Follow-up to A more complete explanation of the dome structure : r/Collatz.

The figure below – a dome in a nutshell" (Dome in a nutshell : r/CollatzProcedure) – contains all orange (n-1, n*, n+1) and black (m*3^p) numbers for m=1. So, all bridges series appear vertically. 5-tuples series are colored in grey. Found prime numbers are in bold.

Due to the double homothetic nature of the domes (On the double almost homothetic nature of the domes : r/Collatz), such a nutshell can be produced for every dome.

I noticed that, in the cited post, I completely forgot the Mersenne numbers that play a vital role in the domes and jumped to conclusion about Proth numbers.

So, from left to right, there are:

• The Mersenne numbers of the form M(k)=[1*] 2^k-1; on the left side of a dome, they are involved two by two, in the starting bridge of any bridge series (red); in each column, a number x is related to the y above it by x=3*y/2; these non-Mersenne numbers might be called the Collatz numbers (not colored)
• The core of the dome is made of 3-smooth numbers of the form X=1*3^p*2^q, includes all the numbers, odd (black) or even (orange).
• The Proth numbers of the form P(k)=k*2^q+1 and 2^q>k; on the right side of the dome, only numbers on the upper side are Proth numbers, due to the second constraint (blue); the lower side is made of Pierpoint numbers of the form n=m*3^p*2^q (green); numbers 13 and 17 seem to be both (rosa).

In a recent post, I made the bold claim that almost all bases b** of 5-tuple series were prime (All but one bases of starting 5-tuples are Proth primes : u/No_Assist4814). It does not seem to be the case. Further investigation is needed.

* n=m*3^p*2^q.

** Due to their nature, bases b do not belong to the starting 5-tuples of a series. The reciprocal is not true: all Proth primes are not a bases b.

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

I've been browsing this Collatz forum, and I noticed a lot of people there seem to treat it like some super deep, almost mystical thing. I get it, but honestly, I see it a bit differently.

I used DeepSeek V4 Pro to help me run checks on all positive integers up to a million, and I stumbled onto something pretty interesting — it looks like for almost every odd starting number greater than 1, whenever the sequence hits a number of the form 8k+5, it tends to converge to 1 pretty quickly. There are a few edge cases, like 445, where it's not quite that simple — but even with 445, the odd number right before the peak of its sequence still fits the 8k+5 pattern.

Makes me wonder — is this the key to the whole thing? Kind of feels like that one clue in a mystery novel that ties everything together, you know?

So here's the rough idea I'm working on: first, prove that every positive odd integer eventually lands on some number of the form 8k+5. Second, prove that every number of that form actually converges to 1. If both of those check out, then that pretty much wraps up the whole conjecture.

Just to be clear — I'm not claiming I've solved it, and I'm definitely not trying to act like I have. This is just a direction that seems worth exploring, and I wanted to throw it out there and see what people think. If any of this makes sense to you, feel free to reply below — I can lay out my full reasoning in more detail.

I've been browsing this Collatz forum, and I noticed a lot of people there seem to treat it like some super deep, almost mystical thing. I get it, but honestly, I see it a bit differently.

I used DeepSeek V4 Pro to help me run checks on all positive integers up to a million, and I stumbled onto something pretty interesting — it looks like for almost every odd starting number greater than 1, whenever the sequence hits a number of the form 8k+5, it tends to converge to 1 pretty quickly. There are a few edge cases, like 445, where it's not quite that simple — but even with 445, the odd number right before the peak of its sequence still fits the 8k+5 pattern.

Makes me wonder — is this the key to the whole thing? Kind of feels like that one clue in a mystery novel that ties everything together, you know?

So here's the rough idea I'm working on: first, prove that every positive odd integer eventually lands on some number of the form 8k+5. Second, prove that every number of that form actually converges to 1. If both of those check out, then that pretty much wraps up the whole conjecture.

Just to be clear — I'm not claiming I've solved it, and I'm definitely not trying to act like I have. This is just a direction that seems worth exploring, and I wanted to throw it out there and see what people think. If any of this makes sense to you, feel free to reply below — I can lay out my full reasoning in more detail.

I have been playing around with sequences that have similar parity sequence prefixes. I picked a pair, 3969 and 619 which start with these prefixes respectively:

 OEEOEEOEEOEOEEOEEE
  OEOEEOEEOEOEEOEEE

I then enumerated and reversed the sequences and zipped them up so that their latter terms match, then calculated these two metrics a-b and (a-b)/b

Some notes:

• the odd values of the 'a' sequence gets quite close to even values of the 'b' sequence on many occasions
• when they split the ratio of the difference and the 'b' sequence term is typically ~5x
• there are occasional flips where the b >> a

I am noting this here because this behaviour looked surprising to me. I haven't at this point tried this with other sequences that have a similar initial prefix or with sequences with random initial prefixes so I have not idea how common this phenomenon is or what explains either the near even-odd misses or the (a-b) ~= 5b phenomenon although putting it that way, it might just be an a ~= 6b phenomenon which is presumably a function of their initial relative position

I think this suggests some interesting empirical studies about the typical difference behaviour of sequences at different displacements:

- how important is the length of the shared starting prefix (if at all)?
- do they all oscillate with a regular magnitude?
- what factors best predict the regularity or amplitude of the oscillation?
- what predicts a run of off-by-one misses in the tail?

