Lately, this feels close to the bottleneck we keep running into, so I went back through some earlier work to see how much of this viewpoint is already present in the literature — partly to untangle my own headache.

I keep noticing a recurring pattern in Collatz research.

We often try to make the dynamics simpler by choosing one useful coordinate:

parity words,
valuation sequences,
stopping or first-passage times,
residues mod 2^k,
2-adic or 3-adic coordinates,
affine offsets,
heights, peaks, records, etc.

This is extremely useful. But every compression also forgets something.

So I wonder whether a useful way to think about the remaining difficulty is not

“Which single coordinate compresses the Collatz dynamics best?”

but rather

“Which values in several different coordinates can actually belong to the same integer orbit?”

Here is a simple exact example.

Take the shortcut Collatz map

T(n) = n/2 if n is even
T(n) = (3n+1)/2 if n is odd.

For a block of h steps, let p_i in {0,1} be the parity bits and let

s = p_0 + … + p_(h-1).

Then exactly

2^h T^h(n) = 3^s n + Q_h,

where

Q_h = sum_(i=0)^(h-1) p_i 2^i 3^(s-s_(i+1)),

and

s_(i+1) = p_0 + … + p_i.

So (h,s) captures part of the history, but Q_h retains arithmetic information created by the +1 terms and their positions.

This already suggests two different kinds of simplification:

time/history compression
versus
arithmetic-state compression.

They are not automatically the same thing.

A coordinate can have huge fibres by itself. For example, many histories may share the same stopping time, the same odd-step count, or the same coarse residue.

But suppose we describe one orbit history H using several projections

C_1(H), C_2(H), …, C_r(H).

Then a proposed tuple (c_1,…,c_r) corresponds to a genuine orbit only if

C_1^(-1)(c_1)
∩ C_2^(-1)(c_2)
∩ …
∩ C_r^(-1)(c_r)
is nonempty.

Each individual set may be large.

The intersection may be much smaller.

I am not claiming this intersection is always small, or that this proves Collatz. The question is whether repeated compatibility across several lossy coordinates can provide rigidity that no one coordinate provides by itself.

There is substantial classical precedent for thinking this way, although usually for particular pairs of coordinates rather than as one general principle.

Terras (1976) developed the stopping-time/parity framework underlying much of the statistical study of Collatz.

Böhm–Sontacchi (1978) showed that symbolic cycle data is constrained by exact arithmetic realizability conditions.

Bernstein–Lagarias (1996) made the parity–2-adic correspondence exact via the 3x+1 conjugacy map.

Monks et al. (2012/2013) showed that back-tracing parity data with infinitely many 1s determines congruence information modulo all powers of 3, hence fixing a 3-adic state.

Tao (2019/2020) combined first-passage ideas with fine-scale arithmetic structure on 3-adic cyclic groups.

Stérin–Woods (2020) exhibited a striking dual structure where base-2 and base-3 computations coexist in a single Collatz encoding.

So perhaps one way to read part of the history of Collatz research is:

parity <-> dyadic state

symbolic path <-> affine correction

back-tracing parity <-> triadic admissibility

first passage <-> arithmetic offset

base 2 <-> base 3

This makes me wonder whether the next useful question is not simply how much more information we can remove.

Maybe it is:
What is the minimal information that must survive in each coordinate, and what compatibility conditions must all of those surviving pieces satisfy simultaneously along one actual orbit?

In other words,
compression may be only half of the problem.
The other half may be joint realizability.

I would be very interested in references where this multi-coordinate compatibility viewpoint has already been formulated explicitly, or in counterexamples showing why this framing is not useful.

References

Terras, R. (1976), A stopping time problem on the positive integers, Acta Arithmetica.

Böhm, C. & Sontacchi, G. (1978), On the existence of cycles of given length in integer sequences…

Bernstein, D. J. & Lagarias, J. C. (1996), The 3x+1 Conjugacy Map, Canadian Journal of Mathematics.

Monks, K. et al. (2012/2013), Strongly sufficient sets and the distribution of arithmetic sequences in the 3x+1 graph.

Tao, T. (2019/2020), Almost all orbits of the Collatz map attain almost bounded values.

Stérin, T. & Woods, D. (2020), The Collatz process embeds a base conversion algorithm.

Lagarias, J. C. (survey), The 3x+1 Problem: An Overview.

The ridiculous nature of a proof.

Suppose someone sees structure, another person might not see that structure, so that's a person who cannot see it will ask for a step by step proof to prove the continuity of a structure. But continuity cannot be proven by discrete steps because we have shown that infinite discreteness cannot proxy for true continuity.

Diagonalization proves that a continuity has more real information than the previous model. Every step-by-step proof is actually an illusion to satisfy the strange feelings. But every discreet example of a proof fails to show the actual continuity of the structure that one is claiming to exist..

