r/Collatz • • Sep 28 '26

Covariance between 1≤n_i≤2^j and the number of odd steps for each n_i

5 Upvotes

The experiments show that, for a given j>3 (the number of steps in the shortcut Collatz sequence) and 2j consecutive starting numbers n_i = 1,2,...2j, the covariance between all n_i and the number of odd steps for each n_i is always positive.

Has anyone come across proof of this? Thanks!


r/Collatz • • Sep 27 '26

We do need a general formula to reducing the circuit

0 Upvotes

The original Collatz function is very simple, consisting of only two branches, odd and even branches:

C(n) = 3n + 1 | if n is odd

C(n) = n/2 | if n is even

Since we know that 3n + 1 is always even when n is odd, we can just divide by 2 on the first branch. That's what Terras does:

T(n) = (3n + 1)/2 | when n is odd

T(n) = n/2 | when n is even

What I'll show next is the further reducing circuit like Terras did. However, since v₂ isn't independent, we can't manipulate it through parametrization.

Here is what Syracuse does:

S(n) = (3n + 1)/2ᵛ

where v = v₂(3n + 1)

And then Steiner comes in. If 3n + 1 can be divided by 2 once and repeated for an amount h times (Steiner uses the letter k, but I prefer h, which means the height of the 2-adic valuation), then the result will be partially in the form of a geometric series:

F(n) = [3ʰn + (3⁽ʰ⁻¹⁾ + 3⁽ʰ⁻²⁾2 + ... + 3·2⁽ʰ⁻²⁾ + 2⁽ʰ⁻¹⁾)] / 2ʰ

By the geometric series formula:

F(n) = [3ʰ(n + 1) - 2ʰ] / 2ʰ

F(n) = 3ʰ((n + 1)/2ʰ) - 1

F(n) = (3/2)ʰ(n + 1) - 1

where h = v₂(n + 1)

Since n + 1 needs to have v₂ = h, then n + 1 must be in the form 2ʰc, which gives us

n = 2ʰc - 1

with some odd c that fulfills this condition.

This form captures how many rising steps occur before it falls by division by 2ᵛ, where

v = v₂(3ʰc - 1).

We can manipulate this to find a number with the "height" larger and larger by choosing the value of h in n = 2ʰc - 1 through parametrization.

A Generalized version was already discovered and written by u/gonzomath in this post.

Suppose we have a set D, C, and N of sequences of the Collatz function:

Divergent, Cycle, and Normal (where Normal means that the sequence eventually collapses to another cycle).

To prove the conjecture, we need to prove (all of this is in terms of natural-number inputs):

  1. C is impossible to exist except for 1 → 2 → 1

  2. D is impossible to exist

  3. Every N collapses to C = {1, 2}

Since N depends on D and C, it doesn't affect our proof whether N is infinite (well, it can easily be proven) or not.

To prove whether D exists or is impossible to exist, we need to guarantee that there is always a method for reducing the sequences of a number n ∈ D, like Terras, Syracuse, and Steiner did.

To guarantee C, we have Steiner's method using Baker's Theorem. And again, it was already posted by u/gonzomath here and it also has great progress.

My idea is: assume there exist D and C.

D = {n₀, n₁, .....} which has infinitely many members.

C = {n₀, ..., nₛ}, where s is the size of the set, and when we apply the Collatz function, it goes back to n₀.

Since D exists:

When we use the Terras function, what we do is simply reduce the sequences to be like this:

D = (T₀, T₁, T₂, ....)

where T = {a, b} and b = a/2.

When we use the Steiner function, we reduce D to a collection of subsets R, where

R = {odd, even, odd, even, ..., odd, even}

followed by several even numbers, so:

D = {R₀, e₀, e₁, ..., R₁, ......}

Suppose we have a general formula for reducing its own result. Then the general formula should be:

G(n) = G(R, e₀, e₁, ..., eᵢ)

