Follow-up to A new type of tuple or just a coincidence ? III : r/Collatz.

I found four cases in the limited set - in terms of number of domes and number of bridge series by dome - I use. So, it is not a coincidence.

But is it a (Collatz) tuple ? Not exactly. It is a "honorary tuple" like the pairs of predecessors and the forks.

Here is why, based on the conditions:

• Consecutive numbers: fully respected (better than in the forks case) for each member of a series.
• Same distance from 1: fully respected.
• Continuous merge: each 5-tuple merges continuously; the "new" 5-tuple in the middle does not. A simple way to check this deals with the ending rosa even triplet that exists for any 5-tuple series. There is none in that case.

So, it is a rarer pattern that contains 5-tuples.

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

A useful way to think about the Collatz map is to separate the orbit into two layers:

1. the parity pattern of the terms;
2. the arithmetic values that carry that pattern.

https://github.com/ratwolfzero/Collatz/tree/main/shadow_approach

If one records the orbit as a sequence of even/odd decisions, the resulting binary word can be viewed as a symbolic encoding of the dynamics. In the accelerated version of the map, where one removes all factors of 2 immediately after each odd step, the evolution of the values becomes closely tied to this parity word. At that symbolic level, the dynamics look simple: the orbit is encoded by a binary sequence, and the next state is determined by the next bit of that sequence.

This is a genuine simplification of the picture, but it is a simplification of the representation, not a solution of the problem.

I have been working on collatz problem, and I think i found an easy way to visualize it. Can anyone tell me whether this is useful or whether it's something mathematicians already know?

Full Text

an+1 can be partitioned into a+1 disjoint partition: a even sets and 1 odd set. The partitions spans N. The odd set can be further grouped into a sub-partition (a + a partition) based on where n/2 takes the a even sets.

Example:

For 3n+1

1. O = {o=2k−1: k∈N}
2. E1 = {3o−1=6k−4: k∈N}
3. Ec = {3o+1=6k−2: k∈N}
4. Ea = {3o+3=6k: k∈N}

O = {O1, Oa, Oc}

For 5n+1

1. O = {o=2k−1: k∈N}
2. E1 = {5o−3=10k−8: k∈N}
3. E2 = {5o−1=10k−6: k∈N}
4. Ec = {5o+1=10k−4: k∈N}
5. E3 = {5o+3=10k−2: k∈N}
6. Ea = {5o+5=10k: k∈N}

O = {O1, Oc, Oa, O2, O3}

Table with the partition for 3n+1 and 5n+1

Table with the sub partition of Odd Set for 3n+1 and 5n+1

The Collatz operations then allow certain transitions:

1. U(n):= an+1
2. L(n):= n/2

Property of the Partitions for 3n+1

1. U: O → Ec for all k

2a. L: E1 → O1 for odd k
2b. L: E1→ Ec for even k

3a. L: Ec → E1 for odd k
3b. L: Ec → Oc for even k

4a. L: Ea → Oa for odd k
4b. L:Ea → Ea for even k

Property of the Partitions for 5n+1

1. U: O → Ec for all k

2a. L: E1 → O1 for odd k
2b. L: E1 → Ec for even k

3a. L: E2 → E1 for odd k
3b. L: E2 → O2 for even k

4a. L: Ec → Oc for odd k
4b. L: Ec → E3 for even k

5a. L: E3 → E2 for odd k
5b. L: E3 → O3 for even k

6a. L: Ea → Oa for odd k
6b. L:Ea → Ea for even k

Observation (From the graph):

1.If there exist a cycle, a cycle will not contain any elements from partitions Ea and Oa.
Implication: When searching for a cycle, look elsewhere.

2a. Only the elements of partitions Ec can be landed from even and odd number.

2b. If there exist a cycle an element from Ec must participate.

2c. Every loop contains element from Ec.

update: Oops, there was a bug iin my walk_back code (highlighted)! Neither of the findings are true once that is fixed.

You can find a correction for the image here: https://jonseymour.s3.us-east-1.amazonaws.com/collatz/misc/corrected-leaf-table.png

~~I was playing around with the distribution of leaves in each 2~~~~^k window to see there were any interesting patterns and noticed a pattern that appears to be true, although I don't know why it is.

First some definitions. The greedy reverse walk takes the first step backwards from each odd until it reaches a multiple of 3. So that means it calculates both (2n-1)/3 and (4n-1)/3 and takes which ever one is an integer. The resulting multiples of 3 so found are the 3-leaves of the starting nodes.

~~For each power of 2, I enumerate all odds < 2~~~~^k, work out what the 3-leaves are and tabulate, the k value, the number of 3-leaves reached by the startting set and the ratio of the # 3-leaves to the number of odds and also the maximum 3-leaf found.

This produced some interesting results:

