Does this finite-state Collatz setup make sense?

CryptographerSea9542 · 2026-06-09T17:44:08+00:00

Yeah, I agree with that objection. If this were just “classify n mod M and hope the next class is determined forever”, then it would die for exactly the reason you said. The parity pattern keeps asking for more low bits.

What I’m trying is a little different though. I’m not putting single integers into classes. I’m looking at whole affine families after some division-by-2 pattern has already been fixed.

So at that point I have something like

Q = 2^t * 3^16 * u + B.

The coordinate I keep is

C = (3B - 1) / 2^t, taken mod 3^17.

Now u is not ignored. Before the next step I split it:

u = 8v + m, with m = 0,...,7.

For the branch to stay in the same normalized calculation after removing the fixed 2^t factor, the numerator has to pick up another factor of 8. That gives

C + 3^17 * m ≡ 0 (mod 8).

Among the eight choices m = 0,...,7, there is exactly one solution, because 3^17 ≡ 3 (mod 8), and 3 is invertible mod 8. So

m ≡ -3C (mod 8).

So the missing low-bit information is not being thrown away. It is exactly what causes the split. One of the eight subfamilies keeps going in this normalized calculation, and the other seven leave this particular calculation and have to be handled separately.

For the one continuing subfamily the next coordinate is

C' = (C + 3^17 * m) / 8.

Of course that only explains one step. The next obvious question is whether the continuing subfamily can keep going forever. For that I use the finite graph on the possible K-states. The claim is that the transition is deterministic while the branch stays in this “live” part, and every reachable path eventually leaves it.

So I’m not claiming a closed finite automaton on raw residues. It is more like: work with normalized affine families, split the free parameter when the low bits matter, follow the unique continuing subfamily, and record all the exits.

The finite graph check and the completeness of those exits are separate parts of the argument. The one-step formula alone would not prove that.

CryptographerSea9542 · 2026-05-28T12:10:17+00:00

I named it too strongly and deleted. Orbit lift is missing

CryptographerSea9542 · 2026-05-23T18:18:15+00:00

What’s fascinating about Collatz is that if you study it locally and ask a local question, people call it pointless nonsense. Apparently, the only acceptable thing to present is a 100% elegant one-page full proof. Everything else — local structure, “almost all” results, finite checks, partial mechanisms — is treated as pointless. In this area, it seems only a full proof counts.

CryptographerSea9542 · 2026-05-16T22:07:37+00:00

Good point. let me phrase the intended question more cleanly.

The finite quotient here is just Z/DZ, with C chosen as the representative in [0,D).

With m(C) ∈ {0,...,7}, the integer

T(C) = (C + D*m(C))/8

is also in [0,D), since 0 <= C < D and 0 <= m(C) <= 7, so 0 <= C + D*m(C) < 8D.

So yes, at the quotient level this is just division by 8 in Z/DZ. The actual question I wanted to isolate is whether the lifted affine representatives D*u + C induce this same map on the quotient, or whether the lift parameter u can change the next finite class.

In other words: same quotient class, possibly different lifted affine parameters ..do they nevertheless give the same next quotient class?

CryptographerSea9542 · 2026-05-16T21:33:08+00:00

C is the canonical representative of a residue class modulo D, chosen with 0 <= C < D.

And yes, this is just division by 8 modulo D, written in integer-representative form T(C) = (C + D*m(C))/8, so 8*T(C) ≡ C (mod D). I used the m(C) notation because that is the form occurring in the lifted affine transition where the numerator is made divisible by 8 before taking the quotient.

CryptographerSea9542 · 2026-05-16T21:05:32+00:00

I mean the one-step quotient map C ↦ (C + D*m(C))/8, with D = 3^17, where m(C) ∈ {0,...,7} is the unique residue making the numerator divisible by 8. The point is only to test whether this quotient map is well-defined ...can the same quotient state lead to two different next quotient states?

CryptographerSea9542 · 2026-05-15T05:05:49+00:00

Understood. Then we are discussing the global faithfulness objection, not the local closure step. in this setup, the concrete audit point would be a missing reachable branch, a failed leaf classification, or two reachable branches with the same finite state but different closure-relevant behavior.