The problem is that each Steiner block also needs to be passed through the Syracuse reduction. In particular, after applying the Steiner reduction with height h, we obtain something of the form n = 2ʰc - 1

and the result of the corresponding block is F(n) = 3ʰc - 1.

Syracuse then requires us to determine how many factors of 2 this result contains: v = v₂(3ʰc - 1).

Therefore, the recursion has to handle both the Steiner parameter h and the resulting Syracuse valuation v. In other words, G must not only describe how the sequence is grouped into Steiner blocks, but also determine the amount of 2-adic reduction that follows each block.

So I am looking for a general reduction:

G(n) = G(h, v) or, more explicitly, a function that takes a Steiner block and automatically determines the corresponding Syracuse step.

G²(n) = G(G(n))

...

Gⁱⁿᶠⁱⁿⁱᵗʸ = G(...G(n))

If the set is a cycle, then there exists some i where Gⁱ·ᵏ(n) goes back to the first element.

If it is divergent, then for every i, Gⁱ(n) always produces a new number.

If there is no D and no C (other than 1 → 2 → 1), then

Gⁱⁿᶠⁱⁿⁱᵗʸ = 1.

Any idea how to find this recursion?


r/Collatz • • Sep 26 '26

A Redirection

10 Upvotes

As many posts recently seem to be exploring the same core ideas with different language, I thought it might be interesting to share a set of questions/observations that I've found compelling over the years - in the hope that someone may find one or more of them similarly interesting and hopefully have more luck than I in unraveling them.

Many of these are conceptual, rather than well-formulated, and correct formalization would be a non-trivial step in itself. Still, I think they're interesting ideas and would love to either see someone make genuine progress on one (or more!), figure out how to formalize them in ways that allow more precise investigation, or formalize them in a way that shows they're already known and a dead end.

Some of these are obvious, some of them are questions, some are conceptual ideas, some are just opinions.