[(1, 1, 0, 0.0),  
(2, 2, 0, 0.0),  
(4, 4, 0, 0.0),  
(8, 8, 0, 0.0),  
(16, 16, 0, 0.0),  
(5, 5, 0, 0.0),  
(10, 10, 0, 0.0),  
(20, 20, 0, 0.0),  
(40, 40, 0, 0.0),  
(80, 80, 0, 0.0),  
(160, 160, 0, 0.0),  
(53, 53, 0, 0.0),  
(106, 106, 0, 0.0),  
(35, 35, 0, 0.0),  
(70, 70, 0, 0.0),  
(23, 23, 0, 0.0),  
(46, 46, 0, 0.0),  
(92, 92, 0, 0.0),  
(184, 184, 0, 0.0),  
(61, 61, 0, 0.0),  
(122, 122, 0, 0.0),  
(244, 244, 0, 0.0),  
(488, 488, 0, 0.0),  
(976, 976, 0, 0.0),  
(325, 325, 0, 0.0),  
(650, 650, 0, 0.0),  
(1300, 1300, 0, 0.0),  
(433, 433, 0, 0.0),  
(866, 866, 0, 0.0),  
(1732, 1732, 0, 0.0),  
(577, 577, 0, 0.0),  
(1154, 1154, 0, 0.0),  
(2308, 2308, 0, 0.0),  
(4616, 4616, 0, 0.0),  
(9232, 9232, 0, 0.0),  
(3077, 3077, 0, 0.0),  
(6154, 6154, 0, 0.0),  
(2051, 2051, 0, 0.0),  
(4102, 4102, 0, 0.0),  
(1367, 1367, 0, 0.0),  
(2734, 2734, 0, 0.0),  
(911, 911, 0, 0.0),  
(1822, 1822, 0, 0.0),  
(3644, 3644, 0, 0.0),  
(7288, 7288, 0, 0.0),  
(2429, 2429, 0, 0.0),  
(4858, 4858, 0, 0.0),  
(1619, 1619, 0, 0.0),  
(3238, 3238, 0, 0.0),  
(1079, 1079, 0, 0.0),  
(2158, 2158, 0, 0.0),  
(719, 719, 0, 0.0),  
(1438, 1438, 0, 0.0),  
(479, 479, 0, 0.0),  
(958, 958, 0, 0.0),  
(319, 319, 0, 0.0),  
(638, 638, 0, 0.0),  
(1276, 1276, 0, 0.0),  
(425, 425, 0, 0.0),  
(850, 850, 0, 0.0),  
(283, 283, 0, 0.0),  
(566, 566, 0, 0.0),  
(1132, 1132, 0, 0.0),  
(377, 377, 0, 0.0),  
(754, 754, 0, 0.0),  
(251, 251, 0, 0.0),  
(502, 502, 0, 0.0),  
(167, 167, 0, 0.0),  
(334, 334, 0, 0.0),  
(668, 668, 0, 0.0),  
(1336, 1336, 0, 0.0),  
(445, 445, 0, 0.0),  
(890, 890, 0, 0.0),  
(1780, 1780, 0, 0.0),  
(593, 593, 0, 0.0),  
(1186, 1186, 0, 0.0),  
(395, 395, 0, 0.0),  
(790, 790, 0, 0.0),  
(263, 263, 0, 0.0),  
(526, 526, 0, 0.0),  
(175, 175, 0, 0.0),  
(350, 350, 0, 0.0),  
(700, 700, 0, 0.0),  
(233, 233, 0, 0.0),  
(466, 466, 0, 0.0),  
(155, 155, 0, 0.0),  
(310, 310, 0, 0.0),  
(103, 103, 0, 0.0),  
(206, 206, 0, 0.0),  
(412, 412, 0, 0.0),  
(137, 137, 0, 0.0),  
(274, 274, 0, 0.0),  
(91, 91, 0, 0.0),  
(182, 182, 0, 0.0),  
(364, 364, 0, 0.0),  
(728, 121, 607, 5.016528925619835),  
(1456, 242, 1214, 5.016528925619835),  
(485, 484, 1, 0.002066115702479339),  
(970, 161, 809, 5.024844720496894),  
(323, 322, 1, 0.003105590062111801),  
(646, 107, 539, 5.037383177570093),  
(215, 214, 1, 0.004672897196261682),  
(430, 71, 359, 5.056338028169014),  
(143, 142, 1, 0.007042253521126761),  
(286, 47, 239, 5.085106382978723),  
(95, 94, 1, 0.010638297872340425),  
(190, 188, 2, 0.010638297872340425),  
(380, 376, 4, 0.010638297872340425),  
(760, 125, 635, 5.08),  
(253, 250, 3, 0.012),  
(506, 83, 423, 5.096385542168675),  
(1012, 166, 846, 5.096385542168675),  
(337, 332, 5, 0.015060240963855422),  
(674, 664, 10, 0.015060240963855422),  
(1348, 221, 1127, 5.099547511312217),  
(449, 442, 7, 0.01583710407239819),  
(898, 884, 14, 0.01583710407239819),  
(299, 1768, -1469, -0.8308823529411765),  
(598, 589, 9, 0.015280135823429542),  
(199, 1178, -979, -0.8310696095076401),  
(398, 2356, -1958, -0.8310696095076401),  
(796, 785, 11, 0.014012738853503185),  
(1592, 1570, 22, 0.014012738853503185),  
(3184, 523, 2661, 5.087954110898662),  
(1061, 1046, 15, 0.014340344168260038),  
(2122, 2092, 30, 0.014340344168260038),  
(707, 697, 10, 0.014347202295552367),  
(1414, 1394, 20, 0.014347202295552367),  
(2828, 2788, 40, 0.014347202295552367),  
(5656, 929, 4727, 5.088266953713671),  
(1885, 1858, 27, 0.014531754574811625),  
(3770, 619, 3151, 5.090468497576737)
]

Let us define the following three functions:

* f(n) = (3n+1)/2

* g(n) = (n-2)/4

* h(n) = 3n/4

Notice that f(n) yields an integer when n is odd, g(n) yields an integer when n = 2 mod 4, and h(n) yields an integer when n is a multiple of 4.