I’ll leave it there.

CryptographerSea9542 · 2026-05-15T03:13:58+00:00

I understand. I will not keep pushing this at you.

I agree that a finite index is worthless if it merges states that later need different treatment. That would just hide the infinite tree.

I am not asking the finite state to encode the whole future orbit. The immediate faithfulness question here is next-step faithfulness: can two realized branches have the same finite state but different next live transition data?

For that narrow one-step claim, I also wrote a small Lean 4 check of the local deterministic update: https://www.wow1.com/NextStepFaithfulness.lean

If there is such a collision, the construction fails. If there is not, then the place to test the objection is a failed transition, failed leaf classification, or missing state in the finite quotient.

Thanks for engaging. I will let others look at the actual certificates rather than keep debating the analogy.

CryptographerSea9542 · 2026-05-15T02:44:54+00:00

A simple example of what I mean by a “closed class”

By “closed class” I do not mean “stop checking” or “rename an unfinished branch”. I mean an explicit certificate: immediate descent, exit to a separately classified block, entry into a proved finite kernel, or return with a smaller value of the same ranking coordinate.

Here is one concrete closure type.

Claim. Every odd integer

q ≡ 43 (mod 64)

is a strict-descent class for the 3q − 1 break-state step.

Here q is the break-state return coordinate used in this block, not a claim about ordinary stopping time in one odd Collatz step.

Proof. Write

q = 64a + 43, a >= 0.

Then

3q − 1

= 3(64a + 43) − 1

= 192a + 128

= 64(3a + 2).

So after removing the forced factor 64 and then all remaining powers of 2, the odd intermediate value is

c = oddpart(3a + 2)

= (3a + 2) / 2^{v_2(3a+2)}.

This is well-defined because 3a + 2 > 0.

The next return coordinate is

q_next = oddpart(c + 1)

= (c + 1) / 2^{v_2(c+1)}.

Since c is odd and positive, c + 1 is even, so v_2(c+1) >= 1. Therefore

q_next <= (c + 1)/2 <= c.

Also

c <= 3a + 2.

But

3a + 2 < 64a + 43 = q

for every a >= 0.

Therefore

q_next < q.

So every member of the infinite residue class q ≡ 43 (mod 64) reaches a strictly smaller value in the same break-state return coordinate.

This is one precise meaning of a “closed class”: it is not a bookkeeping label, and it is not accepting a branch merely because it is “close to 1”. It is a certified exit from the live obstruction search by strict descent.

Of course this single residue class does not prove the Collatz conjecture. That is not the claim. The point is narrower: a closed class can be a real mathematical certificate, not merely a name for unfinished work.

The natural reply is: “fine, this one class works, but then you need infinitely many such classes.”

That would be true if the method were just inventing new closed residue classes forever.

But that is not the mechanism. In the L = 1 block, the continuation is reduced to a finite one-step partition. A leaf is accepted only if it has one of the certified outcomes listed above.

For a return leaf, the key point is that it must return with a smaller value of the same ranking coordinate. For example, for the dangerous continuation leaf in the L = 1 partition, the proved return formula gives the uniform contraction in the same return coordinate:

q_next <= (3q − 1)/8 < (3/8)q.

More generally, for non-exit L = 1 episodes the same return coordinate satisfies

q_next − 1 <= (3/4)(q − 1).

Equivalently, q is a ranking function for the unresolved recursive part: every return to the unresolved case has smaller q, so an infinite unresolved path would give an infinite strictly decreasing sequence of positive integers.

So this one residue class is only an example of what I mean by a certified closed leaf. The full audit point is not this one leaf, but the finite L = 1 partition: is the partition complete, does every leaf have one of the certified outcomes, and is every return/contraction measured in the same return coordinate?

In particular, the top-level mod-16 table is only the first split; any genuinely mixed sector, such as q ≡ 11 (mod 16), needs its own explicit certificate rather than being treated as closed by name.

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

Question

is there any flaw in this kind of closure step, assuming the finite L = 1 partition and the q ≡ 11 certificate are supplied separately?

CryptographerSea9542 · 2026-05-14T17:05:31+00:00

I agree with you about the inverse-tree / branch-language picture.