In no particular order:

  1. Collatz is not a number theory problem. It's easily expressible in number theoretic terms, but the fundamental objects live somewhere else. In this expression, integers are coarse shadows of richer objects and the richer objects remain hidden. This does not refer to arbitrarily decorating integers with invented parameters, but to fundamentally different objects. For example, over the years, we've seen many problems unexpectedly fold into the realm of modular forms. Perhaps the collatz transforms similarly belong natively to some other realm we haven't yet considered.

  2. If #1 is true, the solution may already exist - in pieces - within the literature from widely different areas of math. If so, this is a genuine area where LLMs could offer a big advantage. The trick then becomes to find the right "idea" rather than find the right "math." Since all LLMs harvest user conversations for training purposes, everyone who uses LLMs to work on Collatz should be asking this question a lot.

  3. There are no local obstructions to cycles. This is an area that 90% of ideas seem to attack, whether through modular arguments, funnels, pigeonholes, or exotic/invented "structures" that just rename similar fundamental tools. The affine structure of the collatz process doesn't just allow cycles, it kind of likes them. As really simple high level talking points: the collatz process does produce cycles - several in the negative integers, lots in the rationals, and a preposterous amount in the 2-adics (though many of those are phantoms). We aren't going to find some local reason or some exotic structural latch to prevent cycle formation. It's like the map can produce cycles but it just...doesn't. Lots of arguments get stuck in trying to pick apart some local reason for the "doesn't" part, but that's probably a dead end.

  4. In the spirit of #1 and #2, Collatz may be more about bits, edges, and complexity than about "numbers." Something akin to a question about the physics of computation. The collatz yang tiles, the binary/ternary conversion engine, and other existing work are enticing lenses into this approach. The complexity part is the most motivating to me and I've spent a fair amount of time trying to understand what "complexity" might mean, how it's expressed, and how the transforms might create and destroy it. This is under-explored in the literature.

  5. There's no good reason in number theory that we haven't found a counter example yet, if one exists. There's no exotic structure in the collatz map to suggest we shouldn't find some early witness to whatever behavior it's capable of producing. There are possible arguments to be made through the lens of complexity and computation (see #4), but overall, it's weird. There is precedent in other conjectures for not finding counterexamples until ridiculously big values, but in those cases it's generally understood why we have to wait so long. That understanding doesn't exist for collatz. Either way, there's something to be learned from the fact that we've checked a lot of numbers and haven't found anything unusual.

  6. The solution space isn't necessarily an infinite problem. There are "simple" applications of this idea (it's proven that if you can show every member of any infinite arithmetic progression reaches 1, that's enough to prove all numbers reach 1), "intermediate" applications of this idea (it's proven that every collatz orbit must intersect 20 mod 27), and "hard" applications of this idea - I prefer the one that says something like: the map is self similar. you don't need to prove every integer, you just need to prove some finite subset and then show there are no new patterns spawned by other integers, just the same things over and over at different scales. Tao's big paper poked at this a bit and work in adjacent areas like Busy Beaver, Cellular Automata, and Finite State Transducers hints at it.

  7. Similar to #6 but from a different angle: The collatz transforms can't tell an infinite number of integers apart from one other. Instead, the transforms can only "see" a limited amount of information about any individual integer and only processes that limited amount of information. The problem is finite, even though the integers are infinite, because the infinite part doesn't matter. I like this one a lot and have spent a fair amount of time on it because there are many ways to approach it. You could use the idea from #1 (the fundamental object isn't really the integers), the idea from #4 (only some segment of the bitstream is important), or go really deep into things like "what is an integer, really?" Tao discussed this last one a bit on his blog a while back, in the digestion of an AI-assisted proof, by suggesting one way to conceptualize an integer is something like the cloud of divisibility histories behind it. This is quite abstract, but that's what makes it interesting.

  8. In the spirit of #7, maybe the input itself is the interesting thing. i.e., the transforms are just a computer that accepts and processes input. But the program, the instructions, the interesting part, is the input itself. Understanding things about the deep structure of the input might be more important than understanding the computer that does dumb processing. Also, maybe we should stop throwing away the halving steps as "uninteresting."

  9. Going one step further and flipping the script from #8, the collatz transforms may embed some type of hidden, non-trivial computation. I gravitate again to the binary/ternary conversion engine (which also tracks parity, by the way) as a conceptual proof of concept for this idea. i.e., what if transforms that look simple on the surface only look that way because they're a lucky engineering compression of a much richer computational back end that we haven't yet discovered.

  10. There is no local-to-global bridge. Instead, there are only local steps and the emergent phenomena those local steps generate. Like there's no such thing as a line of ants, just the emergent behavior of individual ants doing their own thing. Sometimes I find this one very motivating and other times very defeating.

  11. Whatever set of things we're looking for is present in every orbit. There's a tendency to study exceptional orbits (like 27) or really specific minute mechanisms, but every orbit follows the same rules and contains the same mysteries.

  12. Whatever set of events/behaviors/alignments is required to produce exceptional behavior (cycles or divergence) has to happen early in an orbit, not "sometime later on." The ultimate fate of any processed input is determined very quickly.

May the "odds" be ever in your favor.


r/Collatz • • Sep 26 '26

More on Fractional Loops in the Collatz Conjecture

0 Upvotes

The closer examination of tables of fractional solutions of loop equations leads to a new equation for prime numbers.

See this link,

https://drive.google.com/file/d/16GujjKKuEnJDoY5b95F2NNjeWQ6I6QMk/view?usp=sharing

The Collatz conjecture has a connection to prime numbers, which may help with its proof.


r/Collatz • • Sep 25 '26

Are those new identities?

0 Upvotes

Hey - I have been working with Rocq and Lean because I somehow found some new relations while applying QFT on top of Collatz. And idk i couldnt find these identities that i derived. Computationally they held up - and after hours of testing I Rocqed and Leaned them:

Edit:

please ignore my previous statement - I have made Collatz via a poincare inequality computationally down to proving a single - existing constant.