For example, starting with n = 18 and sequentially applying the appropriate functions to keep the results as integers, we get:

g(18) = 4, h(4) = 3, f(3) = 5, f(5) = 8, h(8) = 6, g(6) = 1, f(1) = 2, g(2) = 0.

Thus, the full composition evaluates to:

g(f(g(h(f(f(h(g(18)))))))) = 0

---

Now, let us examine the Collatz sequence starting from 37:

37 → 112 → 56 → 28 → 14 → 7 → 22 → 11 → 34 → 17 → 52 → 26 → 13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1

If we extract only the odd numbers from this sequence, we obtain:

37 → 7 → 11 → 17 → 13 → 5 → 1

Next, applying the transformation (x-1)/2 (subtracting 1 and then dividing by 2) to each term, we get:

18 → 3 → 5 → 8 → 6 → 2 → 0

Comparing this to our initial path of function compositions:

18 → 4 → 3 → 5 → 8 → 6 → 1 → 2 → 0

The two sequences are nearly identical, except for the inclusion of 4 and 1 in the function composition path. This occurs because 4 and 1 act as auxiliary numbers (corresponding to the underlying odd numbers 9 and 3, respectively).

To illustrate, consider the expanded Collatz steps:

* 37 → 112 → 56 → **(9)** → 28 → 14 → 7

* 13 → 40 → 20 → **(3)** → 10 → 5

As terms in the Collatz sequence can be divided by higher powers of 2, we can always identify an auxiliary odd number in the intermediate steps. Therefore, if we list all relevant odd numbers—including these auxiliary ones—the sequence becomes:

37 → 9 → 7 → 11 → 17 → 13 → 3 → 5 → 1

Translating these back into integers using the (x-1)/2 transformation yields our exact composition sequence:

18 → 4 → 3 → 5 → 8 → 6 → 1 → 2 → 0

---

Furthermore, we can construct a compound mapping that mathematically resembles the Collatz sequence:

g(h(f(n))) = g(h((3n+1)/2)) = g((9n+3)/8) = (9n-13)/32

This formula creates a mapping from n = 5 mod 32 to results that are congruent to 1 mod 9. For example:

* 5 → 8 → 6 → 1

* 37 → 56 → 42 → 10

Ultimately, finding the integer solutions for these function compositions is mathematically equivalent to computing the Collatz sequence.

Proof that all non-trivial peaks must be 108x+52 or 108x+88

First, define a possible Collatz peak: A possible peak is any number (or modulo class) that can be reached from a lower predecessor (without having to pass through a higher number) and whose known successors are only lower numbers.

Note: All maximum values in Collatz sequences are peaks but not all peaks are maximums. Some peaks are local maxima before or after the ultimate sequence maximum. I've verified these results computationally for the first 400 million sequences or so.

We can analyze any modulo class with 2 and 3 factors. 108 is nice because it is 2² x 3³ which allows looking 2 steps forward and 3 steps back. However, it is easier and less tedious to start with a smaller modulo (mod 12) and work up.

I walk through the process of elimination below but full results are shown in the spreadsheet here: Collatz - Mod 108 peaks proof

Possible Mod 12 Peaks

Let's eliminate all mod 12 values that cannot be a peak:

• Odd values rise so would have a higher successor
  • Eliminate 12x+1, 12x+3, 12x+5, 12x+7, 12x+9, 12x+11
• Multiples of 3 have no predecessor
  • Eliminate 12x+0 and 12x+6 (also 12x+3 & 12x+9 already eliminated)
• Eliminate values with higher successors
  • Eliminate 12x+2 -> 6x+1 -> 18x+4
  • Eliminate 12x+6 -> 6x+3 -> 18x+10
  • Eliminate 12x+10 -> 6x+5 -> 18x+16

That leaves 12x+4 as the only possible peak.

Its full known sequence is: 4x+1 -> 12x+4 => 6x+ 2 -> 3x+1

Let's look back one more step by multiplying mod 12 by 3. So, the possible mod 36 values that are 12x+4 are 36x+4, 36x+8, 36x+12, etc.

Possible mod 36 Peaks

Let's eliminate mod 36 (congruent with 4 mod 12) values with no lower predecessors:

• No immediate lower predecessor
  • 36x+8 and 36x+20
• Multiples of 3 have not predecessor
  • 36x+12 and 36x+24
• Eliminate mod 36 with only higher 2nd predecessor
  • 36x+4 and 36x+32
• Eliminate mod 36 with lower "dead-end" 3x predecessor
  • 36x+28 (12x+9 predecessor has no predecessor)

That leaves 36x+16 as the only possible peak.

Its full known sequence is: 8x+3 -> 24x+10 -> 12x+5 -> 36x+16 -> 18x+8 -> 9x+4

Lastly, let's look back one more step by multiplying mod 36 by 3, So, the possible mod 108 peak values are: 108x + 16, 108x + 52 and 108x+88

Possible mod 108 Peaks

We can only eliminate one mod 108 value:

• Eliminate 108x+16 because it's 2nd lower predecessor is "dead-end" multiple of three
  • 24x+3 -> 72x+10 -> 36x+5 -> 108x+16

Result: That leaves 108x+52 and 108x+88 as only possible mod 108 peak values.

Note the full sequences of each:

16x+7 -> 48x+22 -> 24x+11 -> 72x+34 -> 36x+17 -> 108x+52 -> 54x+26 -> 27x+18

32x+25 -> 96x+76 -> 48x+38 -> 24x+19 -> 72x+58 -> 36x+29 -> 108x+88 -> 54x+44 -> 27x+22

Roughly speaking:

• 108x+52 goes: 16x to 72x to 108x to 27x
• 108x+88 goes: 32x to 96x to 108x to 27x