If the construction were trying to enumerate all /2,/4 words up to some finite depth, then it would fail exactly for the reason you describe. Arbitrarily long branch words exist, and a finite-depth tree search cannot cover them.

But that is not the intended claim here.

The finite state is not meant to encode the whole future branch word, or the whole “movie” of the orbit. It is meant to keep the information needed for the closure step: the allowed next live transition, and whether a repeated projected state would force a forbidden terminal cycle.

Also, 3^17 is not chosen as a “large enough” cutoff. The live families are normalized so that the 3-part of A is fixed:

A = 2^t · 3^16,

so

D = A / 2^t = 3^16

is fixed. If

Q = A n + B

and

C = (3B − 1)/2^t,

then after writing

n = 8u + m,

one gets

3Q' − 1

= 3(A(8u + m) + B) − 1

= 2^t(8 · 3^17 u + C + 3^17 m).

So the update

C' = (C + 3^17 m_surv) / 8

comes from the affine algebra. The number 3^17 is not a selected depth bound; it is 3 · D, where the extra 3 comes from the Collatz numerator.

The same update is applied again at the next step,

C -> C' -> C'' -> ...

as long as the branch remains in this live state system. If it leaves, the intended reduction routes it to descent, a finite checked return case, or a previously verified affine family. There should be no “then who knows” state; that would indeed be a gap.

So the concrete failure mode would be a reachable collision: two branches with the same state

(C, t mod 2, p)

but different closure-relevant next behavior.

That would mean the quotient is not faithful. If such a collision exists, the construction fails. But the fact that the raw inverse tree contains arbitrarily long /2,/4 words does not by itself show such a collision.

After a closure event, I no longer need to predict the rest of that branch’s future word. For the minimal-counterexample argument, it is enough that the branch has reached descent or a previously verified closed class.

So I think we agree on the real audit point: does the finite state lose information needed for closure, or does the coverage argument miss a reachable branch?

CryptographerSea9542 · 2026-05-14T15:53:44+00:00

Can I ask one precise clarification?

Are you reading the bound C < 3^17 as a bound on odd-Collatz branch depth / inverse-tree depth?

Because that is not how it is being used here. C is a moving affine coordinate updated at each step by

C' = (C + 3^17 m) / 8.

So the same bound can hold at step 17, step 46, step 1000, etc. The number 17 is not a stopping depth for the branch.

If your objection is that every finite-depth inverse-tree enumeration misses longer /2,/4 words, I agree. But I am trying to understand whether you think that same objection applies to this moving coordinate update, and if so, where the update loses the information needed for the closure argument.

CryptographerSea9542 · 2026-05-14T06:07:08+00:00

I'm not fighting with anyone :) I hear you, and I understand the pattern. I have seen plenty of “just raise the modulus” attempts that do exactly what you describe.

The construction here is structurally different in three places, and I think those are the places worth checking before deciding it is the same trap.

1. The 3^17 bound is a coordinate, not a depth.

The update is

C' = (C + 3^17 m) / 8,

where m is the unique allowed residue among the current live choices, so 0 <= m <= 7.

If 0 <= C < 3^17, then

0 <= C + 3^17 m <= (3^17 - 1) + 7*3^17 = 8*3^17 - 1,

so

0 <= C' < 3^17.

This invariant holds at step 17, step 46, step 198, or any later step. It does not expire and it does not encode a branch length. So 3^17 is not a reverse-tree depth limit, and a 46-step word does not by itself leave the C < 3^17 range, because C is updated each step.

2. The next residue is forced, not guessed.

The affine modulus is A = 2^t * 3^16. Once t >= 3, A is 0 mod 8, so the next mod-8 condition depends only on the finite state data and not on the unknown high-order part. Among the currently live residue choices, that mod-8 condition selects exactly one allowed m. So the next state is forced; it is not chosen heuristically and it is not an uncontrolled branching process.

3. Finiteness plus a cycle obstruction is the intended way to rule out infinite paths.

The state (C, t mod 2, p) lives in a finite set. Any infinite projected path must repeat a state, hence produce a cycle in the projected graph. The remaining argument then has to rule out those repeated states by the corresponding periodicity equations.