Sorry If I dont give you the definitions yet. But this was unexpected. Mazure had a recent paper. That build on top of Monk. And now I somehow used some combination of Lagarias and Tao to get this. Everything is screen captured - my work - because NSE 3D was also my work. And I send out an Email to my Unis profs - they ignored me - very long so - and then I was mad and uploaded to GPT. And a month later they uploaded and I was happy.

I was not wrong then - this time - what I did here - Is the work that the mathematics that sit behind the NSE proof live. In full action. Like I got some bridge done that linked Topology - like basic metric spaces to Hopf algebra. I also have a Lean native - proof of the Riemann Hypothesis - that is covered by only building on top of Leans native Theorems. I uploaded this on github.

On top of this - I have proven Pi non normality - and I found some neat way to generate sequences that converge to pi - faster than any known sequence. I can derive deterministically - a formula with N digits per term. It somehow closes the work of Ramanujan - because he found many identities that i calibrated my generalisations on. This is bonkers. Atleast this sub here didnt ban me. Like the people at stackexchange did - like the people in the maths and physics subreddit did.

I will just keep on working. I had some progress in Birch and Swinnerton-Dyer conjecture

and also YM.


r/Collatz • • Sep 25 '26

Is this confluent node and confluence chain method valid?

Post image
1 Upvotes

Since applying the confluence method to the tree I built, I found

  1. All positive integers are covered, and the nodes are disjoint, so no positive integer appears in more than one node

  2. For 0, 1, and 2 mod 4, the descent follows by induction to smaller case.

  3. For 3 mod 4:

a. Direct descent: 3, 11, 19, 23 mod 32

b. For the n ≡ 27 mod 32 branch, the residue classes 27, 91, and 251 mod 128 are resolved by confluence, while 59, 123, 187, and 219 mod 256, together with 315 mod 512, are resolved by direct descent.

c. For the n ≡ 15 mod 32 branch, the residue classes 47, 111, and 207 mod 256 are resolved by confluence, while 15 mod 128, 79, 143, 175, and 271 mod 256 are resolved by direct descent.

d. For the n ≡ 31 mod 32 branch, the residue classes 31, 63, and 223 mod 256 are resolved by confluence, while 95 mod 256 is resolved by direct descent. The residue class 127 mod 256 is treated as a lateral node.

e. For the n ≡ 7 mod 32 branch, the residue classes 71, 103, and 167 mod 256 are resolved by confluence, while 7 mod 128 and 135 mod 256, together with 39 and 199 mod 256, are resolved by direct descent.

f. The confluent nodes are resolved through the corresponding confluence chains. Example

N27=(729n+925)/ 128, n=27, 155, 283, 411, ... t(n)= 161, 890, 1619, 2348, ..

Confluence to

L41= (243n+341)/64 n=41, 105, 169, 233, 291, 361, 425, ... t(n)= 161, 404, 647, 890, 1133, 1376, 1619, ...

It's mean that image N27 subset image L41

4. Confluence chain

It consists of the confluent nodes mentioned above, covering the 1 and 3 mod 4 nodes from N27 to I23, where I23 (23 mod 32) is proven to be direct descent. The diagram is shown in the post.

Along the transitions between confluent nodes, some nodes fall outside the confluence chain and are therefore treated as lateral nodes.

5. Lateral nodes

A lateral node is a node that leaves the main confluence chain and is handled through confluence to a descent node, followed by direct descent.

a. The lateral nodes that leave the main confluence chain are handled by confluence to previously resolved nodes. In terms of residue classes, these include 127 mod 128, 347 mod 512, 191, 231, and 415 mod 512, 487, 763, 935, and 1019 mod 1024, 795, 991, and 1503 mod 2048, and 2015 mod 4096.

b. The remaining lateral nodes are resolved by direct descent. In terms of residue classes, these are 999, 423, 507, 735, and 575 mod 1024, together with 4063 mod 4096.