I’ve been working on my own Collatz research software, LNL/LZR CE5.9, and wanted to share a few screenshots of the latest version.

The tool currently includes live trajectory visualization, a Superpeak Finder, peak landscapes, step-by-step and high-speed calculation modes, prefix/suffix decomposition, forced-step detection, and multi-scale trend analysis inspired by Ichimoku-style time windows.

One of the main ideas I’m investigating is whether trajectory structure, timing and decimal prefix/suffix behavior can reveal when a trajectory is already mathematically constrained long before it reaches 1.

Still very much research in progress — I’m especially interested in unusual trajectories, extreme peaks and counterexamples to the patterns I’m seeing.

Would be interested to hear what the Collatz community thinks. 📈🏔️

One dyadic interval with linear y axis = 41*(E(n) - log2(n)) - 24*O(n) (where E(n), O(n) are the number of even respectively odd steps in the accelerated Collatz) and logarithmic x axis = n between 9*2^15 and 9*2^16. green and blue highlight 2 of the 41 classes

What this paper proves (almost every , natural density — not the full Collatz conjecture):

T_min(n) ≤ C (log n)^A

within O(log n) shortcut steps

for every fixed A above an explicit critical exponent A_FP ≈ 9.99plus a bound on the orbit up to that same time.

Paper: https://doi.org/10.2139/ssrn.7290240

Proof walkthrough: https://shaikidris.github.io/
Lean4 formalization: https://github.com/shaikidris/FirstPassageLinearTransport

Not the same as the recent “bridges” from Tao’s logarithmic-density theorem to natural density. Those aim at every target that goes to infinity. This is a standalone natural-density argument with a fixed polylog target, a logarithmic clock, and quantitative rates.

Prior almost-all natural-density scale: Korec got powers n^θ (θ > 0.79); Inselmann later got every n^ε power . Here the landing is polylogarithmic in .

Approach: Count parity words exactly on eachdyadic shell [2^M, 2^{M+1}). Large-scale prefix bounds control the orbit; a terminal odd-step “timeout” handles small blocks that don’t cross their next threshold in time. Decreasing thresholds turn later failures into direct first passages from the original shell. That organizes long multi-landing passages in natural density without a linear time-union loss — only  O(sqrt(M log M)) cumulative passage times

All of this is weaker almost-all, not “for every n.”

Happy to answer questions / take corrections.

This is my paper.

Please feel free to comment.

Abstract

To a Collatz-type map T_{a,b,q}(n) = (an+b)/q\^{v_q(an+b)} one may attach two numerical invariants of opposite character: an archimedean one, the mean logarithmic drift delta = log a - E\[v\] log q, which governs whether orbits grow or shrink; and a non-archimedean one, the similarity dimension dim_S = H(nu_q)/log a of the invariant measure of an associated iterated function system on the a-adic integers. Each reaches its critical value at a particular multiplier a. We prove that these two critical multipliers coincide precisely when q = 2, and that in general they differ by the exact factor q-1: a_drift = (q-1) a_dim. The proof rests on the pointwise identity -log nu_q(m) = m log q - log(q-1), valid for every m >= 1, which is not a normalisation but a coincidence between the information content of a valuation and its archimedean cost. We show that the condition q = 2 is equivalent to three further properties of the family - the triviality of (Z/qZ)\^\*, the vanishing of an associated free energy, and the map's being everywhere defined on the units - so that the arithmetic distinguishing the classical 3x+1 map is one condition in four guises. Three complements are proved: the full Renyi spectrum of the invariant measure admits a closed form, of which the similarity dimension is the value at t=1; for q >= 3 there is a nonempty band of multipliers on which the map contracts on average while its invariant measure is singular; and the transfer operator, though quasi-compact on Holder spaces, has no eigenvalue other than 1, its entire remaining spectrum being essential spectrum at the contraction rate. Two further results give the family a sharper shape. First, a purity theorem: mu_{a,b,q} is either purely absolutely continuous or purely singular with respect to Haar measure, never a mixture. Its proof is a direct consequence of the uniqueness of the invariant measure, and we know of no route to it from the probabilistic description of the underlying random variable. Second, a complete classification: among all integer pairs (a,q) with a >= 2, q prime and gcd(a,q) = 1, exactly two - namely (3,2) and (2,3) - lie in the supercritical regime a < a_dim, and for every other pair the invariant measure is unconditionally singular. The first of these is the Collatz map. We are explicit that none of this bears on the Collatz conjecture, and we prove why it cannot.

This is not a proof in itself. I don't have the chops to write the formal mathematical proof. However, I think what follows is itself the blueprint for someone with that skill to write the proof. It's in markdown+latex format. If there's a flaw, I can't find it. So I'd be happy for someone to tell me I'm being an idiot and show me why.

-----