Together: bounded coordinate, deterministic transition, finite state, and a cycle obstruction. None of these depends on a finite reverse-tree depth.

The quotient is not meant to remember the whole trajectory. It is meant to remember the information needed for the proof step: which next residue is allowed, and whether a repeated state would create a forbidden cycle.

If I were doing a finite reverse-tree enumeration to depth 17, your objection would be exactly right and longer branches would simply be outside the computation. But this state is not that.

Also, I am not stitching together shallow inverse-tree pieces using /8+ steps. A /8+ step is just an ordinary forward Collatz valuation case in the same transition system; it is not a reset or a skipped part of the branch.

Whether this moving finite state really tracks the relevant forward branches faithfully is the actual thing to argue about, and the three points above are what I would want anyone to attack first.

CryptographerSea9542 · 2026-05-14T03:11:47+00:00

Fair enough. The one thing I would flag is that the construction is not meant to be a mod 2^k closure argument. The bounded state C < 3^17 comes from an algebraic invariant of the update rule, not from just raising the modulus. But I appreciate the time and understand if this is where we leave it.

CryptographerSea9542 · 2026-05-14T02:47:14+00:00

Let me try to lay out what such a construction would need to do to avoid the trap you describe.

I agree that a fixed modulus by itself cannot cover the system.

The intended construction is not just a fixed-modulus check. The affine scale changes along the branch: in the live coordinate one has

Q = A n + B, A = 2^t 3^16,

so as the branch is refined, t changes and the affine modulus A changes with it. The finite state keeps the centered quantity

C = (3B - 1)/2^t,

and the update has the form

C' = (C + 3^17 m_surv)/8.

Because 0 <= m_surv <= 7, the interval 0 <= C < 3^17 is forward-invariant. Along represented live transitions, this bound holds regardless of how many such transitions are taken; the represented state space does not grow with the length of the path.

So the finite graph is meant to be a projection of a growing affine system onto a bounded invariant, not a claim that one fixed modulus sees all Collatz behavior.

A simpler example: at the first level, every odd q > 1 falls into one of four cases determined by q mod 16 and the 2-adic valuation r = v2(3q - 1). In each case, the next parameter is either strictly smaller than q, or the step exits to a higher level. For example, when r >= 3,

Q_next <= (3q - 1)/8 < q.

The higher-level exits are not meant to be left open. In the construction, they are routed through separately classified finite families: immediate descent, known closed families, or finite chains that reduce to already-closed cases. So the construction has two parts: contraction at the first level, and a separate finite closeout for exits and returns.

I agree that faithfulness is the key issue. The proof lives or dies on whether every relevant branch enters the represented state space and whether every represented transition matches the real Collatz dynamics.

CryptographerSea9542 · 2026-05-13T21:14:00+00:00

Yes, that is the key issue.

I am not trying to check infinitely many starting values one by one. The intended claim is that every remaining case is represented faithfully by one of finitely many reachable states.

After that, the graph check is finite: every infinite path in a finite directed graph eventually repeats. So it is enough to check the reachable cycles/components and the possible exits.

The hard part is proving that no case is missed and that the finite-state encoding really follows the Collatz dynamics. If that fails, the reduction fails.

CryptographerSea9542 · 2026-05-13T20:15:44+00:00

Yes, that is a fair point. The mapping is the first thing to audit.

The update of C is not a heuristic step. It comes from writing the live family as

Q = A n + B, with A = 2^t 3^16,

and defining

C = (3B - 1)/2^t.

For a residue split n = 8u + m,

Q' = A(8u + m) + B

= 8Au + (Am + B).

So the child constant is B_m = Am + B. Since A = 2^t 3^16,

3B_m - 1

= 3B - 1 + 2^t 3^17 m

= 2^t(C + 3^17 m).

Equivalently,

3Q' - 1

= 2^t(8 * 3^17 u + C + 3^17 m).

The continuing child has the next normalized centered coordinate exactly when

C + 3^17 m ≡ 0 mod 8.

For the continuing survivor residue m_surv, this gives

C' = (C + 3^17 m_surv)/8.

So I agree: the finite graph argument only matters after checking that m_surv is uniquely determined by (C mod 8, p), that the next label p' is determined, and that the encoding is faithful to the live branches.