6. The critical point is the transition between confluent nodes: are there any lateral nodes leaving the main confluence chain that have not yet been resolved?

Edit: The latest version of the paper, v15, has been uploaded to Zenodo https://zenodo.org/records/23133589

Update — Oct 17, 2026: Collatzogin Tree v16 published: confluence network = confluence chain + tributary node + lateral node https://zenodo.org/records/23428552

Update 26 Oct 2026 I’ve just uploaded v17 of my preprint to Zenodo: https://zenodo.org/records/23653911

The main structural additions in this version:

  1. Confluence network → DAG. The residual 3 mod 4 branches are organized as a finite directed acyclic graph G_{\mathcal N}. The DAG has three types of vertices—principal confluence chain, tributary nodes, and lateral nodes—and a DAG Descent Theorem proved by reverse topological induction.

  2. Mod 32 completeness. Four residue classes in the 3 mod 4 branch—3, 11, 19, 23 mod 32—already have direct descent established (Propositions H_3, I_{11}, I_{19}, I_{23}).

  3. The remaining four classes—27, 31, 15, 7 mod 32—are analyzed branch by branch. A Coverage Lemma then shows that every residual node is accounted for by direct descent, by the principal confluence chain, by tributary-node confluence, or by lateral-node resolution; equivalently, every residue class r = 3 mod 4 modulo 32 is covered at some modulus 2m.


r/Collatz • • Sep 25 '26

What i realised today about Collatz

0 Upvotes

Collatz is just a way of making long division give you a divisible number. So until someone thinks of a short cut to long division Collatz will continue unsolved. But really in way it is solved because its a tool that works.


r/Collatz • • Sep 23 '26

Super-liminal Drain logic.

2 Upvotes

I had a fun idea in a dream last night. In Backrooms lore, each level is infinite. There are also possibly infinite levels. There are also spaces in various lore that center around impossibly large drainage systems. My idea is to view things like an engineer would. For each odd value, a pump exists to send it over a hill the odd value marks. The even values mark downward slopes and are fitted with a drain instead. You can imagine as many drains funnel to one, that it gets overwhelmed, so it therefore must be bigger with a higher throughput. As you get to larger and larger drains, you eventually find the final drain. Falling in means no more pumps. The drains all have little wheels that produce power for the pumps. You are tasked with routing power from the drains to the pumps in a methodical way, endlessly. You are special, because you work on the hardest line, one that some say has more pumps than drains....


r/Collatz • • Sep 22 '26

Collatz Conjecture in desmos

Thumbnail
desmos.com
0 Upvotes

r/Collatz • • Sep 22 '26

The Collatz conjecture - manic

3 Upvotes

r/Collatz • • Sep 22 '26

Decades? Centuries? Never?

3 Upvotes

This problem has been going on for 82 years now, and it's making me question, will this problem ever be solved at some time? If so, when?


r/Collatz • • Sep 21 '26

my feeble attempt at a Collatz related image

Post image
14 Upvotes

I am aware that it may not prove anything, but I think it says something.

package dk.jhh.collatz;

import javax.imageio.ImageIO;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.math.BigInteger;

import java.util.ArrayList;

import java.util.List;

public class Collatz {

private static int[] RGB = {0x000000, 0x00FF00, 0x0000FF, 0xFFFFFF};

public static void main(String[] args) throws IOException {

BigInteger n = new BigInteger(

"11111111111111111111111111111111111111111111111111111111111111111111111" +

"00000000000000000000000000000000000000000000000000000000000000000000000" +

"11111111111111111111111111111111111111111111111111111111111111111111111" +

"00000000000000000000000000000000000000000000000000000000000000000000000" +

"11111111111111111111111111111111111111111111111111111111111111111111111", 2);

BigInteger remainder = BigInteger.ONE;

BigInteger divisor = BigInteger.TWO;

List<BigInteger> list = new ArrayList<>();

while(!n.equals(remainder)) {

list.add(n);

if(!n.mod(divisor).equals(BigInteger.ZERO)) {

n = n.multiply(BigInteger.valueOf(3)).add(remainder);

}

remainder = remainder.multiply(BigInteger.TWO);

divisor = divisor.multiply(BigInteger.TWO);

}

list.add(n);

int width = (n.bitLength()+1)/2;

int height = list.size();

BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

for(int y = 0; y < height; y++) {

for(int bitIndex = 0; bitIndex < width*2; bitIndex+=2) {

int value = list.get(y).shiftRight(bitIndex).intValue() & 3;

int x = width - bitIndex/2 - 1;

image.setRGB(x, y, RGB[value]);

}

}

ImageIO.write(image, "png", new File("collatz.png"));

}

}