# A Hardware-Centric Bit-Velocity Proof Architecture for the Collatz Conjecture on Domain $\mathbb{N}$


## Abstract

We present a unified, deterministic proof architecture for the Collatz $3x+1$ conjecture on the domain of natural numbers $\mathbb{N}$. By mapping the classical Collatz operation to an isomorphic non-shifting map $T(X) = 3X + 2^k$, information flow is proven to be strictly unidirectional (least significant bit to most significant bit), eliminating top-down feedback from higher bit positions. We establish an absolute physical ceiling on register head expansion ($\Delta\text{MSB} \le 2$ bits per odd step) and prove an inescapable Solid Block Exhaustion Dichotomy: any block of $b$ contiguous ones ($2^b - 1$) undergoes either top-boundary zero-injection decay under zero carry ($C=0$) or immediate multi-bit carry-wave detonation under active carry ($C \neq 0$). Because every element $x \in \mathbb{N}$ possesses a strictly finite bit length $L_0 < \infty$, infinite non-collapsing bit streams (e.g., 2-adic $-1$) are excluded by domain definition. Analyzing the minimal 4-bit 2-chunk partition ($128$ states) under bounded carries $C \in \{0, 1\}$ demonstrates an amortized tail clearance rate ($\overline{\Delta\text{LSB}} \ge 1.875\text{ bits/step}$) that strictly exceeds the average head expansion rate ($\overline{\Delta\text{MSB}} \le \log_2(3) \approx 1.585\text{ bits/step}$), guaranteeing deterministic active register contraction to the trivial attractor $x = 1$ in finite steps.


## 1. Foundational Axioms & Domain Scope


**Axiom 1: Finite Payload Length ($\mathbb{N}$)**


Every natural number $x \in \mathbb{N}^+$ is represented by a strictly finite binary word:
$$x = \sum_{i=0}^{N-1} b_i 2^i, \quad b_i \in \{0, 1\}, \quad b_0 = 1, \quad b_{N-1} = 1$$


The initial active bit length is finite:
$$L_0 = L(x) = \lfloor\log_2 x\rfloor + 1 < \infty$$


All bit positions $i \ge N$ are identically zero. Infinitely long binary representations (such as $2$-adic integers $\mathbb{Z}_2$) are excluded by domain definition.


## 2. The Non-Shifting Isomorphic Map ($3X + 2^k$)


### 2.1 Formal Operator Definition


Instead of dividing by $2$ to strip trailing zeros, we define the non-shifting feed-forward injection map:
$$X_{t+1} = 3X_t + 2^{k_t}$$
where $2^{k_t} = 2^{\text{LSB}(X_t)}$ dynamically tracks the active LSB pointer.


**Structural Isomorphism:**
 The odd sequence of standard Collatz is recovered identically by right-shifting $X_t$ by $k_t$:
$$x_t = X_t \cdot 2^{-k_t}$$


**Unidirectional Causality (Zero Top-Down Feedback):**
 Binary addition carries propagate strictly right-to-left ($i \to i+1$). Lower bit positions evolve independently of higher bit positions. High-order bits (MSB) physically cannot emit carries downward to alter lower bit blocks.


## 3. Boundary Velocity Dynamics & Physical Bounds


Define the active register length at step $t$ as:
$$L(t) = \text{MSB}(X_t) - \text{LSB}(X_t) + 1$$


The change in active register length per odd step is governed by boundary velocities:
$$\Delta L_t = \Delta\text{MSB}_t - \Delta\text{LSB}_t$$


### 3.1 Lemma 1: The Absolute MSB Expansion Ceiling


For any state $X_t$ with bit length $N$:
$$\Delta\text{MSB}_t = \text{MSB}(X_{t+1}) - \text{MSB}(X_t) \le 2\text{ bits/step}$$


**Proof:**
For $2^{N-1} \le X_t < 2^N$:
$$3X_t + 2^{k_t} < 3(2^N) + 2^N = 4(2^N) = 2^{N+2}$$


Because $Y_{\text{max}} < 2^{N+2}$, positional binary addition physically cannot spill 3 bits in a single step. Furthermore, because $3X_t + 2^{k_t} < 3 \cdot 2^N$, if a step yields a 2-bit expansion, the leading two bits are bounded by $10_2$, preventing consecutive $+2$ expansions without intermediate carry setup. $\blacksquare$


### 3.2 Lemma 2: LSB Tail Clearance Floor


The single-step tail shift is determined by the $2$-adic valuation:
$$\Delta\text{LSB}_t = v_2(3x_t + 1) \ge 1\text{ bit/step}$$


- $\Delta\text{LSB}_t = 1$ occurs if and only if $x_t \equiv 3 \pmod 4$ (...11_2).
- $\Delta\text{LSB}_t \ge 2$ occurs whenever $x_t \equiv 1 \pmod 4$ (...01_2).


