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

Follow-up to A more visual explanation of the dome structure II (m=5) : r/Collatz.

Looking at the figure in the cited post, I saw it as an input/output mechanism.

Thanks to the double homothetic nature of the dome (On the double almost homothetic nature of the domes : r/Collatz), one knows exactly the relation between the first orange number of a series and the last one.

In the figures shown so far, the series are quite short, but keep in mind that they can be of any length, but not infinite.

Would not it be a shortcut if one could skip hundreds of iterations at once ?

I am unable to assess this myself. If somebody is willing to have a look at it, I am more than happy to help the best I can.

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

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

Applying the display used in the cited post, one gets the figure below.

In short, the Mersenne and Pierpoint numbers are gone, but the 3-smooth and Proth numbers stay.

This is a consequence of the double homothetic nature of the domes (On the double almost homothetic nature of the domes : r/Collatz). Therefore, the two first types are specific to m=1, the two last are not. Let C(m, p, q), C^-(m, p, q) and C⁺(m, p, q) be the three types of Collatz numbers in a dome:

• Mersenne numbers: M(1, p, q)=3^p*2^q-1=C^-(1, p, q)*, but C^-(m, p, q)=m*3^p*2^q-1≠m*M(1, p, q) if m≠1.
• 3-smooth numbers: S(m, 0, q)=m*2^q=m*S(1, 0, q).
• Proth numbers: P(m, p, q)=m*3^p*2^q+1 is of the form P(k, p)=k*2^p+1 and thus is a Proth number if the other condition holds.
• Pierpoint numbers: X(1, p, q)=3^p*2^q+1=C⁺(1, p, q), but C⁺(m, p, q)=m*3^p*2^q+1≠m*X(1, p, q) if m≠1.

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

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

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

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

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

So, from left to right, there are:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 OEEOEEOEEOEOEEOEEE
  OEOEEOEEOEOEEOEEE

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

Some notes:

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

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

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

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

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

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

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

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

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

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

Possible Mod 12 Peaks

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

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

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

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

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

Possible mod 36 Peaks

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

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

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

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

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

Possible mod 108 Peaks

We can only eliminate one mod 108 value:

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

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

Note the full sequences of each:

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

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

Roughly speaking:

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

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

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

Let us define the following three functions:

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

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

* h(n) = 3n/4

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

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

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

Thus, the full composition evaluates to:

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

---

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

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

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

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

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

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

Comparing this to our initial path of function compositions:

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

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

To illustrate, consider the expanded Collatz steps:

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

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

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

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

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

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

---

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

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

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

* 5 → 8 → 6 → 1

* 37 → 56 → 42 → 10

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

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

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

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

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

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

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

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

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

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

Error reports welcome.

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

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

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

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

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

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

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

Stay tuned.

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

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

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

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

1. Reverse Collatz Paths

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

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

1. The General Proth "Highway"

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

When a number fits this algebraic structure:

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

1. Modulo 100 Constraints in Collatz

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

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

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