r/Collatz • • Sep 20 '26

The Apology

3 Upvotes

Here's the thing, when I made a post here for a proof that no number can escape in this process, all I did was prove that no predictable escapes can happen. You guys pointed that out, and I felt so shaken that I ended up deleting the post altogether. So I made this as an apology for that. I feel like you did that because someone else already proved that, so is there something new I can try proving?


r/Collatz • • Sep 20 '26

Pratt coordinates and surreal numbers

1 Upvotes

Please find attached a report on Pratt coordinates and surreal numbers applied to the Collatz problem. No claim of proof of the conjecture is made. https://github.com/githubuser1983/collatz/blob/main/pratt_collatz_parity_surreal.pdf


r/Collatz • • Sep 19 '26

Follow-up to the centered-residue escape result: aperiodic Entry and conditional nontrivial-cycle rigidity

Post image
0 Upvotes

This is a follow-up to my earlier centered-residue escape post:
https://www.reddit.com/r/Collatz/s/OiyfZkfiDt

The earlier result was downstream.

Roughly speaking, once one fixed positive-integer orbit repeatedly enters a sufficiently small centered-residue regime, arithmetic rigidity can be used to force an escape.

That leaves a natural upstream question:

What forces one actual Collatz orbit into that centered-residue regime in the first place?

I have now published an Entry-side result addressing that question, together with a separate conditional result for the positive nontrivial-cycle branch.

Neither result claims a proof of the Collatz conjecture.

Entry Program I — aperiodic branch

Future-Minimum Critical Corridors and Beatty Clock Rigidity in Accelerated Collatz Dynamics:
https://zenodo.org/records/22845983

The current aperiodic architecture is
positive aperiodic survivor
-> Entry I
-> centered-residue realizability [OPEN]
-> Delta-Core Exit
-> contradiction.

Entry I develops the chain
future minima
-> critical corridors
-> exact Beatty-clock rigidity
-> reverse first-passage structure
-> relevant dyadic-fibre capacity scale.

But this structure alone does not yet show that one fixed positive-integer orbit must realize the centered-residue regime required downstream. So the realizability bridge is left explicitly OPEN.

Cycle Exclusion Program I — nontrivial-cycle branch

Fine-Phase Defect Rigidity in Record-Critical Accelerated Collatz Cycles:
https://zenodo.org/records/22846197

This is a logically separate periodic branch.

Under the explicit record-critical hypotheses (H1)-(H5), the paper develops the chain

endpoint-state fine-correction determinization
-> fine-factor rigidity
-> defect syndeticity
-> positive-density fine-phase defects
-> capacity-scale localization.

But the global reduction that would force every hypothetical positive nontrivial cycle into this record-critical sector is still OPEN.

So the current periodic architecture is
positive nontrivial cycle
-> Cycle I
-> global reduction / terminal exclusion [OPEN]
-> contradiction.

The periodic branch does not pass through Delta-Core Exit.

My questions are these:

For the aperiodic / Entry I branch:
• Can the short-gap Beatty step be strengthened?
• Can more arithmetic information be extracted from the reverse first-passage structure?
• Can the capacity-scale conclusion be pushed further?
• Most importantly, is there a route from this structure to centered-residue realizability for one fixed positive-integer orbit?
• If first-passage / capacity information is insufficient by itself, what genuinely independent arithmetic information is missing?