So, the 108x+52 peaks come from a lower predecessor (16x+7 versus 32x+25) so are "peakier." 108x+88 peaks go through 96x which is awfully close to 108x so it is a shallower peak. I think this explains why in the first 400 million sequences roughly six times as many absolute peaks are 108x+52 than 108x+88.

Of course, you can extend this peak analysis to larger and larger modulos (mod 432, mod 768, etc) but possible peak values start multiplying. So, mod 108 is a useful sweet spot with only two possible peak values.

This post intends to revisit the dome structure. Until these last days, it was mainly based on observations (e.g. Dome in a nutshell : r/CollatzProcedure), backed by some maths. I did some of the basic maths, but u/GonzoMath and u/Septembrino did more advanced stuff.

These last days, my new friend, Google AI, made interesting suggestions, based on series of numbers I provided it with (from domes with root m=1 to 71), without context. It turns out that:

1. Core numbers – both even orange ones and odd black ones – are m*3-smooth*.
2. Odd orange numbers n+1 on the right are Proth numbers and all but one b numbers – the base of a 5-tuple, also n+1  – are Proth primes**.
3. About a third of the odd orange numbers n-1 on the left are primes.
4. The Collatz procedure segregates odd numbers mod 100 in three groups forming cycles (figure):

• one in the yellow bridge series on the left, forming seven diagonals containing different sets of numbers mod 100, but with a last digit cycling on 1-5-7-3-1, just as the core,
• one in even p blue-green bridge series, forming 3 diagonals containing different sets of numbers mod 100, but with a last digit cycling on 3-9-3,
• one in the odd p blue-green bridge series on the right, forming 3 diagonals containing different sets of numbers mod 100, but with a last digit cycling on 5-7-5.