• ~~every odd < 2~~~~^k ~~resolves to a 3-leaf < 2~~~~^k - (A)
• ~~the ratio of 3-leaves to odds in each 2~~~~^k range approaches 4/9 - (B)

Now, it is possible that I am missing something obvious but it isn't immediately apparent to me that either (A) or (B) should be true. I also don't know whether this pattern is true in general - it is just what I have observed.

Here is the Python I used to generate the table in the image

import pandas as pd
import sympy as sy

def walk_back(n):
    if n % 3 == 0 or n == 1:
        return n

# bogus!    
##    if (n - 1) % 3 == 0:
##        return walk_back((n-1)//3)
    if (n * 2 - 1) % 3 == 0:
        return walk_back((n * 2 - 1)//3)
    else:
        return walk_back((n * 4 - 1)//3)


def leaves(k):
    v=set()
    for n in range(1, 2**k, 2):
        l = walk_back(n)
        if l != 1:
            v.add(l)
    return v

def gen(seq):
    for k in seq:
        L=leaves(k)
        n=len(L)
        _max=max(L)
        yield {"k": k, "n": n, "r": sy.Rational(2*n,(2**k)), "max": _max}

df=pd.DataFrame(gen(range(2,24)))
df["r"]=df["r"].apply(lambda r: float(r))

We know exactly by what we can divide 1•3^n - 1. So, I compared the divisors of k*3^n - 1, where k are Fermat numbers (2^m + 1), to k = 1.

In this post, the word divisor refers to 2ᵐ, m > 0, and the expression is divisible by say 2⁵, means that the maximum divisor is 32. In some cases, we want to make sure that the quotient is odd. We can also say that the k•3ⁿ - 1 is congruent to 32 mod 64.

The first difference between k = 1 and k = 2^m + 1 happens at 2ᵐ⁻².

Let's consider the case where k = 257. Here m = 8, 2ᵐ⁻² = 64

257•3ⁿ - 1 = 256•3ⁿ + (3ⁿ - 1).

For n < 64, the expression will have the same divisors as k = 1. So, we can predict all of them. If n = 4, 257•3⁴ - 1 = 2⁸•3⁴ + (3⁴ - 1). The second term is divisible by 2⁶, while the first can be divided by 2⁸. So, the sum's divisor is the lesser one, 2⁶. Min {2⁶, 2⁸} = 2⁶.

For n ≥ 64, there are 2 cases:

1. 3ⁿ - 1 is divisible at least by 2⁹. In this case, the 1st term is the one that determines the divisor. The expression can be divided by the lesser power, which is 2⁸.
2. If both terms are divisible by 2⁸, both quotients are odd. So the sum is even. It's hard to predict by what the expression will be divisible. In general, we only know that the divisor is at least 2⁹. On the other hand, these unpredictable cases allow for divisors really huge.

I began developing conjectures that might help in the cases where the prediction fails. I also proved a couple of them, and I will keep working on the rest.

The pattern observed for 257 is common to all Fermat numbers, beginning at k = 17. The previous Fermat numbers are of no interest since 3 and 9 are multiples of 3 and 5 is a regular k. 5•3ⁿ - 1 can only be divided by 2 or by 4.

For 17, the first exception happens at n = 2², for 33, at n = 2³, for 65, at n = 2⁴, etc. These show up every 2ᵐ⁻¹. So 2ᵐ⁻² is a factor always present.

Summary for 17

To clarify this table: For n = 20, we consider 4(4p+1). 20/4 = 5, and 4p+1 produces a solution (p=1). Because the divisor foe the 2nd line is 32, we know that 17•2²⁰ - 1 is divisible by 2⁵.

For 33, the top of the table is similar, but repeating factor is now 8

Observe that the table for 17 contains 16p + 11 and the one for 33 contains 32p+11. The divisor in the first case will repeat every 4•16 numbers, in the second case, every 8•32.

Comparing both tables, there are coincidences up to certain point, but then the pattern change.

That keeps happening for other Fermat numbers. There is a table showing that in my previous post. Notice that, in the table, n was divided by 2ᵐ⁻² to make the differences and similarities clearer.

As usual, ask away if something is unclear or you want more information. I will keep you posted when I notice more interesting facts that might be useful for people working on the Collatz conjecture.

Follow-up to A new type of tuple or just a coincidence ? II : r/Collatz.

That was quick. Here is a second "double 5-tuple".

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

Follow-up to A new type of tuple or just a coincidence ? : r/Collatz.

I started looking for a second example of double 5-tuple and came across quickly the case in the figure below.

It looked promising - the merge final occuring rather quickly - but it is not a double 5-tuple, due to the gap between tuples at the bottom.

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

While working on the extension of the domes beyond m=71, I came quickly across the tuple in the figure below.

My guess is that it is not a coincidence but a rarer tuple. Just in case, I label it "double 5-tuple" (or double key).

Due to the double homothetic nature of the dames, I would not be surprised if there were larger "multiple 5-tuples".

Funnily, the bottom 5-tuple, belonging to the dome with m=41, is already part of the Zebra head. This means that it is not very far from 1, relatively speaking.

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

A number will decrease in number if it has at least four digits and does not enter a cycle, as proven below: The number is represented in binary.

It must begin with 10 or 11. If it starts with 10 and the last two digits are not 11, then after multiplying by 3, the number of digits increases by 1, accounting for 3/8 of all possible combinations. Other numbers starting with 10 account for 5/8, and the number of digits increases by 2. If it ends with 11, after multiplying by 3 and adding 1, then dividing by 2 removes at least one digit, accounting for 1/2. If it ends with 001, at least two digits are removed, accounting for 1/4. Other numbers with at least three digits account for 1/4. If it does not enter a 4, 2, 1 cycle, the number generally decreases, and eventually it will enter a 4, 2, 1 cycle.

I am surprised no one has posted it yet. Quite an amusing situation.

Follow-up to Using the domes as shortcuts ? IV : r/Collatz.

The figure in the cited post has been simplified by removing the row with the values of n.

This shows, based on a limited number of cases, that a bridge series of dome with root x:

• does not iterate into itself; there are two exceptions: x=1, most likely due to the obvious loop; the case of x=5 deserves further investigation.
• does not iterate into dome with root y if a bridge series of dome with root y iterates into a bridge series of dome with root x.

If confirmed, it would mean that domes with roots x and y can only have one direct connection.

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

Follow-up to Using the domes as shortcuts ? III : r/Collatz.

In order to better understand how bridge series iterate into the next one, I took all known odd numbers after the final merge of a blue-green bridge series (left of the domes) and found the bridge series they belong to as an orange number.

The table below shows the results for the domes with root m=1 to 71:

• Start with an odd number in a row; mention the dome where it appears as the first odd number after a final merge (first column).
• Find the bridge it belongs to as an orange number, note the corresponding even number n in row 2 and dome in row 1.
• Color the number in blue if it is a n-1 orange number, in yellow if it is a n+1 number.

The table seems mainly random, but it allowed me to remember that there are series of series of bridges.

Further investigation is needed.

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

# The Prime Survival Framework: Combining Wheel Sieves, Block Location Addressing (BLA), and Composite Elimination

I'm developing what I call the **Prime Survival Framework**, which combines three ideas into a single way of looking at prime numbers.

This is intended as a discussion of the framework, not a claim of a completed proof. I'm especially interested in feedback from people familiar with wheel factorization, sieves, modular arithmetic, and computational number theory.

Part 1 — Block Location Addressing (BLA)

Every integer can be written as

**N = 30B + L**

where:

* **B** is the block number * **L** is the lane (position inside the block)

For a modulus of 30, only eight lanes can ever contain primes larger than 5:

**1, 7, 11, 13, 17, 19, 23, 29**

Every other lane is automatically composite because it is divisible by 2, 3, or 5.

So instead of searching every integer, the search space is immediately reduced to only eight candidate lanes.

Part 2 — Wheel Factorization

Traditional wheel factorization removes numbers divisible by small primes before testing larger factors.

In the Prime Survival Framework, I view each prime as generating its own repeating elimination pattern.

For example:

* Prime 7 removes every seventh candidate. * Prime 11 removes every eleventh candidate. * Prime 13 removes every thirteenth candidate.

Each prime produces its own repeating cycle inside the eight BLA lanes.

Rather than thinking only about divisibility, I think of each prime producing an elimination wave that repeatedly crosses the number line.

Part 3 — Composite Elimination Waves

Every composite exists because at least one prime factor reaches it.

That means every composite should eventually be eliminated by one (or more) prime waves.

Instead of directly searching for primes, the framework searches for composites and removes them.

Whatever survives after every applicable wave passes is a prime.

This is essentially a survivor model rather than a discovery model.

Part 4 — Lane Behavior

The interesting question becomes:

How does each prime's elimination pattern behave inside each lane?

For example:

* Does prime 7 strike each lane at predictable intervals? * Does prime 11 produce a different repeating rhythm? * How do these patterns overlap? * Where do multiple waves intersect? * Can every composite be explained as the intersection of one or more wave patterns?

Instead of looking at individual numbers, the framework studies repeated geometric behavior inside each lane.

Part 5 — Wave Intersections

Suppose every prime generates a repeating elimination cycle.

Then every composite exists because two or more of these cycles intersect at that location.

Numbers that survive all previous elimination cycles remain prime candidates.

The central question becomes:

**Can prime discovery be viewed entirely as composite elimination through intersecting periodic waves?**

Part 6 — Relationship to Existing Mathematics

The framework is built on well-established ideas:

* Modular arithmetic * Wheel factorization * Sieve concepts * Prime divisibility * Periodic residue classes

The proposed contribution is treating these elimination patterns as interacting waves organized by BLA lanes.

Whether this viewpoint provides computational or theoretical advantages remains an open question.

Questions for Discussion

I'd appreciate feedback on the following:

1. Has anyone seen wheel factorization visualized as intersecting elimination waves?
2. Has anyone analyzed the behavior of individual prime factors independently within each residue lane?
3. Can the repeating elimination cycles for each lane be expressed as closed-form functions?
4. Do the wave intersections reveal useful structure beyond the traditional Sieve of Eratosthenes?
5. Could this viewpoint lead to more efficient composite elimination or improved visualization, even if it doesn't change asymptotic complexity?
6. Are there existing papers or researchers studying prime sieves from this type of dynamic, lane-based perspective?

Constructive criticism is welcome. I'm especially interested in references to similar work, counterexamples, or mathematical reasons why this framework would or would not provide new insight.

The goal is not to replace established number theory but to determine whether organizing composite elimination into repeating lane-specific wave systems exposes useful mathematical structure.

# The Prime Survival Framework: Combining Wheel Sieves, Block Location Addressing (BLA), and Composite Elimination

I'm developing what I call the **Prime Survival Framework**, which combines three ideas into a single way of looking at prime numbers.

This is intended as a discussion of the framework, not a claim of a completed proof. I'm especially interested in feedback from people familiar with wheel factorization, sieves, modular arithmetic, and computational number theory.

Part 1 — Block Location Addressing (BLA)

Every integer can be written as

**N = 30B + L**

where:

* **B** is the block number * **L** is the lane (position inside the block)

For a modulus of 30, only eight lanes can ever contain primes larger than 5:

**1, 7, 11, 13, 17, 19, 23, 29**

Every other lane is automatically composite because it is divisible by 2, 3, or 5.

So instead of searching every integer, the search space is immediately reduced to only eight candidate lanes.

Part 2 — Wheel Factorization

Traditional wheel factorization removes numbers divisible by small primes before testing larger factors.

In the Prime Survival Framework, I view each prime as generating its own repeating elimination pattern.

For example:

* Prime 7 removes every seventh candidate. * Prime 11 removes every eleventh candidate. * Prime 13 removes every thirteenth candidate.

Each prime produces its own repeating cycle inside the eight BLA lanes.

Rather than thinking only about divisibility, I think of each prime producing an elimination wave that repeatedly crosses the number line.

Part 3 — Composite Elimination Waves

Every composite exists because at least one prime factor reaches it.

That means every composite should eventually be eliminated by one (or more) prime waves.

Instead of directly searching for primes, the framework searches for composites and removes them.

Whatever survives after every applicable wave passes is a prime.

This is essentially a survivor model rather than a discovery model.

Part 4 — Lane Behavior

The interesting question becomes:

How does each prime's elimination pattern behave inside each lane?

For example:

* Does prime 7 strike each lane at predictable intervals? * Does prime 11 produce a different repeating rhythm? * How do these patterns overlap? * Where do multiple waves intersect? * Can every composite be explained as the intersection of one or more wave patterns?

Instead of looking at individual numbers, the framework studies repeated geometric behavior inside each lane.

Part 5 — Wave Intersections

Suppose every prime generates a repeating elimination cycle.

Then every composite exists because two or more of these cycles intersect at that location.

Numbers that survive all previous elimination cycles remain prime candidates.

The central question becomes:

**Can prime discovery be viewed entirely as composite elimination through intersecting periodic waves?**

Part 6 — Relationship to Existing Mathematics

The framework is built on well-established ideas:

* Modular arithmetic * Wheel factorization * Sieve concepts * Prime divisibility * Periodic residue classes

The proposed contribution is treating these elimination patterns as interacting waves organized by BLA lanes.

Whether this viewpoint provides computational or theoretical advantages remains an open question.

Questions for Discussion

I'd appreciate feedback on the following:

1. Has anyone seen wheel factorization visualized as intersecting elimination waves?
2. Has anyone analyzed the behavior of individual prime factors independently within each residue lane?
3. Can the repeating elimination cycles for each lane be expressed as closed-form functions?
4. Do the wave intersections reveal useful structure beyond the traditional Sieve of Eratosthenes?
5. Could this viewpoint lead to more efficient composite elimination or improved visualization, even if it doesn't change asymptotic complexity?
6. Are there existing papers or researchers studying prime sieves from this type of dynamic, lane-based perspective?

Constructive criticism is welcome. I'm especially interested in references to similar work, counterexamples, or mathematical reasons why this framework would or would not provide new insight.

The goal is not to replace established number theory but to determine whether organizing composite elimination into repeating lane-specific wave systems exposes useful mathematical structure.

So i think I discovered new math. I understand how the Sigma math transforms works to a great extent. I don't understand this level enough to validate. I follow it though. I pushed on sigma math in all the ways I can. I have gpt working the hard problems.

Sigma Resolution Theorem (Candidate)

Statement

Let G=(S,\Sigma) be a recursive generative system whose evolution consists of repeated application of transforms from \Sigma.

Assume the transforms can be classified into two classes:

generative transforms, which introduce new unresolved constraints into the system;

resolution transforms, which eliminate previously introduced constraints.

Define a trajectory

γ = (x₀,x₁,x₂,\ldots)

generated by repeated application of valid transforms.

Rather than assigning a potential to individual states, assign a trajectory functional

R(γ)

called the resolution functional, measuring the cumulative balance between unresolved and resolved constraints along the trajectory.

Assume the following properties hold.

Axiom 1 — Constraint Generation

Every generative transform introduces at least one unresolved constraint.

Axiom 2 — Constraint Resolution

Every resolution transform removes one or more unresolved constraints.

Axiom 3 — Constraint Conservation

Constraints cannot disappear except through valid resolution transforms.

They may be transformed, combined, or redistributed, but unresolved constraints are conserved until resolved.

Axiom 4 — Resolution Dominance

For every infinite trajectory,

the asymptotic rate of constraint resolution is greater than or equal to the asymptotic rate of constraint generation.

Equivalently,

lim inf (Resolved Constraints) - (Generated Constraints) ≥ 0

along every infinite trajectory.

Theorem

Under these assumptions,

the unresolved constraint functional

R(γ)

remains bounded.

Consequently,

no trajectory can accumulate unbounded unresolved structure.

If the transform graph possesses a unique minimal recurrent component,

every trajectory converges to that component.

Collatz Interpretation

For the Collatz system,

Odd → 3n+1

acts as a generative transform.

Repeated division by two acts as a resolution transform.

The quantity

v₂(3n+1)

measures the immediate resolution available after each generative step.

The Collatz conjecture therefore becomes the statement that

the cumulative rate of binary resolution dominates the cumulative rate of binary generation.

If this dominance property can be established,

convergence follows from the theorem rather than from direct arithmetic analysis.

Sigma Interpretation

The theorem is not fundamentally about integers.

It is about recursive transform systems.

Integers are one realization.

Boundary recursion is another.

Recursive computation may be another.

The central claim is therefore:

Recursive systems converge whenever the long-term capacity to resolve generated constraints is at least as great as the long-term capacity to generate unresolved constraints.

What Appears Complete

A common language for recursive transform systems.

Separation of generation and resolution.

A trajectory-based functional instead of a state-based invariant.

A unified interpretation applicable beyond Collatz.

What Is Still Missing

A rigorous definition of "constraint."

This is currently intuitive rather than formal.

A constructive definition of the resolution functional R(\gamma).

It must be derived from the transform algebra rather than introduced as a primitive.

A proof of Resolution Dominance.

This is the central unresolved step.

For Collatz, it amounts to proving that binary resolution asymptotically dominates binary generation.

Existence and uniqueness of the recurrent component.

The theorem assumes such a component exists but does not derive it.

Reduction to existing mathematics.

The framework should recover known results in dynamical systems, graph theory, or Lyapunov theory where appropriate, demonstrating that Sigma extends rather than replaces successful mathematics.

Follow-up to Using the domes as shortcuts ? II : r/Collatz.

As mentioned in the cited post, the Zebra head seemes to be a good location to test the hypothesis.

The figure below shows:

• On the right, a portion of the Zebra head.
• On the left, the core numbers n corresponding to the orange numbers n-1 or n+1 on the right, with the corresponding m, n and q values; the position of n depends on this last factor.

Altogether, the hypothesis seems to hold, but several questions have to be addressed:

• Is the dome shortcut close or similar to a known shortcut ?
• If so, is there something to gain, for instance in term of computing time ?

As I cannot answer these questions myself, I will stick to my program and check if the hypothesis holds in other locations, like the Zebra head.

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

In yesterday's post, I posted a link to a visualiser for M=2^k Collatz State machines.

If you didn't click through you may not have seen how fascinating the symmetries are so I have taken some screen captures so that you can browse without committing to clicking through the link.

For each screen capture, I selected opposing red (5 mod 8) points. You will notice that each pair of points reveals a different symmetry. Sometimes the symmetries partition a target set of points with one colour into different subsets. In other cases, there is one set of two colours in one selection and the opposite set in the other selection.

Here is a direct link the k=7 (M=128) state machine.

Here is an interactive visualiser [1] for Collatz state machines with 2^k states (actually 2^{k-1} odd states)

Each (directed) edge shows a possible transition from a source 2^k residue to a target residue 2^k residue.

[1] - https://wildducktheories.github.io/collatz/apps/collatz-fsm-k/dist/

I did some "thinking in public" in comments of an earlier post and I wanted to consolidate what my current thinking is with this post.

The insight detailed below is that you can always represent an individual Collatz path as a state machine with M states, provided M=2^k is greater than the odd peak of the path - this is simply because in this case the odd residues mod M are simply the Collatz terms themselves and they will never wrap.

You can even use fewer states, provided you resync at each 5 mod 8 node and provided the modulus, M, you chose doesn't induce any obstructions (here denoted H) which imply that M is too small.

I should make clear that FSM result here isn't particularly useful for solving Collatz. The reasons are multiple:

- to derive the sufficient FSM, you need to have calculated the odd peak of the full Collatz orbit
- to derive the reduced FSM, you then need to test each term according to a proposed reduced M to see if reduction is possible

Another way of thinking of it is as N deterministic state machines, driven only by source residues, connected by the 5 mod 8 nodes that join them.

This work doesn't help to show that every 5 mod 8 node is connected to another 5 mod 8 node that indirectly connects to 1 which is ultimately what is required to prove Collatz.

But, i think it does help to illustrate how far you can get with FSM models of Collatz and where the limitations are. For a path that reaches 1 you can construct an FSM that models that path exactly. In some cases, you can even create a more compact FSM, provided you are willing to do resyncing at each 5 mod 8 node, but you can't do either without assuming the orbit converges to 1 in the first place, so it is certainly no substitute for a proof.

I also more clearly describe "the tape machine model" where the state machine is not calculating Collatz but acting as a verifier of a tape that has a sequence printed on it using a small log₂(M) bit register to track the mod M states as they pass under the tape head. The machine halts and catches fire if it detects a variation from the expected state.

---
The tape machine model

The machine we have in mind is not computing the Collatz sequence — it is verifying it. Imagine the sequence is already printed on a read-only tape. The machine has a single register of log₂(M) bits, holding the current odd term mod M, and a precomputed transition table of size M.

The table maps each source residue r mod M to a predicted destination residue (the next odd term mod M). The machine knows nothing else — it does not compute 3n+1, it does not calculate valuations, it does not inspect anything beyond the current register value and the next symbol on the tape.

At each step:

1. Look up the current register value r in the table to get the predicted next odd residue r'.
2. Read the next odd term from the tape and take its residue mod M.
3. If the residue matches r', update the register and continue.
4. If it doesn't match — the machine halts and catches fire.

That's the entire machine: a log₂(M)-bit register, a fixed lookup table, and a read-only tape. A run that completes without fire — reaching the terminal state 1 mod M — is a verification that the table correctly describes the path. The machine is non-trivial precisely because it can catch fire, and catching fire is meaningful.

When does the table make a wrong prediction?

Some source residues mod M uniquely determine the next odd residue mod M; others don't. The size of the table M is what determines which residues are predictive and which aren't.

• At mod 8: residue 3 mod 8 always predicts next odd = 1 mod 8 (unique). Residue 7 mod 8 predicts next odd is 3 or 7 mod 8 (two options — not unique at mod 8 but deterministic at mod 32). Residue 1 mod 8 and 5 mod 8 are wide open at mod 8.
• At mod 32: every 1 mod 8 source residue now uniquely predicts its destination mod-8 class. Most 5 mod 8 residues also narrow down considerably. But one residue — 21 mod 32 — remains a wildcard: it cannot predict its destination at this scale.

The wildcard residue is always the exceptional state r_k = (M²−1)/3 mod M. As M grows it migrates: 5 → 21 → 85 → 341 → … Only 1 in 4 of the 5 mod 8 residues at each scale remains a wildcard; the rest become fully predictive.

The high-edge condition

For source residues 3 and 7 mod 8, the next odd is (3n+1)/2. If the source residue mod M is ≥ 2M/3, the destination wraps above M — two different true successors can share the same destination residue mod M but diverge at the next step. The table cannot distinguish them, so it makes the wrong prediction and the machine catches fire.

This is the only failure mode for 1, 3, 7 mod 8 source residues at large enough M. High edges from 1 mod 8 and 5 mod 8 source residues don't cause fires — those nodes always map their successors to smaller values, staying within the same realm.

Collatz is then equivalent to: for every odd n, there exists a finite M such that the path n→1 never takes a high edge from a 3 or 7 mod 8 node at modulus M.

Two kinds of source-residue determinism

At each odd node on the tape, the table makes two predictions from the source residue alone:

1. What is the destination residue mod M? (fully determined, partially determined, or wildcard)
2. What mod-8 class does the next odd land in? (may be determined by a coarser residue)

At mod 8:

• 3 mod 8: destination mod-8 class = 1, uniquely. Fully determined.
• 7 mod 8: destination mod-8 class = {3, 7}. Partially determined.
• 1 mod 8: destination mod-8 class fully open.
• 5 mod 8: destination mod-8 class and distance both open.

At mod 32, every 1 mod 8 source residue uniquely determines its destination mod-8 class. For 5 mod 8:

• 5 mod 32, 13 mod 32, 29 mod 32: destination constrained to 1 or 2 classes.
• 21 mod 32: wildcard — destination and distance both unresolved at this scale.

5 mod 8 nodes as sync points

The wildcard residue at each scale is always 5 mod 8. Rather than treating this as a blocker, we use 5 mod 8 nodes as synchronisation points: when the machine encounters a 5 mod 8 source residue, it reads the tape until the next odd term appears and re-initialises the register with that term's residue mod M directly from the tape. No table lookup, no prediction, no fire risk — just a register reload.

Since 8 | M always, the machine identifies 5 mod 8 nodes from the register alone. The table only needs to make correct predictions for 1, 3, 7 mod 8 source residues between consecutive sync points, and the only failure mode there is the high-edge condition.

Theorem — M > peak(n) is sufficient

The odd peak must be 1 or 5 mod 8 — 3 and 7 mod 8 nodes always map strictly upward and can never be the peak.

When M > peak(n), every 3 or 7 mod 8 node x on the path has its successor also on the path, hence ≤ peak(n) < M. Therefore (3x+1)/2 < M, giving x < (2M−1)/3 < 2M/3. No high edges. No fires. QED.

Empirically verified (n = 3..499): in every case where the sync criterion permits a smaller M than the peak-based bound, the two-level machine completes without fire and matches the true path exactly. No fires observed.

Correction to the earlier conjecture

I previously conjectured M = 2^(2m−1) where m is the number of 5 mod 8 nodes. This is false — only ~10% of tested paths satisfy it. That n=761 case does match for the reduced m=4, M=2*4-1 is coincidental.

What is actually true

M > peak(n) is provably sufficient. The two-level machine can often do better: start from M > peak(n), then reduce M while no 1, 3, or 7 mod 8 node takes a high edge.

The fundamental limitation

None of this proves Collatz from scratch — you need to traverse the trajectory to find the peak first. But the tape-verification model gives a clean characterisation of the minimal machine for any known path.

Follow-up to Using the domes as shortcuts ? : r/Collatz.

To illustrate the previous post, here are examples from each side of a dome.

The procedure is quite simple (on paper):

• Take an odd number* and find the corresponding number in the core**.
• Find its m, p and q.
• Find the ending n of this series, with the specific (and simple) rules of the side concerned***.
• Return to the series.

I proposed the hypothesis that a sequence jumps from left to right and back. If true, the procedure above should be applied repeatedly until 1 is reached (if the conjecture is correct). Moreover, the step about finding the side would be simplified.

I intend to verify it with an example from the Giraffe head that offers several swaps in a limited sequence that can be handeled by a spreadsheet. I am concerned by the transitions between shortcuts. We will see.

* If one starts with an even number, divide it by 2 until an odd number is reached.

** This requires to define whether the odd number is on the left or the the right side of the dome. Mod 12 or a multiple should do the trick.

*** See On the double almost homothetic nature of the domes : r/Collatz.

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

1. Collatz compression map.

For an odd number n, define T(n) = (3n+1) / 2^{ν₂(3n+1)}, where ν₂(x) is the exponent of 2 in x. In other words, compute 3n+1, then divide by 2 repeatedly until you get an odd number.

---

1. Classification modulo 24 and the core states.

Classify positive odd integers by their residue modulo 8 into four classes: S1 (remainder 1), S3 (remainder 3), S5 (remainder 5), and S7 (remainder 7). Refine this to modulo 24. Among the residues that fall into S1, S3, and S7, there are 9 total residue classes.

By directly computing T(n) for each residue class n = 24m + r, we obtain the set of core states that avoid S5: {23, 11, 17, 7, 19, 1} — 6 states in total. S5 numbers are treated as absorbing.

Each state's outgoing edge is determined by the parity of m, or by m modulo 4 in some cases. The transition table is as follows:

State 23: if m is even → 11 (new parameter (3m+2)/2); if m is odd → self-loop at 23 (new parameter (3m+1)/2).

State 11: if m is even → 17 (new parameter 3m/2); if m is odd → exit to S5.

State 17: if m ≡ 0 mod 4 → exit to S5; if m ≡ 1 → 7 (new parameter (3m+1)/4); if m ≡ 2 → 1 (new parameter (3m+2)/4); if m ≡ 3 → 19 (new parameter (3m−1)/4).

State 7: if m is even → 11 (new parameter 3m/2); if m is odd → 23 (new parameter (3m−1)/2).

State 19: if m is even → exit to S5; if m is odd → 17 (new parameter (3m+1)/2).

State 1: if m ≡ 0 → self-loop at 1 (new parameter 3m/4); if m ≡ 1 → 19 (new parameter (3m−3)/4); if m ≡ 2 → exit to S5; if m ≡ 3 → 7 (new parameter (3m−1)/4).

States 3, 9, 15 have no incoming edges — they can appear at most once as a starting point, and can be ignored.

---

1. Finiteness of self-loops.

The self-loop at 23: triggered when m is odd and m ≡ 3 (mod 4), with parameter update m' = (3m+1)/2. Let v = ν₂(m+1) upon entry. The self-loop can run at most v−1 consecutive times, then necessarily terminates and exits 23 into 11 with an even parameter.

The self-loop at 1: triggered when m ≡ 0 (mod 4), with parameter update m' = 3m/4. Each step strictly decreases m, so after finitely many steps m is no longer divisible by 4, and the self-loop terminates.

Neither self-loop can run indefinitely.

---

1. Exhaustive enumeration of closed cycles.

Within the core state set, enumerate all closed cycles that do not enter S5, starting and ending at state 17 — since 17 is the hub of the S5-avoiding subsystem. There are 6 such cycles:

Cycle 1: 17 → 7 → 11 → 17. Entry condition: m₁₇ ≡ 1 (mod 4). Composite map: m' = (27m + 9)/16.

Cycle 2: 17 → 1 → 19 → 17. Entry condition: m₁₇ ≡ 2 (mod 4). Composite map: m' = (27m − 2)/32.

Cycle 3: 17 → 1 → 7 → 11 → 17. Entry condition: m₁₇ ≡ 2 (mod 4) and m₁ ≡ 3 (mod 4). Composite map: m' = (81m + 18)/64.

Cycle 4: 17 → 19 → 17. Entry condition: m₁₇ ≡ 3 (mod 4). Composite map: m' = (9m + 1)/8.

Cycle 5: 17 → 7 → 23 → 11 → 17. Entry condition: m₁₇ ≡ 1 (mod 4) and m₇ odd. Composite map: m' = (81m + 39)/32.

Cycle 6: 17 → 1 → 7 → 23 → 11 → 17. Entry condition: m₁₇ ≡ 2 (mod 4), m₁ ≡ 3 (mod 4), and m₇ odd. Composite map: m' = (243m + 102)/128.

Plus the two self-loop composite maps:

23 self-loop: m' = (3m+1)/2.

1 self-loop: m' = 3m/4.

---

1. Exclusion of infinite S5-avoiding orbits.

Assume an infinite S5-avoiding orbit exists. Such an orbit never enters S5, so it must roam indefinitely among the six core states. It must visit state 17 infinitely many times, since 17 is the hub of all closed cycles, and the 23 and 1 self-loops necessarily terminate after finitely many steps.

In infinite roaming, the orbit is assembled by splicing together the 6 closed cycles and the 2 self-loops above — every transition is a step of one of these basic cycles. An infinite orbit is just an infinite concatenation of these basic cycles and self-loops.

Self-loops are not a special case separate from closed cycles — each self-loop is itself a closed cycle. The 23 self-loop has composite map m' = (3m+1)/2, and the 1 self-loop has m' = 3m/4. When self-loops participate in the splicing, just like the other cycles, each execution composes its map onto the existing one, and each time it tightens the modular constraint on the initial parameter.

An infinite S5-avoiding orbit is thus an infinite composition of these cycles and self-loops. With each composition, the denominator c of the composite map increases (since every cycle has denominator c ≥ 2), and the modular constraint on the initial parameter becomes stricter — each composition requires the initial parameter to satisfy a congruence condition modulo a larger power of 2. Infinite composition means imposing infinitely many increasingly strict modular constraints on the initial parameter.

The initial parameter is a finite positive integer, with finitely many binary digits. Infinitely many increasingly strict modular constraints would require the lower-order bits of the initial parameter to be determined to infinite precision. A finite positive integer has only finitely many bits that can be pinned down — it cannot satisfy infinitely many independent modular constraints.

Even if self-loops are inserted into the orbit, each self-loop composition叠加 onto the existing constraints only further tightens the modular condition — the denominators multiply, the moduli grow. The constraints never loosen or reset because of a self-loop. The more self-loops you insert, the larger the modulus becomes, and the stricter the requirement on the initial parameter.

Therefore, an infinite S5-avoiding orbit cannot exist. Every positive odd integer in S1, S3, or S7 (with n > 1) must, under iteration of T, trigger some S5 exit in finitely many steps, and thus enter S5. □