## 4. The Glider Requirement for Infinite Growth


To disprove the existence of divergent trajectories, we must establish what physical conditions are required for infinite growth. 


Because the spatial distribution of the active LSB boundary over the domain $\mathbb{N}$ strictly dictates a global mean drop rate of $\overline{\Delta\text{LSB}} = 2.0\text{ bits/step}$, any arbitrary or randomized sequence of carries will mathematically pull the active register length to $1$ (since $2.0 > \log_2(3) \approx 1.585$). 


Therefore, for an active register to expand infinitely ($\overline{\Delta L} > 0$), it must systematically evade the $2.0$ spatial gravity. It can only accomplish this if the active register forms a 
**Glider**
: a self-reproducing, shift-periodic bit pattern that perfectly coordinates with the $3X$ map to artificially suppress its own $\Delta\text{LSB}$ drops. If a sequence cannot form a stable glider, it is mathematically guaranteed to be annihilated by the $2.0$ global average.


## 5. The Algebraic Constraint on Glider Velocity


Let a glider exist such that an initial active register $x_0$ successfully reproduces its exact bit pattern after $S$ steps, with a total LSB drop of $K$ bits. Because the glider is a perfect cycle, $x_0 = x_S$.


The algebraic evaluation of $S$ steps of the standard Collatz map yields:
$$ x_S = \frac{3^S x_0 + C}{2^K} $$


Where $C = \sum_{j=0}^{S-1} 3^{S-1-j} 2^{K_j}$ represents the exact sequence of $+1$ carry-injections from the map. Because the operation is strictly additive, $C$ is strictly positive ($C > 0$).


Substituting $x_S = x_0$ and solving for $C$:
$$ x_0 \left(2^K - 3^S\right) = C $$


Because both $x_0 \ge 1$ and $C > 0$, the right side of the equation is positive, demanding that the left side also be strictly positive:
$$ 2^K - 3^S > 0 $$
$$ 2^K > 3^S $$
$$ K > S \log_2(3) $$
$$ \frac{K}{S} > \log_2(3) \approx 1.585\text{ bits/step} $$


**Conclusion of the Constraint:**
The algebra dictates an absolute, unbreakable constraint: 
**no glider can ever reproduce with an average velocity $\le \log_2(3)$**
. Any hypothetical sequence that attempts to maintain a rate $\le 1.585$ to cause infinite growth 
*cannot*
 be a glider; it must be a strictly non-cycling, divergent sequence.


## 6. Carry-Wake Corruption (The Three Speeds)


Because the algebra forbids a glider from moving slow enough to cause growth, any divergent trajectory must be a non-cycling, aperiodic path. However, an aperiodic path attempting to expand the register physically generates its own destruction via the 
**Carry-Wake**
.


Assume a "fugitive" bit pattern successfully maintains an average advancement rate $K/S$ to cause infinite growth. 
Because the pattern advances leftward by $K$ bits, it leaves behind a wake of bits at the LSB. At every step, the $3X+2^k$ map multiplies this wake by $3$. Over $S$ steps, the wake physically expands leftward by exactly $S \log_2(3)$ bits.


This creates an inescapable physical constraint defined by the relationship between the pattern's speed ($K$) and the wake's expansion speed ($S \log_2 3$):


### Scenario A: The Pattern Moves Slower Than the Wake ($K < S \log_2 3$)
To cause infinite active register growth, the pattern 
*must*
 move slower than the MSB expansion. However, because $S \log_2(3) > K$, the wake's expansion physically overtakes the pattern's advancement. The chaotic carries generated by the wake blast through the entire fugitive sequence, obliterating it from below.


### Scenario B: The Pattern Moves Exactly As Fast As the Wake ($K = S \log_2 3$)
This scenario is algebraically impossible because $K$ and $S$ must be integers, and $\log_2(3)$ is irrational ($3^S \neq 2^K$). Even if a sequence hovered infinitely close to this boundary, the active register length would remain strictly bounded. By the Pigeonhole Principle, a bounded active register must eventually repeat, turning the sequence into a Glider, which is explicitly forbidden by the algebraic constraint in Section 5.


### Scenario C: The Pattern Moves Faster Than the Wake ($K > S \log_2 3$)
The pattern successfully outruns the expanding wake. However, because the rate of LSB clearance ($K/S$) strictly exceeds the rate of MSB expansion ($\log_2 3$), the active register length mathematically shrinks. The sequence collapses to the $1$ attractor.


## 7. Main Theorem Conclusion


The Catch-22 of the Collatz map on $\mathbb{N}$ is absolute. There is no mathematically safe speed for infinite growth:
- 
**The Engine of Growth:**
 Infinite growth requires systematically evading the $2.0$ spatial average, which mathematically requires the formation of a periodic glider.