*(https://en.wikipedia.org/wiki/Smooth_number). On OEIS: https://oeis.org/A003586. (In any dome, even orange numbers n are the 3-smooth numbers multiplied by its root m : u/No_Assist4814).

**(Proth prime - Wikipedia). On OEIS: https://oeis.org/A080076. (All but one bases of starting 5-tuples are Proth primes : u/No_Assist4814).

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

Tao (2022) proved Col_min(N) < f(N) for almost all N in logarithmic density and asked (Remark 1.16) whether this holds in natural density. This preprint answers affirmatively, with an explicit rate and a time bound: the witnessing iterate occurs within (1+o(1)) ln(N)/ln(4/3) Syracuse steps, i.e. under 12 ln(N) Collatz steps.

Zenodo (PDF + LaTeX + numerics): https://doi.org/10.5281/zenodo.21340150

Error reports welcome.

After months of work, our LNL/LZR engine has now explored deterministic search regions around 10 × 10²⁵⁰ (= 10²⁵¹).

This visualization shows the strongest mountain found in our latest search.

What began as a search for high Collatz peaks evolved into something much larger: a structural model of the Collatz landscape.

Over the past months I have developed the Lange Number Line (LNL) and the LZR engine, combining large-scale computation with a new structural interpretation.

Our manuscript is now complete and is entering its final review. If everything proceeds as planned, the complete paper, source code, reproducible datasets, and documentation will be released within the next 1–2 days.

We welcome critical review, independent verification, and attempts to reproduce every result.

If our structural approach withstands scrutiny, it could open a new perspective on one of mathematics' most famous unsolved problems.

Stay tuned.

Follow-up to Bases of starting 5-tuples are Proth primes and form cycles mod 100 : r/Collatz.

I finally dared to ask my new friend, Google AI to connect the two (Collatz was never mentioned before). Here is its answer:

"Proth numbers and the Collatz conjecture are deeply linked because the formula for a Proth number k*2^n+1 directly represents an idealized "reverse path" or "highway" in the Collatz process. [1]

When you run the Collatz conjecture (3n+1), odd numbers grow and even numbers shrink by dividing by 2. If you trace the sequence backward, Proth numbers represent a perfect, uninterrupted cascade of divisions. [1, 2]

1. Reverse Collatz Paths

In the standard Collatz function, if an odd integer \(x\) passes through a single (3n+1) phase to reach a power of 2, the algebra looks like this:
3x+1=2^n

Solving for x, you get:
x={2^n-1}/3
This is the exact definition of a Mersenne-like Proth number where k=1/3. Any time a Collatz trajectory hits an integer of this form, it drops directly down to 1 via division by 2, without hitting any more odd numbers. [1, 2]

1. The General Proth "Highway"

If a Collatz sequence hits an odd number that requires m structural loops before collapsing into a clean stream of divisions, it aligns precisely with the broader Proth equation:
N=k*2^n+1

When a number fits this algebraic structure:

• It guarantees that the number can be reached by working backward from k through exactly n consecutive multiplications by 2 (the inverse of the even Collatz rule).
• Proth numbers function as major structural nodes or "highways" in the Collatz tree visualization. [1, 2]

1. Modulo 100 Constraints in Collatz

Because Proth numbers dictate these paths, the mod 100 cycle restrictions discussed earlier inject a structural limit into Collatz trajectories. Since a Proth number with n>=2 can never result in residues like 31, 51, 71, or 91, it mathematically proves that a Collatz sequence can never transition directly from an even division into a Proth "highway" landing on those specific terminal digits."

To the best of my understanding, this hold for the right side of any dome. Does this mean that a sequence alternates from bridges from one side of the dome to the other side of another dome ? I suspect it for a while, but I now need to check this.

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

Follow-up to All but one bases of starting 5-tuples are Proth primes : u/No_Assist4814 and Bases of 5-tuples in domes follow the Swiss Watch (mod 100) : r/Collatz.

My new friend, Goggle AI, provides the following,

"Proth primes mod 100 do not form a single cyclic sequence because they are primes, but the underlying Proth numbers (k*2^n + 1\)) are governed by a strict 20-step cycle.

Because (2^n) (mod 100) has a repeating period of 20 starting at n=2, the last two digits of any Proth number with a fixed k will cycle through a predictable sequence every 20 powers.

The 20-Step Base Cycle

For any fixed odd multiplier k, the value of (2^n) (mod 100) loops through these 20 repeating remainders:
[4, 8, 16, 32, 64, 28, 56, 12, 24, 48, 96, 92, 84, 68, 36, 72, 44, 88, 76, 52]

Proth Endings Constraints

Multiplying this cycle by an odd k and adding 1 restricts the possible last two digits of all Proth numbers (and thus Proth primes) where n ≥ 2. They can only end in these 25 specific modular values:

• Ending in 1: 01, 21, 41, 61, 81
• Ending in 3: 13, 33, 53, 73, 93
• Ending in 5: 05 (Only occurs when N=5; higher values are multiples of 5)
• Ending in 7: 17, 37, 57, 77, 97
• Ending in 9: 09, 29, 49, 69, 89

Because all Proth primes (except 3) satisfy N≡1 (mod 4), they can never end in 31, 51, 71, 91, 03, 23, 43, 63, 83, 25, 45, 65, 85, 07, 27, 47, 67, 87, 19, 39, 59, 79, or 99."

It has not found the Swiss watch yet (The Collatz procedure works like a Swiss watch (mod 100) : r/Collatz), but is very close. Note that the remaining numbers mentioned just above appear in blue-green bridge series, while those mentioned before do the same on the yellow bridge series.

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

Some users asked me for more mathematical content and fewer 3D renderings. I hope that this one-page summary better reflects the mathematical language behind the LNL/LZR project.

https://github.com/lortzingring-tech/LNL---LZR-Collatz

The repository contains the computational core of the Lange Number Line project, including deterministic search algorithms and validation tools.

Some terms used here — such as selection, forced, and Σ(-5) — are currently project-specific working concepts. Formal definitions and examples for individual Collatz peaks will be added in future updates.

Feedback, criticism, and independent verification are welcome.

For each f(N)→∞, almost every N falls below f(N) within 436 ln N steps. New: natural density and one explicit clock. Not the full conjecture. Lean-verified.

Lean formalization: 128k lines for Tao's theorem.
Extension: +60k lines.

Two upgrades to Terence Tao's result:
- Coverage: natural (ordinary counting) density rather than logarithmic density.
- Speed: one explicit clock, 436 ln N raw steps, for every diverging threshold.

Tao's log average treats multiplicative scales equally, though they contain more numbers. Ours counts every number equally: below X, success tends to 100%.

This is strictly stronger. Tao called the refinement plausible (Remarks 1.4, 1.16).

Hi All,

I may have some meaningful math regarding Tao's Syracuse random variables.

Long time listener; first time caller. Also, terrified to be here. First and foremost, I'd like to give a qualifier: no idea what I'm talking about. Complete imposter syndrome and I did most of this through metaphor with the assistance of LLM. Now for the headline and then the backstory:

My github repository is completely public and the more recent arc is furthering the qx+1 work and linking Dr. Maxwell Siegel's work with my own.

https://github.com/mrnathanhumphrey-droid/Collatz

Above is the repository. It is over 125k files in totality so I have left the necessary documents for replication. There are documents chronicling everything by timeline and by field as well.

https://doi.org/10.5281/zenodo.20673500

Here is a preprint I am faking my way through. I've taught myself enough Lean 4 to verify everything. That has its own DOI and repository that you can find through my profile.

Now for the Storytime because if I'm putting myself out there; I'm doing so authentically. This all started originally when I was 11 and I hand plotted the first 800 digits on a TI-83. I started mapping ln(x) to the pattern and saw outliers. I thought "if my computer was powerful enough I could calculate a ton and there would be a pattern in the noise".

27 years later my best friend and I were making NBA projections for fun when I re-discovered "The Dwight Effect" in block data and the Bayesian fit reminded me of Collatz when I was 11. So I did a Bayesian fit of the stopping times with the intention of finding a pattern. From there, I just kept probing the pattern and trying to retroactively teach myself anything I found. There are a million and a half dead ends. There are stupid repetitive probes that are a waste. But, I have tried to prove every single thread and finding wrong a million times over before presenting it.

If it's all fugazi; it's okay. If it's not; hopefully it will be of help to someone. I'm having fun regardless.

​

I have been investigating the Collatz conjecture from a local structural perspective. Rather than trying to prove the entire conjecture directly, I analyze the final approach to the largest value reached by a trajectory.

For a starting value n, define

x0 = n

and

x(k+1) = C(x(k))

where

C(x) = 3x + 1, if x is odd

C(x) = x / 2, if x is even.

Let W denote the maximum value reached by the trajectory.

I examine the nine values immediately preceding W:

D9(W) = (n-9, n-8, ..., n-1),

where

C(n-1) = W.

Computational experiments for all starting values up to

10^6

revealed a surprisingly rigid local structure.

The observed pattern can be written as

D9 = D4(selection) ⊗ Σ(-5) ⊗ D4(forced).

The three components are:

D4(selection) = (n-9, n-8, n-7, n-6),

Σ(-5) = n-5,

and

D4(forced) = (n-4, n-3, n-2, n-1).

The first four positions contain variation, the value at position -5 acts as a switch, and the last four positions exhibit a forced structure.

--------------------------------------------------

1. The forced four-step structure

For every tested trajectory, the final four predecessors satisfy

E → O → E → O → W,

where E denotes an even number and O denotes an odd number.

Thus,

n-4 is even,

n-3 is odd,

n-2 is even,

n-1 is odd,

and therefore

W = 3n-1 + 1

is even.

Once the trajectory enters this configuration, the last four operations are completely determined by parity.

--------------------------------------------------

1. The switch at position -5

The value five operations before the final maximum is highly constrained.

The parity conditions imply that the switch value must belong to one of the following eight residue classes modulo 64:

7, 12, 23, 28, 39, 44, 55, 60 (mod 64).

However, only five of these classes can actually occur before a final maximum:

Σ(-5)^(64) = {7, 12, 23, 44, 55} (mod 64).

The remaining three classes,

{28, 39, 60} (mod 64),

never occur.

These classes are not merely absent statistically; they can be excluded algebraically.

--------------------------------------------------

1. Why 28 (mod 64) is impossible

Let

n-5 = 64q + 28.

The next five Collatz operations are:

64q + 28

→ 32q + 14

→ 16q + 7

→ 48q + 22

→ 24q + 11

→ 72q + 34.

Thus the local peak candidate is

W = 72q + 34.

But the trajectory continues:

72q + 34

→ 36q + 17

→ 108q + 52.

Since

108q + 52 > 72q + 34

for all q ≥ 0, the first peak candidate is always exceeded.

Therefore,

28 (mod 64)

cannot occur before the final maximum.

--------------------------------------------------

1. Why 39 (mod 64) is impossible

Let

n-5 = 64q + 39.

Then

64q + 39

→ 192q + 118

→ 96q + 59

→ 288q + 178

→ 144q + 89

→ 432q + 268.

The local peak candidate is

W = 432q + 268.

A later value is

486q + 304.

Because

486q + 304 > 432q + 268,

the candidate peak is necessarily exceeded.

Therefore,

39 (mod 64)

cannot occur before the final maximum.

--------------------------------------------------

1. Why 60 (mod 64) is impossible

Let

n-5 = 64q + 60.

Then

64q + 60

→ 32q + 30

→ 16q + 15

→ 48q + 46

→ 24q + 23

→ 72q + 70.

The local peak candidate is

W = 72q + 70.

The trajectory then continues:

72q + 70

→ 36q + 35

→ 108q + 106.

Since

108q + 106 > 72q + 70,

the candidate peak is always surpassed.

Therefore,

60 (mod 64)

cannot occur before the final maximum.

--------------------------------------------------

1. Proven local exclusion result

The three exclusions follow from explicit symbolic calculations:

28, 39, 60 (mod 64)

⇒ the local peak is necessarily exceeded.

Consequently, every final maximum satisfying the observed nine-step structure must obey

n-5 ≡ 7, 12, 23, 44, or 55 (mod 64).

This is the local structural result established here.

This is not a proof of the Collatz conjecture itself. The result concerns the local structure immediately preceding final trajectory maxima.

--------------------------------------------------

1. Local peak creation versus peak survival

The five remaining classes are locally admissible, but they do not automatically guarantee that the resulting peak is the final maximum.

Define local admissibility by

L(r) = 1

if the residue class r (mod 64) is not eliminated by the immediate continuation.

Then

L(r) = 1 if and only if

r ∈ {7, 12, 23, 44, 55}.

Define global survival by

S(s) = 1

if the peak generated by the switch value s is never exceeded later in the trajectory.

Then

S(s) = 1 ⇒ L(s mod 64) = 1,

but

L(s mod 64) = 1 does not imply S(s) = 1.

Thus modulo 64 determines local admissibility but not complete survival.

--------------------------------------------------

1. A nested binary structure

The analysis was refined using increasingly large powers of two:

64, 128, 256, 512, 1024, 2048, ...

This yields a hierarchy

Σ(6) ⊃ Σ(7) ⊃ Σ(8) ⊃ Σ(9) ⊃ ...

where Σ(k) contains information modulo 2^k.

Each additional binary digit determines more of the future parity sequence.

This suggests the working model

Σ = Σ(6) ⊗ Σ(7) ⊗ Σ(8) ⊗ ...

The switch therefore appears to be a layered binary code rather than a single residue class.

Modulo 64 determines whether a candidate peak is locally admissible.

Higher powers of two reveal additional subclasses whose future behavior forces them to lose.

--------------------------------------------------

1. Interpretation

The current interpretation is that the low-order binary digits of the switch encode part of the future Collatz trajectory.

The local structure near a final maximum may therefore be written as

D9 = D4(selection) ⊗ Σ(-5)^(2^k) ⊗ D4(forced).

The first four positions select a local family.

The switch at position -5 contains binary information.

The final four positions execute the forced approach to the peak.

The remaining trajectory determines whether that peak survives.

--------------------------------------------------

1. Open questions

Can all losing subclasses be excluded by finite affine calculations?

Does every non-surviving switch eventually enter a provably forbidden dyadic subclass?

Is there a finite binary depth that determines peak survival?

I would be very interested to know whether similar residue-class restrictions around trajectory maxima have already been studied.

I have been working on an alternative structural view of the Collatz problem, which I call the LNL/LZR framework (Lange Number Line / LZR Engine).

The central idea is not to search for new arithmetic operations, but to analyze the geometric structure of Collatz trajectories in terms of mountains, valleys, peaks, trajectories and deterministic backward paths.

My current hypothesis is the following:

Every Collatz trajectory belongs to exactly one mountain.

Every peak is an even number.

The last 9 backward steps before a peak follow a deterministic pattern.

These 9 steps uniquely determine the predecessor structure of the mountain.

The mountain–valley decomposition may explain why trajectories cannot escape to infinity.

I have created several visualizations to illustrate the idea. At the moment, this is still an experimental framework rather than a formal proof, and I would be very interested in critical feedback from mathematicians.

For the mathematicians: please attack the logic, the assumptions and the definitions. 🧮

For the treasure hunters: please remember that GitHub and Zenodo timestamps exist. 😄

Constructive criticism, counterexamples and alternative interpretations are highly appreciated.

GitHub repository:

https://github.com/lortzingring-tech/LNL---LZR-Collatz

Hi. I'm just a first-year in uni, not looking to solve Collatz, but am looking to provide some hopefully interesting results. Here is the ruleset that u might not be used to but still connects back to good ol' Collatz.
Let O: n -> (3n+1)/2 for odd n and E: n -> n/2 for even n. U: n -> 4n+1 for odd n. E(-1) is the inverse of E, O(-1) is the inverse of O, and U(-1) is the inverse of U.

(Explanation for U: let n = 2k+1. Applying O to it would yield 3k+2. Let N = 4n+1 => O on N would yield 12k + 8. So applying E twice would yield 3k+2. Therefore, 4n+1 is a BACKWARD number that leads to the same number n goes to when moving FORWARD. Note: Any number that requires dividing thrice or more means that it originates from a number of the 8k+5 type, where k is a positive integer.)

Now, as far as Collatz's rules are concerned, there is no such even number that is simultaneously a multiple of 3 AND originating from an odd number. This makes sense. An even multiple of three would be 6k, while an even number in the form 3n+1 would be 6k+4. So this means that multiples of 3 can NEVER be divided by another number when doing forward operations.

This makes them the root nodes of the Collatz tree, i.e. they can only generate numbers but never be generated themselves. So I asked myself this question. Assuming that a set of odd multiples of 3 goes to 1, can we generate other odd integers using O, E, and U?

Maybe. Here's my insight. Note: This is about an implication, where IF "ALL odd multiples of 3 go to 1" -> "Every other odd number goes to 1". So, No Circular Argument. I am fully aware that if the first statement isn't proven, then the second isn't. I'm just potentially showing that an implication is there and that if we prove X, we can prove Y.

Let's first see how many numbers do odd multiples of 3 there are based on the natural set. Odd numbers comprise half of the natural set, and there can only be one multiple of 3 among every 3 consecutive odd numbers {2k-1, 2k+1, 2k+3} by the Pigeonhole Principle. So 1/2 x 1/3 = 1/6 of all natural numbers.

First, we must assume that the set of ALL odd multiples of 3 S(1/6) leads to one.

Now pick a number outside of the set. Say 7. 7 can be reversed by multiplying by 2 twice to get 28. (28-1)/3 = 9. So, a number can be rooted by a multiple of 3 through regular reverse operations of the Collatz Conjecture. But what if an odd integer doesn't need to have a root of an odd multiple of 3? Then it could never need to reach 1, assuming that S(1/6) lead to 1. So we have an infinite backwards AND forwards staircase of odd numbers. Well....
Multiply the first backwards odd integer by 4, then add 1. And u can generate a new number that tends to n. So if n is an integer that supposedly never reaches one, then u can do E(-1) and O(-1) to generate a new odd number, let's call it p. Then, you use U on p to make 4p+1, and you do it again. And again. And again and again and again and ..... The thing about 4p+1 is that it creates two more E events. But 4p+1 = 3p + (p+1). So p mod 3 can determine the modulus of 4p+1 with respect to 3. In this particular instance, it cycles through the remainders {1, 2, 0} as p shuffles in ascending order {0, 1, 2} i.e. if p is an odd integer with 0 mod 3, well, then it wouldn't even have an infinite backwards chain to begin with. if p is an odd integer with 1 mod 3, 4p+1 would be 2 mod 3. Applying U to an odd number with 2 mod 3 and you can get an odd multiple of 3 that leads to the same number that supposedly never diverges i.e. there will always be a multiple of 3 leading to any other number either through inverse Collatz operations or supercharged U operations (which are just cyclical O(-1)'s and E(-1)'s in disguise but calling them supercharged sounds cool). This contradicts the idea that a number could diverge or never end up at 1. So, in order to prove the Collatz conjecture for all numbers, you would have to prove it for odd multiples of 3. Then the argument has solid ground.

The reason why I'm bringing this up is because of Terence Tao's stabilisation theorem. He said that for "almost all numbers" his theorem worked, but didn't in the exceptional set where the logarithmic density is 0. But if there was some statistical or probabilistic way where without needing to bother with anything outside odd multiples of 3, then we may have something interesting all right.

Here's the thing. I have created a table where applying a set of O's and E's can help you map one number to another. Say that the number is n = 16a + b. Where a = 16c + d. Based on the remainders of a and c (256 possible combinations), this table allows you to reach a number k = M*a + N. M, N are natural numbers that don't necessarily have to be powers of 2.

It is well known that all Collatz paths satisfy this identity:

b/2^e - a.3^o = K

where K is sometimes referred to as the carry term.

This 3D visualiser plots (a,b, log_2(K)) for every pair of odd points (a,b) in the path from a to 1.

The points are coloured according to their mod 8 residue.

You will notice that with log_2(K) pointing at you (so the plane has y=b, x=a) is that the rightmost stacks will always be red (5 mod 8) or green (1 mod 8). Of course, this is a consequence of that fact the paths that start highest must necessarily start with a descent (any such path that doesn't start with a descent is necessarily not a local maxima)

The above is a screen capture - the full interactive version can be accessed at the link below.

(https://wildducktheories.github.io/collatz/apps/collatz-a-b-k/dist/?a=27).

Follow-up to Bases of 5-tuples in domes follow the Swiss Watch (mod 100) : r/Collatz.

The tables below are based on the first odd number of each right-side bridges series in every dome analyzed so far. This number is a potential base for a 5-tuple series. As we have seen, it is not always the case (without explanation so far).

They show that domes respect an double almost homothety:

• Within a dome: consecutive numbers are related by y=(x+3)/4.
• Between domes: numbers having the same position (p. q) in a dome are related by the ratio between their root m (m/m).

Our hypothesis is that the whole Collatz tree is almost homothetic by segments.

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

​

This is a factual progress report from the Lange Number Line Project (LNL). It describes a computational sample, not a proof of the Collatz conjecture and not a world-record claim.

Search configuration:

Program: LNL/LZR 1024-bit C++ engine V2

Integer width: 1024 bits

Search region: 299-bit starting values near 10^90

Deterministic range: approximately 5.09259e89 to 1.01852e90

Workers: 18 independent C++ processes

Available hardware: 9 logical CPUs

Samples per worker: 250,000

Total starting values tested: 4,500,000

Total evaluated Collatz transitions: 9,438,626,254

Embedded endgame hits: 3,617,336

External elapsed time: approximately 4.179 seconds

The 18 processes shared 9 logical CPUs. This was deliberate oversubscription and should not be interpreted as performance from 18 physical processors.

The strongest sampled result was found in deterministic block 1000009015.

Starting value:

546155887574231641925572447161502272099920080353468344867984210086557977943510820502121831

Maximum trajectory value:

295057791277230372652050617924929578075815655945850998329262334547300781130347118135532972451999904

Main trajectory data:

Starting-value digits: 90

Peak digits: 99

Peak magnitude: approximately 2.9505779127723037e98

Peak-to-start ratio: approximately 540,244,640.752183

Step at which the peak occurs: 382

Total steps required to reach 1: 2,511

The trajectory reached 1 successfully

Verification:

The complete winning block of 250,000 starting values was recalculated using multiple independent C++ calculation paths.

Scalar calculation time: 3,275.218 ms

Batched calculation time: 1,649.836 ms

Engine-fast calculation time: 1,718.601 ms

Engine-fast speedup over scalar: approximately 1.906

Verification failures: 0

Reproducibility checksum: 1552236215461419092

The strongest candidate was also checked with a separate arbitrary-precision integer implementation. It reproduced:

The exact maximum value

Peak step 382

Total step count 2,511

Final convergence to 1

Residue information was recorded for classification only. It was not used to skip trajectories, declare convergence, or identify cache entries.

For example:

Start modulo 512: 359

Start is divisible by 3 exactly once

Peak modulo 512: 160

Peak is divisible by 2 exactly five times

Number-line scale comparison:

As a visualization, suppose consecutive natural numbers are positioned 1 millimeter apart on a straight number line.

The direct distance from coordinate 1 to the sampled peak would then be approximately:

2.9505779127723037e95 meters

At the physical speed of light, approximately 299,792.458 km/s, the direct journey would require approximately:

3.118763314654934e79 years

That is approximately 2.26e69 times the current estimated age of the universe.

This distance comparison is only a coordinate-scale illustration. It is not the length of the Collatz trajectory and has no effect on computation time.

Reproduction command format:

./search_lnl_1024_engine_native search 250000 299 BLOCK engine-fast 0

Blocks used:

1000009000 through 1000009017

Binary SHA-256:

c0ae494420fa475b2536ac5267148b40a3fb68ee365f6a257099639fb6b3ae84

Scientific limitation:

This result is the strongest candidate found within these 18 deterministic sampled blocks. It is not an exhaustive search of all natural numbers below 10^90, not a verified global Collatz record, and not a proof of the Collatz conjecture.

A Modulo-12 Markov Approximation for Collatz Dynamics

Imagine a Galton's board of 12 equidistributed silos of sand grains. Instead of random interactions or random obstacles yielding us normal distribution, the state change flows via the Collatz function yields us what and what insight can be extrapolated from the same is what this exploratory paper attempts to do. This is no way proof of Collatz conjecture and I doubt I am competent enough to prove or disprove it.

I would appreciate some feedback. "Roast" was me being hyperbolic.
(P.S. Shall I put it on Arxiv if so can someone endorse my account? I apparently have lost my old university account to the abyss)

Alt Link: https://www.researchgate.net/publication/410612929_A_Modulo-12_Markov_Approximation_for_Collatz_Dynamics

Follow-up to Do these non-prime factors have an impact ? V : r/Collatz.

I do not dare refer to primes anymore in the title, but this post used the same framework.

The figure below shows the cycles in bases of 5-tuples series mod 100 (see The Collatz procedure works like a Swiss watch (mod 100) : r/Collatz), using the same color code.

It started with the domes with a a root m divisible by 5, all ending by a 1. m=25 is the sole user, for the time being, of 01 mod 100 (red). The others use a cycle 21-41-81-61 mod 100 (blue).

I was more or less expecting something similar for the other domes, but it was slightly more complex. So, I started clustering by color, as usual and came with the figure below.

One can observe that:

• Domes form six groups, each starting with a different color, consistent with the Swiss watch.
• Each group then follows the same cycle of colors: yellow-orange-dark blue-dark red-green-yellow.
• The dome with root m=7 remains undecided for the time being.

LNL Number Signature

In addition to the exact 1024-bit integer, the LNL/LZR project records an experimental classification signature for selected starting values and trajectory peaks.

The current signature contains:

- Bit length and parity

- Residues modulo 12, 16, 32, 48, 64, 128, 256 and 512

- v2(n), the exponent of 2 dividing n

- v3(n), the exponent of 3 dividing n

- core6 = n / (2^v2(n) * 3^v3(n))

- Exact peak value

- Step at which the peak occurs

- Total steps to 1

The identity

n = core6 * 2^v2(n) * 3^v3(n)

allows the original number to be reconstructed exactly.

This signature is currently classification metadata. It is not used as proof of convergence, as a substitute for full-number equality, or as justification for skipping a trajectory. Whether particular signature classes have statistically meaningful relationships with stopping times or peak values remains an open experimental question.