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.

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

Note: This applies for natural numbers above two, i.e., {3, 4, 5, ...} . If anyone wants the calculations, do let me know.

Part 1: Setting the boundaries

It can be said that the given number decreases on x operations (of which (3x+1) is done 'H' times and (x/2) is done 't' times) if 3^H < 2^T .

It is also known that x = H + T

So, the boundaries can be set as follows:

(H/x) < (ln2/ln6)

(T/x) > (ln3/ln6)

Part 2: Finding a general trend for h and t as x changes

Since (3x+1) for an odd number always gives an even number, (x/2) always comes after (3x+1) . So, no two (3x+1) operations can happen consecutively. This can be rewritten as:

If a coin is flipped x times, what is the average number of heads, if no two heads appear consecutively?

An example to ensure proper understanding: Let's say the coin is flipped thrice. The possible outcomes are TTT, TTH, THT, HTT, HTH. (THH, HHT, HHH are excluded because they have consecutive heads.)

There are 5 total outcomes.

The average number of heads = (0+1+1+1+2)/5 = 1

1/5 is less than ln2/ln6 (H/x < 0.38)

Finding the formula for the total number for outcomes for x throws will lead to the formula for H/x .

After some solving, I arrived at the formula shown below (If someone knows how to format math on reddit, do let me know):

To show that the above equation does not cross (ln2/ln6), I used desmos to plot a graph (see below):

It is seen that (from 3 and onwards) the graph continues to decrease. The maximum is at (3, 1/3) - meaning that it will not cross (ln2/ln6 = 0.38)

Can someone tell me why this approach might not work?

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.

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

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.

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.

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. 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.

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

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).

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.

​

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.

​

This is my final full peak report posted directly on Reddit before moving the Lange Number Line Project documentation, source code, datasets, and reproducible releases to GitHub and Zenodo.

The latest reproducible 200-bit sampled search produced a new strongest LNL trajectory.

Start value:

1084820695304608898376597485794546984528180820629394323505151

Exact peak:

12324763716514253071447088281192419703733391394845870197521733855368

Main results:

Peak reached at step 142

Total steps to 1: 1,593

Odd steps: 539

Even steps: 1,054

Peak length: 68 digits

Approximately 3,254,796.718309 times above the previous LNL candidate

The candidate was found using exact 512-bit C++ arithmetic. Its complete trajectory was independently recalculated to 1 using JavaScript BigInt.

Important scientific limitation:

This is the strongest trajectory found in the documented LNL sampled search detected on 20th of July 2026. It is not a proven global Collatz record and not a proof of the Collatz conjecture. Confirming a global record would require exhaustive verification of every smaller starting value.

Future code, datasets, manifests, checksums, and reproducible releases will be published through GitHub and Zenodo. I will continue using Reddit for occasional progress updates and discussion.

Thank you for the criticism, questions, and constructive advice.

Best regards,

Mike Lange

I've been noodling around with Fable 5 before it's gone. Asked 5.6 Sol for verification.

https://claude.ai/code/artifact/05587812-3be7-4be9-a8b7-96326cb042f4

https://github.com/benpham3206/an-atlas-of-the-collatz-conjecture

​

PURPOSE OF THE PROJECT

The Lange Number Line Project, abbreviated LNL, is an independent computational project for calculating, encoding and examining Collatz trajectories.

LNL does not claim to prove the Collatz conjecture.

The current goals are:

Calculate individual Collatz trajectories exactly.

Create reproducible operation codes for every tested trajectory.

Detect trajectory peaks and possible path-record candidates.

Compare the software with established reference results.

Publish code and data so that other people can reproduce or challenge the calculations.

The LNL terminology is an additional descriptive layer. Every numerical result remains based on the standard Collatz operations.

STANDARD COLLATZ RULE

For every positive integer n:

If n is even:

T(n) = n / 2

If n is odd:

T(n) = 3*n + 1

The trajectory of n is:

n, T(n), T(T(n)), and so on.

The calculation continues until the trajectory reaches 1.

TRAJECTORY PEAK

The trajectory peak P(n) is the largest number reached by the complete trajectory, including the starting value.

In plain notation:

P(n) = maximum value in the trajectory starting at n

The peak position is the first step at which this maximum is reached.

PATH RECORD

A starting value n is a path record only if its peak is higher than the peak of every smaller positive starting value.

In plain notation:

P(n) > P(m) for every m < n

This distinction is important.

Finding a very large peak for one sampled starting value does not prove that the starting value is the next path record.

To confirm the next path record, every smaller starting value must first be checked.

STANDARD OPERATION CODE

LNL records every standard operation with one letter:

U = odd operation: n becomes 3*n + 1

D = even operation: n becomes n / 2

A complete trajectory can therefore be stored as a sequence of U and D operations.

ACCELERATED ODD-STEP CODE

For every odd number x, LNL calculates:

d = v2(3*x + 1)

Here, v2 means the number of times that 3*x + 1 can be divided by 2 before the result becomes odd.

The next odd number is:

next odd x = (3*x + 1) / 2^d

The resulting list of d-values is a compact encoding of the standard Collatz trajectory.

This is not a new Collatz rule. It is only a shorter representation of the same operations.

CURRENT SOFTWARE

The current LNL software includes:

A deterministic path-record scanner

Exact 128-bit calculations

Exact 256-bit calculations

Exact 512-bit calculations

U and D trajectory codes

Accelerated d-value codes

Reproducible independent seed blocks

Overflow protection

Python arbitrary-precision verification

JavaScript BigInt verification

Residue-class and transition tests

The 512-bit C++ scanner compiles without warnings using:

-Wall -Wextra -Wconversion -Werror