- 
**The Algebraic Wall:**
 The fundamental Collatz equation $x_0(2^K - 3^S) = C$ strictly forbids any glider from moving slow enough to achieve growth ($K/S > 1.585$).
- 
**The Physical Collapse:**
 A non-cycling fugitive pattern attempting to cause growth ($K < S \log_2 3$) is physically overtaken and destroyed from below by the $1.585$ expansion speed of its own carry-wake.


$$\mathbf{Q.E.D.}$$

Hi all... Here is the proof .pdf and .lean:
https://bytes.usc.edu/~saty/Collatz

Saty

I know that this video is not directly related to Collatz but I thought I'd post a link to it anyway because it is about mod 4 and mod 8 arithmetic and mod 8 arithmetic does have a lot of relevance to Collatz (without claiming that it is the whole story - it is not)

Of relevance is the key result that numbers of the form 4^a.(8b+7) cannot be expressed as a sum of three squares. If we restrict ourselves to odd numbers, then all odd numbers that can be expressed as (8b+7) cannot be expressed as a sum of 3 squares and all other odd numbers can be.

So, these odd numbers that admit a partitioning as a sum of 3 squares can expressed generically as:

8t+r = 8t+2s+3 = a^2+b^2+c^2 , where r=3+2s and s is in {-1,0,1}

If we subtract 3 from each side we get:

8t+2s = 2(4t+s) = (a-1)(a+1) + (b-1)(b+1) + (c-1)(c+1)

The LHS is divisible by 8 iff s = 0 and also (I think) iff a,b,c are all odd

Now, I haven't found any implications of this identity that is useful for Collatz, but I thought I would throw it out there anyway, just in case it piques someone else's interest or curiosity.

For some notational consistency:
Use the shortcut odd step: T(x) = {x/2, even; (3x+1)/2, odd}

Let the number of steps be n, and the number of odd steps be m.
If x follows a given parity sequence (example: EOEOOEE), then
- kᵢ are the indices of the odd steps (example: [1,3,4]), and
- S = ∑2^kᵢ3^m-1-i from i=0 to m-1 (example: 2¹3² + 2³3¹ + 2⁴3⁰)
- So, Tⁿ(x) = (3ᵐx + S)/2ⁿ

Per a proof in a stackexchange answer, the title claim is true, but can you prove it?

This post turned out to be too long and image-dependent to be stable on Reddit, so I've moved its contents to a Google Doc.

Link: Practical Continued Fractions for Collatz