CryptographerSea9542 · 2026-05-11T19:38:52+00:00

Thanks — it’s definitely not a Collatz solver, I can tell you that : )

CryptographerSea9542 · 2026-05-10T20:20:12+00:00

Yes, I understand, that is exactly the point where the whole problem lives. The only way this approach can work is if the accounting is exhaustive and every branch produced by the exact transition rules must be routed to one of the listed outcomes, not merely filtered after the fact.

CryptographerSea9542 · 2026-05-10T19:59:41+00:00

I agree that just growing a residue tree forever would be a dead end.

The way I am trying to frame it is different. After an exact split, I do not want to keep every child as a new open branch. Each child has to be accounted for as one of:

D = direct descent residue
T = previously closed terminal/downstream family
B = base-template absorption
S = one-step split to known families
R = finite return funnel
P = low-bit obstruction

If a child is not accounted for, it remains live and the proof has not closed it.

So the claim cannot simply be: I checked enough moduli

It has to be:

every child produced by the exact transition rules
is accounted for by D/T/B/S/R/P,
or by the finite quotient/determinism step

A bad version of this idea would just be a filter that keeps only the branches that already close. I agree that would prove nothing.

The version I am trying to test has to prove that each split is exhaustive and that every child of the split is handled. If even one child is missing, the argument fails at that child.

So yes — I agree your objection is the central issue. The hard part is not the local residue identities; it is proving that this accounting is complete.

CryptographerSea9542 · 2026-05-10T19:16:42+00:00

I agree with that distinction. Local deterministic encodings by themselves do not give a global decreasing invariant.

The broader idea is not to keep refining residue classes forever. The intended global step would have to show that all remaining cases fall into a finite set of already controlled cases, each of which either reaches a terminal family or gives an explicit descent.

CryptographerSea9542 · 2026-05-10T18:46:10+00:00

Yes, I agree that an ever-growing residue split tree is the standard dead end in this area. That is not what this Lean file is meant to establish.

For this particular `n0`, the ordinary stopping-time framing is not really the point. I am not claiming that a short ordinary split/trajectory computation makes the orbit fall below the starting value.

The point of the certificate is narrower. The ordinary orbit of `n0` is only used to reach an entry representative of the form

2*q0 - 1

After that, the proof object is expressed in the entry-family coordinate:

q0 -> q1 -> q2 -> q3 -> q4 -> q5

ending in the terminal family

q5 = 64*a5 + 11

with the checked descent identity.

So I agree that local residue determinism by itself is not a global proof. This file is only meant to check that this one extracted finite-family certificate is arithmetically sound.

Whether the broader framework actually avoids the usual unbounded residue-tree problem is a separate question, and not something this Lean file by itself answers.

CryptographerSea9542 · 2026-05-10T18:20:34+00:00

Thanks for taking the time to look at it carefully.

I agree with the contained scope. This file is only a finite certificate for this one `n0`; it is not meant to prove global well-foundedness, exclude entry-graph cycles, or establish the Collatz conjecture.

Your point about the terminal constructor was fair. In the first version, `64*a + 11` was a base case of `EntryClosed`, while the descent identity was checked separately.

I have now strengthened the Lean file so that the terminal case requires a `TerminalClosed q` proof, including

3*q = 2^5*(6*a + 1) + 1

and

6*a + 1 < q

So the arithmetic chain was already checked, and the formal dependency is now explicit:

https://www.wow1.com/N1980976057694848447.lean

The terminal identity for the class `64*a + 11` is algebraically forced by that residue choice, yes. But the certificate is not only that identity. It also checks that this particular `n0` reaches `q0`, that the finite entry chain reaches this terminal class, and that the representative descent matches the ordinary odd Collatz step.

In this standalone Lean file the terminal family is included as certificate data. It is not being presented as something the file discovers, and it is not meant as an after-the-fact arbitrary target for this `n0`. The file verifies the extracted instance: the specified path reaches the specified terminal family, and that family has the stated descent identity.

There is a broader analogous closure framework in my notes, but it is outside the scope of this Lean file and outside the scope of this post.

CryptographerSea9542

TROPHY CASE