REFERENCE VALIDATION

Before performing experimental searches, we tested the core software against established Collatz path records.

An exhaustive calculation of every starting value from 1 through 100,000,000 reproduced 41 successive path records.

The final path record in this interval is:

Start:

80,049,391

Peak:

2,185,143,829,170,100

Peak position:

164

Total steps to 1:

572

The results agree with the published reference sequences OEIS A006884 and OEIS A006885.

Reference links:

https://oeis.org/A006884

https://oeis.org/A006885

https://pcbarina.fit.vutbr.cz/path-records.htm

ARBITRARY-PRECISION EXAMPLE

As a separate large-number test, LNL calculated the trajectory of:

n = 10^1001

This number is exactly a 1 followed by 1,001 zeros.

It has 1,002 decimal digits.

Because:

10^1001 = 2^1001 * 5^1001

the trajectory begins with exactly 1,001 divisions by 2.

After these divisions, the odd core is:

5^1001

Exact results:

Starting value:

10^1001

Decimal digits:

1,002

Binary length:

3,326 bits

Trajectory peak:

10^1001

Peak position:

0

Total steps to 1:

17,840

Odd 3*n + 1 steps:

5,615

Even n / 2 steps:

12,225

Control calculation:

5,615 + 12,225 = 17,840

The starting value itself is the peak. The trajectory never returns to or exceeds it.

Python arbitrary-precision integers and JavaScript BigInt independently produced the same result.

SAMPLED HIGH-NUMBER SEARCHES

LNL has also calculated individual trajectories for sampled starting values far beyond the exhaustively tested interval.

Some of these trajectories reach extremely large exact values.

These experiments demonstrate that:

The software can process very large integers.

The individual trajectories can be reproduced.

The 512-bit engine works beyond the normal 64-bit range.

These results do not establish new path records.

At very large starting values, the starting value itself may already be larger than an older published peak.

For this reason, these results are described only as:

Exact sampled trajectories

or:

Sampled height exceeders

They are not described as confirmed world records.

WHAT LNL DOES NOT CLAIM

LNL does not currently claim:

A proof of the Collatz conjecture

Proof that every positive integer reaches 1

Discovery of the next official path record

Exhaustive verification beyond the stated limits

That sampled searches can replace exhaustive calculations

That every descriptive LNL term is mathematically new

NEXT SCIENTIFIC GOAL

The next goal is not simply to generate a larger number.

The next goal is to improve reproducibility.

PHASE 1: PUBLIC SOFTWARE RELEASE

Publish:

C++ source code

Python verification code

Compiler commands

Exact definitions

Test results

CSV result tables

SHA-256 file hashes

PHASE 2: EXHAUSTIVE EXTENSION

Extend the deterministic path-record calculation from:

100,000,000

toward:

1,000,000,000

No starting values may be skipped.

PHASE 3: INDEPENDENT VERIFICATION

Every detected path record must be recalculated with a separate arbitrary-precision implementation.

A result will be called a path record only after every smaller starting value in the interval has been checked.

PHASE 4: STRUCTURAL ANALYSIS

After the numerical baseline is secure, we will examine whether U/D codes, d-value sequences and inverse structures contain useful predictive information.

INVITATION TO REPRODUCE OR CRITICIZE

Technical criticism is welcome.

A reproducible countercheck should include:

The exact starting value.

The Collatz convention used.

The source code or algorithm.

The first trajectory position where the results differ.

The integer type and overflow protection.

Whether the starting value is included in the peak definition.

The purpose of LNL is not to replace established mathematics with graphics or terminology.

The purpose is to build a transparent computational framework whose results can be independently reproduced, tested, criticized and improved.

Copyright (c) 2026 Mike Lange

Lange Number Line Project (LNL)

All rights reserved.

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

The figure below is based on the same information as in the previous posts, with some changes:

• The base b underlying a 5-tuple is presented here as b mod 6 (see previous post) and colored according to the color of the corresponding 5-tuple.
• The domes with root m (rows) form classes m mod 16. Every third dome is embedded in another one when m+16k is divisible by 3.

One can observe that:

• 5-tuples series of a given row start (on the right) with a given color,
• Within a class of domes, the starting color alternate.
• Classes of domes have a propensity to form 5-tuples series of certain lengths.

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

The LZS — Lange Technology Center has expanded its Collatz trajectory software from 256-bit to exact 512-bit integer arithmetic.

New strongest sampled trajectory

Start:

1,369,482,433,354,456,041,226,337,279,508,360,375,146,277,235,369

Exact peak:

10,372,557,405,456,016,307,857,991,353,006,097,761,785,856,811,996,878,420

Peak step: 140

Total steps to 1: 1,450

This sampled peak is approximately 10,496,103,243,578 times higher than the published verified peak below 2^71.

Software and verification:

Exact 512-bit C++ integer arithmetic

Sampled 140-, 145-, 150- and 160-bit starting zones

192 odd-stage LZS DNA analysis

Independent reproducible seed blocks

Dynamic comparison against the latest candidate peak

Warning-clean C++ compilation

Complete trajectory independently reproduced with arbitrary-precision Python integers

Scientific status:

This is an exact sampled trajectory and a confirmed height exceeder. It is not yet the confirmed next Collatz path record.

To identify the next official record mountain, every smaller starting value above the published verification frontier would have to be checked exhaustively.

The 3D mountain scale in the accompanying graphic is illustrative. All displayed numerical values and ratios are calculated from the exact trajectories.

Copyright © 2026 Mike Lange

Lange Number Line Project (LZS)

All rights reserved.

Reproduction, modification, redistribution or commercial use of the source code, data, documentation or graphics requires prior written permission from Mike Lange.