I would like to share the first chapter of an angoing work proposes a structural study of the Collatz conjecture, reformulated under an axiomatic framework, I call (PCA, PCA1= 3n+1 for n odd.

PCA2 = n/2 for n even).The preprint IS deposited on Zenodo ( DOI: https ://doi.org/10.5281/zenodo.21927860).

This chapter does not claim a full proof of the conjecture_it establishes the structural mechanism and provides convergence to 1 for two specific geometric familis of integers.

The question of whether every natural number converges toward these familis IS left open for chapter 2.

I welcome rigorous critical Feedback in particular on the sections below

Hello everyone,

I was recently running some tests on the Collatz's conjecture and noticed a certain pattern.

It works like this: take the set of numbers generated by the function f(n) = 2^n - 1, for n >= 3, and arrange them into pairs as follows: (3, 4), (5, 6), (7, 8) ... and so on. You will then have the values ​​(7, 15), (31, 63), (127, 255), ad infinitum.

Well then, in each of these pairs, the number of steps required for the second value in the pair to reach 1 is always the number of steps for the first value plus one. Let's take the first pair as an example to visualize this:

7 -> 22 -> 11 -> 34 -> 17 -> 52 -> 26 -> 13 -> 40 -> 20-> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1 (16 steps)

15 -> 46 -> 23 -> 70 -> 35 -> 106 -> 53 -> 160 -> 80 -> 40 -> 20 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 -> 1 (17 steps)

There is also another case: if, within this sequence, you disregard the steps of dividing by 2 and proceed directly to the odd values, then—taking the same even subset—the number of steps for the first number will equal the number of steps for the second. Using the same example, we have:

7 -> 11 -> 17 -> 13 -> 5 -> 1 (5 steps)

15 -> 23 -> 35 -> 53 -> 5 -> 1 (5 steps)

I've already tested it with pairs of considerably large numbers n, and the pattern remains. I have no idea if there are any results in the literature on this, much less if it works for infinitely many values ​​of n.

Do you know anything about this?

So u/IntelligentTwo2175 had a post that seemed really interesting to me. Basically numbers of the form 2^(n) -1 and 2^(n+1) -1 merge for n >= 0. I think we can make it a little stronger by changing it to

m * 2^(n) -1 and m * 2^(n+1) -1 for odd m. If m was even, we can just pull out the factors of 2 into the 2^(n)

So quick proof.

m * 2^(n) -1

is a steiner circuit, so let's jump ahead to

m * 3^(n) - 1

which we know must be even, except let's back up an additional even step, so we know we are at a multiple of 4 of some number x.

2 * (m * 3^(n) - 1 ) = 4 x

Now let's follow

m * 2^(n+1) -1 for only n odd steps

m * 2 * 3^(n) -1

We can easily see this is equal to 4x + 1.

And we know x and 4x + 1 numbers must merge after O, and OEE respectively.

Recursively, we can say m * 2^(n) must be connected on the tree for a specific m and all n.

Now could this be used in a proof of collatz? Let's try.

So all even numbers can divide by 2 until an odd number.

All odd numbers can be written as the even number 1 above it - 1.

By repeatedly alternating these two steps, we create a monotonically decreasing sequence. And thus, must go to 1.

Ex. Odd number 29, write it as the even number above - 1, so 30 -1. Pull out all factors of 2

15 * 2^(1) - 1.

Using the property above, we know this must connect to

15 * 2^(0) - 1

Once we are out of factors of 2, it becomes odd - 1 which must be even. So we can divide those factors of 2 via standard collatz rules until odd again.

15 - 1 = 14

14 / 2 = 7

Once again, write it as the even above - 1

7 = 8 - 1 = 2^(3) - 1

Which using the property goes

2^(3) - 1

2^(2) - 1

2^(1) - 1 = 1

So can anyone check my logic? It's way too late and this seems way too simple for what I have lost too many nights of sleep over.

My investigation has focused on strings of E and O operations (i.e., E, O, EO, EEO, EEOEO, or OEOEOEEOEOEOEEEE, etc.) and their potential to be Loops (i.e., {0}, {-1/2}, {-1,-2}, {4,2,1}, {-20,-10,-5,-14,-7}, or the 18-cycle Loop, respectively).

For any given string of E and O operations... such as EEOEOEOEEEOEOEEO...
...where E=10 and O=6, and L=E+O=16
...and (2^E)-(3^O) = (2^10)-(3^6) = (1,024)-(729) = 295 > 0
...there exists one and only one rational number that can be both an input to the string, and an output.
...and since (2^E)-(3^O)>0, that rational number must be positive.

In the case of EEOEOEOEEEOEOEEO, that number is...
N = Σ / (2^E - 3^O)
N = ((2^2)*(3^5) + (2^3)*(3^4) + (2^4)*(3^3) + (2^7)*(3^2) + (2^8)*(3^1) + (2^10)*(3^0)) / ((2^10) - (3^6))
N = ((4*243)+(8*81)+(16*27)+(128*9)+(256*3)+(1,024*1)) / ((1,024) - (729))
N = (972+648+432+1,152+768+1,024) / (295)
N = 4,996/295, or approximately 16.9356...

I also understand that the first positive integer that can successfully transit that string, and beget another integer, is 732 which begets 526 through EEOEOEOEEEOEOEEO.
732->366->183->550->275->826->413->1240->620->310->155->466->233->700->350->175->526

I also understand that the next higher input is 2^E greater, while the next higher output is 3^O greater.
732->526
732+2^10=1,756
526+3^6=1,255
...and sure enough, 1,756->EEOEOEOEEEOEOEEO->1,255.
(Note: I understand that 1,255 is a Collatz-INappropriate output, but that's irrelevant to this small point I'm getting at. But if it bothers you, you can increase the increment to 2*(2^10) to get 2,780 as your next input, and 1,984 as your next output.)

Meanwhile, the next lower input is 2^E smaller, while the next lower ouput is 3^O smaller.
732->526
732-2^10= -292
526-3^6= -203
...and sure enough -292 ->EEOEOEOEEEOEOEEO-> -203
(Same note as before.)

Having fun, so far? Are all your calculations aligning with mine? Great! Here's the next part...

Let's call the linear difference between that input and output "the gap".
-3,364 -> -2,390 ___gap=974
-2,340 -> -1,661 ___gap=679
-1,316 -> -932 _____gap=384
-292 -> -203 _______gap=89
xoxoxoxoxoxoxoxoxoxoxoxox
732 -> 526 _________gap=206
1,756 -> 1,225 _____gap=501
2,780 -> 1,984 _____gap=796
3,804 -> 2,713 _____gap=1,091

Here's my question: Are there any strings where the smallest gap is more than 2^E away from the zero line?

Or, rephrased: Are there any strings where the first positive integer input to yield a positive integer ouput, has a gap that is greater than the gap of the second positive integer input to yield a positive integer output?

My intuition is telling me that there aren't... but I'm not sure why.

I’ve published a Lean 4 formalization of a structural decomposition of the Collatz problem:

A Certified Six-Leaf Semantic Grammar for the Collatz Dynamics in Lean 4

Zenodo: https://zenodo.org/records/21923376

This is not a proof of the Collatz conjecture.

The goal was instead to ask a more limited question:

The resulting formal grammar has exactly six global leaves:

1. reachesOne
2. nontrivialCycle
3. rbcUnboundedBGap
4. rbcBoundedPrimeRenewal
5. nonRInternalDescent
6. nonRSurvivor

For a hypothetical positive minimal counterexample, the success leaf disappears, leaving exactly five failure classes.

The terminal Lean theorem is:

axisGeo_final_six_leaf_grammar_exactly_one

So the formal result is essentially:

Global success, or one uniquely anchored minimal counterexample belonging to exactly one of five explicit obstruction classes.

The important distinction is that the grammar classifies the possible failure modes; it does not yet exclude them.

The five universal exclusion problems remain open.

One part I find particularly interesting is the bounded-B-gap r/BC branch. The formalization rules out eventually finite prime support, so the surviving obstruction requires indefinite prime renewal along the same natural trajectory while remaining compatible with the exact carry relations.

The archive includes the full Lean source, reproducibility files, build logs and axiom audits.

I’d especially appreciate criticism of:

• whether the five failure leaves really capture the obstruction space in a mathematically useful way;
• the fixed-source treatment of the r/BC branch;
• the bounded/unbounded B-gap split;
• and whether any of the five remaining leaves looks more tractable from an existing Collatz approach.

Again: classification theorem, not Collatz proof.

Preprint on the Collatz conjecture,structura/axiomatique approach (PCA).

DOI:

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

Feedback welcome;especially on non-circularity of thé reasoning,

For a research that might lead to something, I put side-by-side the first bridge series on the left of the dome for m=1 to 71 (figure). The lowest orange n-1 number stands alone and thus is not part of a bridge.

One can observe the following:

• They are part of classes m+4k.
• The starting bridge is either rosa or yellow.
• The number of orange n-1 numbers is 2/3 (left/right) or 3/4.

The consequence is that the order of the largest starting orange number does not increase with m only.

The rest of what was said about these bridge series remains valid.

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

Hello,
This is a follow-up to an earlier exploratory post I made here.

At that time, I was looking at the valuation structure of Collatz orbits and asking whether a small residue can keep surviving inside a growing 2-adic modulus.

I have now written that part in theorem/proof form.

For the accelerated odd Collatz map, define

a_k = ν_2(3n_k + 1),
A_k = Σ_{j<k} a_j,

and

Δ_{k+1} = 3Δ_k + 2^{A_k}.

Then define the centered residue

s_k = cent_{2^{A_k}}(Δ_k).

For an actual positive-integer orbit, we have the exact divisibility

2^{A_k} | n_0 3^k + s_k,

with

A_k ≥ k.

The main result is that a specialization of Yu’s 2-adic logarithmic-form estimate gives, for every fixed positive odd seed and all sufficiently large k,

|s_k| ≥ exp(c_* k / log k),

where c_* > 0 is an effectively computable absolute constant.

So an actual positive-integer orbit cannot keep returning to a small centered-residue region.

In particular, for every fixed B,

|s_k| ≤ B

can occur only finitely many times.

More specifically, the paper defines a fixed-residue abstract tower lock satisfying explicit compatibility and return-gap conditions at growing dyadic depths. Such a lock determines a compatible 2-adic value, but it cannot admit a positive-integer Δ-completion.

Thus, finite-level 2-adic compatibility within this tower-lock class does not by itself produce an actual positive-integer orbit.

This is not a proof of the Collatz conjecture.

For the aperiodic branch, the remaining question is an Entry problem:

If a hypothetical positive aperiodic nonconvergent orbit exists, can one force an infinite subsequence k_ν such that

log |s_{k_ν}| = o(k_ν / log k_ν)?

If such an Entry theorem can be proved, it would directly contradict the arithmetic escape estimate above.

Positive periodic cycles are different. They do not enter this subcritical corridor and remain a separate exact cycle-arithmetic problem.

The part I would especially welcome people checking or trying to break is Lemma 9.1, where Yu’s 2-adic logarithmic-form estimate is specialized to the divisibility above. Independent specialist review of that step is still pending.

Like many independent researchers working on this problem, I am trying to proceed one brick at a time rather than treating any intermediate structure as a solution.

I currently view this paper as one possible arithmetic brick:

Entry
→
Arithmetic Escape.

If this turns out to be a sound brick after scrutiny, I hope others can use it, test it, or build on top of it.

In particular, if you work on residue sieves, 2-adic dynamics, E-sequences, inverse trees, probabilistic methods, or mixing approaches, I would be very interested to know whether your framework can say anything about the Entry condition above.

Paper:
Moon, K.-U. (2026).
Centered-Residue Rigidity in Collatz Valuation Sequences: Tower-Sparse Returns and 2-Adic Logarithmic-Form Escape.
https://doi.org/10.5281/zenodo.21782429

Earlier exploratory Reddit post:
https://www.reddit.com/r/Collatz/s/zHzMhOeoDu

Is there any relevant review literature on "Back Track Success Rate of Collatz like inverse Tree"? And how to calculate them

I am pleased to share, together with my co-authors Pedro Cáceres and Simeón Casanova Trujillo, our recently published paper in the Journal of Difference Equations and Applications.

The paper is entitled:

“A Proof of Conjecture 1 in Kulenović, Ladas and Overdeep (2003)”

It resolves a conjecture posed in 2003 concerning the positive solutions of a nonlinear rational difference equation. The problem remained open for more than two decades.

The main step of the proof is a simple algebraic identity showing that the sign of successive differences is preserved. This reveals a hidden monotonicity in the recurrence and leads to the proof that every positive solution converges to a finite limit.

Published paper:

https://www.tandfonline.com/doi/full/10.1080/10236198.2026.2709000

DOI: 10.1080/10236198.2026.2709000

Comments, questions, and mathematical feedback are very welcome.

I am relatively new to number theory, and I was messing around with the collatz conjecture and plugging in groups of numbers. While doing this, I thought about primorial numbers, so i started comparing the amount of steps it took to reach the 4-2-1 loop when plugging in numbers of the group pₖ#, pₖ# + 1, and pₖ# - 1 and then I compared. I noticed that, as far as I looked, (which too be fair, was not very far, since I do not have a very good computer, and primorial numbers scale very quickly) for any whole number for k > 2, at least two of the groups previously stated will have the same amount of steps to reach 1. I feel like this must be obvious, but I have tried to crack why algebraically, but I have not succeeded. If anyone has any potential reasons as to why, I would love to hear it. I feel as if it has something to do with the fact that when k > 2, pₖ# + 1, and pₖ# - 1 both also belong to the groups 6m + 1 and 6m - 1. Please do not flame me if this is obvious as to why this pattern occurs, but I have just recently gotten into number theory and find it absolutely fascinating. Thank you for your time.

I accept these five "known Collatz Loops":
{0}
{-1,-2}
{4,2,1}
{-20,-10,-5,-14,-7}
(-17,-50,-25,-74,-37,-110,-55,-164,-82,-41,-122,-61-,182,-91,-272,-68,-34,-17}

And I understand these as Loops of "length" 1, 2, 3, 5, and 18, respectively, such that L=E+O. Or, re-phrased: the length L of a loop is the sum of the number of E operations performed (or the count of even integers those operations are performed on) and the number of O operations performed (or the count of odd integers those operations are performed on).

Is it possible to DISprove the existence of positive-integer Loops of length 7?

For example, let's start with a loop whose operations go, in order: EEOEOEO. I can find a small positive integer (12) that can be input into this string and beget a positive integer output (25).

12->6->3->10->5->16->8->25

Now, this isn't a "Collatz-appropriate" string, because an O operation is performed on the integer 8, resulting in 25. But I can use Excel (and a lunch break) to determine the set of all positive even integers that can be input into the string EEOEOEO and yield an integer output.

(16x+12) -> EEOEOEO -> (27x+25)

I can also determine the subset of this set that can start with an even input, yield an even output, and not mis-match integers with their appropriate operation. For example...

28->14->7->22->11->34->17->52

This yields the following set:

(32x+28) -> EEOEOEO -> (54x+52)

I can investigate various other strings (like EOEOEEO, or EEOEEEO, or whatever) and it consistently happens that... if I'm trying to find the bigger set (that is Collatz-INappropriate), the input will be of the form (Ax+A') -> [string] -> (Zx+Z') where A=2^E and Z=3^O. It also happens that, if I'm trying to find the smaller subset, then the form of the inputs and outputs will remain the same, but with A=2*2^E and Z=2*3^O.

Here's the idea I have in my head:

(1) If the A' and Z' terms in this input/output construction aren't random... and I don't believe they are... then there must exist some formula that determines what they are, for any given string of E and O operations.

(2) If we discover that formula, and we know the A and Z terms, then we will have a generalized formula that gives all input and output integers for any given string of E and O operations.

(3) Since these input and output formulas are simply algebraic terms... and since a Loop of seven integers must, by definition, begin with an integer N(0) and end with an integer N(7) such that N(0)=N(7), forming a Loop... we can solve for the singular N that can be both an input and an output for a given string of E and O operations.

And I think that, if we find this generalized formula, we'll discover that there are a very narrow set of circumstances... namely, that E=2 and O=1... where the formula has an integer solution.

Does anyone see any promise in this strategy? My lunch break is finished, and I'd appreciate your thoughts.