For the nontrivial-cycle / Cycle I branch:
• Are (H1)-(H5) used only within their stated scope?
• Is there any hidden dependency or reuse of information in the chain

fine-factor recurrence
-> defect density
-> capacity-scale localization?
• Is there a stronger route to the required global reduction?
• Can the record-critical sector be reached from a more general hypothetical nontrivial cycle without adding a comparably strong new assumption?

More generally:
Are there counterexamples, missing hypotheses, hidden information reuse, cleaner formulations, or completely different ways to attack either OPEN bridge?

This program is not a declaration of a proof of the Collatz conjecture.

What I am trying to do instead is make the structure of the problem explicit: where the argument currently closes, where it stops, and exactly which questions remain OPEN.

I hope that makes it easier for the next question to begin where the previous one ended. That is also why the dashed boxes are left visible in the figure.

I would rather show clearly where the program is still open than make it look more complete than it is.


r/Collatz • • Sep 18 '26

Is there a way to know if some number grow to infinity?

2 Upvotes

Suppose N = {a_0.....a_infinity}. Even though we know that a_0 to a_i results in smaller numbers, it doesn't mean that a_j < a_0 in term j > i . How can we create a strict condition so that at some point the numbers will always increase and not periodically?


r/Collatz • • Sep 18 '26

It's been a while, but I found a pattern I hadn't considered before.

0 Upvotes

We usually look at Collatz going down to or up from 1, but lately I've been considering it from each integer.

For background, we know that multiples of 3 can only be the origin of a path on Collatz, but there are infinite numbers, infinite multiples of 3, and infinite paths, so how can we possibly prove them all?

By going backwards from each and every integer through the path of least resistance.

Starting from 1, check if the number is a multiple of three, multiply by 2, check if it meets 3x+1. If it does, subtract 1 and divide by 3. If it doesn't, multiply by 2 again and do the same. Repeat until you reach a multiple of 3.

1, naturally, is infinite and multiplies by 4 infinitely.
3, is a multiple of 3.
5, multiplies by 2, then reduces to 3, where it terminates.

You end up with a pattern

4, 4, 4, 4
3
2, 3
4, 3
3
2, 4, 3
4, 2, 2, 4, 3
3
2, 2, 4, 3
4, 4, 3
etc

These patterns seem random, but they are not. They are 100% predictable and 100% finite, with the obvious exception of the number 1.

For 1 length:
2 = 6x+5
3 = 6x+3
4 = 6x+1

For 2 length:
2, 2 = 18x+17
2, 3 = 18x+5
2, 4 = 18x+11
4, 2 = 18x+13
4, 3 = 18x+7
4, 4 = 18x+1

This means that every single odd integer (and thus every single integer) has paths of finite length that extend behind it, however arbitrarily long, in a predictable pattern.

Since every integer is represented and calculated in this matter, there is no way for an integer to go above itself to runaway without reappearing on this chart.

5 doesn't need to reappear, because it goes down to 1, 13 goes down to 5, etc. But 41 goes down to 31, then up to 47, causing it to reappear. And every pattern that starts like 47 (2, 4, 2) will be in number 54x+47

These patterns can be extended as far as you can go, with them always cycling in that same order, 4, 3, 2, 4, 3, 2 (again that's a number that needs to be multiplied by 4, then a multiple of 3, then a number that needs to be multiplied by 2)

This is regular, periodic, and infinite.

And for this reason, I believe we have proof that every number must therefore decrease to 1.


r/Collatz • • Sep 17 '26

4^(n+1).c+1 merge with 2^n.c-1 if and only if v2(3^n.c-1) =2

3 Upvotes

In the accelerated Collatz map https://www.reddit.com/r/Collatz/s/AGKyGBYPm0

4^(n+1).c+1 -> 3^(n+1).c+1 [1]

and 2^n.c-1 -> 3^n.c-1 [2]

Since [2] happens, I want to focus on the last sequences instead.

Suppose we have a number of the form

q = 3^n.c - 1

where v2(q) = 2. [3]

Applying Collatz to q produces

3q/4 + 1

= (3(3^n.c - 1) + 4)/4

= (3^(n+1).c - 3 + 4)/4

= (3^(n+1).c + 1)/4.

Thus, the sequence merges into the form in [1].

The case c = 1 is excluded here, since v2(3^n - 1) = 1 when n is odd and >= 3 when n is even, never be 2.


r/Collatz • • Sep 17 '26

Interesting mapping

0 Upvotes

I was playing around and I found this mapping. I suspect it's already known but I found it interesting.

If you have a number that can be written as 4a3bn+1, it will map to 3a+bn+1.

And it'll do it in 3a+1 steps, which I think is funny.


r/Collatz • • Sep 16 '26

Cycle of Huge Gap

0 Upvotes

Can an AI generates a Collatz like sequence or Kaakuma sequence that second cycle starts after 40 digits number with minimum constraints of sum of absolute value of constant terms less than 20 digit number ?


r/Collatz • • Sep 16 '26

Subproject: From dome to dome

Post image
0 Upvotes

Follow-up to Where are the root of each dome located in the left side of another dome ? : r/Collatz.

The table below presents the possible transitions from one dome to the next one, for each type of tuple. It will be completed little by little and each case characterized if possible, like we did in the cited post.

While creating it, I came under the impression that the extrem cases for each dome, made of truncated bridges - one in the left wing, two in the right wing - might need to be treated separately. Time will tell.

Project "Tuples and segments" in 13 pages : r/Collatz


r/Collatz • • Sep 16 '26

Odd remainder Recursion from 3^2^n -1 after divided by 2^v

1 Upvotes

I was already posted this in some private group on facebook, it doesnt really matter but probably usefull for someone that are trying to figure it out about 3^n .o-1 after divided by 2^v

first of all this number isnt special, by the LTE theorem we can say that this number has v2 = n+2. If u dont want to check that ill explain it in a simple term.

since 3^2 -1 = 2^3 then 3^4 - 1 = 2^3 (2^3 +2) = 2^4 (2^2+1)

repeat it n times we get 3^2^n - 1 can be divided by 2^(n+2)
and by adding 2 -> 2^(n+2) k +2 it can only be divided by 2

So, this number has v2 predictable which is n+2 for every 3^2^n-1 and 1 for 3^2^n+1
If its v2 was predictable, so the remainder predictable?yes, but not as simple as that, it exist in the term of recursion, lemme show you:

supposed 3^2^n-1 = An
we get An/2^(n+2) = A(n-1)/2^(n+1) . (A(n-1)+2)/2

supposed An/2^(n+2) = O(n), which mean an odd number after An lost its 2s
then (An+2)/2 = {2^(n+2) .O(n)+2}/2 = 2^(n+1) . O(n)+1

Therefore An/2^(n+2) = O(n) = O(n-1). (2^n . O(n-1)+1) = 2^n . O(n-1)^2+O(n-1)

since we already know that O(1) = 3^2 -1/2^3 =1

then we can predict every 3^2^n-1 after divided by 2^(n+2)

O(1) = 1
O(2) = 2^2 . 1^2 +1 = 5
O(3) = 2^3 . 5^2 + 5 = 205
...
O(n) = 2^n . O(n-1)^2 + O(n-1)

why is this important for someone studying 3^n .o-1/2^v?
If 3^n = 2^p .k+1 and o = 2^p .k-1, the result would be 2^2p .k -2 which can only be divided by 2 once becoming 2^(2p-1) .k - 1 and this happen to 27 which equal 2^2.(2^3-1) -> 3^2(2^3-1)-1

notice that 3^2-1 = 2^3 earlier, so 3^2 = 2^3+1
And when we divided the product by 2 once, it does becoming 2^5 -1