1RB0RB_0LC0RA_1LE1LD_0LE---_1LF0LC_1RA1LB

Label: H-1 (halting hunt). 740 list line 686. Class: Bell eats counter (our class claim; this machine got its own claims line on 2026-10-13).

Family: this is 347's table (1RB1RF_1RC0RA_1LD1RE_1LE0LE_0RA0LD_0RB---, ours, STUCK "cryptid-margin suspect"), relabeled and mirrored (347 A,B,C,D,E,F -> 686 C,E,F,A,B,D). 441 is the same table from another start. A 686 phase start

0^inf rev(W) (01)^M <C 0^inf        (C reads the last 1)

is 347's 0^inf A> (10)^M W 0^inf. So 347's rules, invariant G1 and margin analysis apply verbatim (347 notes.md, rounds 1-3).

Halting comes only from margin breaks. A break is k_align(W) > M-1, where k_align is the number of Incs until the counter is aligned.

Halting hunt: exact model (2026-10-13)

Result: no halt to phase 127,822,269 (M = 2,055,209,149; about 3.5e26 steps). No margin break.

• The closest approach is a new near-miss at phase 43,355,647: k_align/(M-1) = 0.9893 (M = 662,347,287, 7.06e6 Incs spare). Before that, the record was 0.9755 at phase 1572.
• Not cryptid: the model is exact and the arithmetic is regular (bijective base 3 on fixed widths, plus a fixed walk). What is open is a margin bound.

The model

Scripts are in scripts/.

fastmap.py is 347's validated fast phase map (deepen3_fast.phase) with one more exact acceleration, for the Incs before alignment: - Write the counter as P X. P is the longest prefix of wide aligned frames (d in 1..3, even width >= 4). X is the rest, the "head". - While some digit of P is below 3, an Inc changes only P, as bijective base 3 with fixed widths. This is 347's Inc rule (1300/1300), the same one deepen3_fast.add already applies to aligned counters. - So the Incs until P is all 3s are added arithmetically. - The single Inc that carries out of P into X runs at cell level (deepen2_orbit.bounce_ctr, bell reduced to 3 blocks). It is a Gap-Inc, a J-rule sub-phase, or a d3/T overflow. - X does not change during prefix Incs, so the result is Inc-for-Inc identical to while not aligned(c) and k < M-1: c = bounce_ctr(c). - The marker walk is still deepen2_orbit.crossing, at cell level.

Cost per phase is O(cell-level carries + crossing), independent of M:

Other scripts: - fastmap.c is a C port with the same semantics; binaries fastmap686 and fastmap686d are both builds of it. The long run used a build from before the --dump option was added, which gives identical P and C lines on 15,000 phases. - run686.py is the Python driver. - Model phase starts map to 686's real configurations through the mirror map above.

Validation

A shifted Inc index is not flagged, which is correct: the result does not depend on the bell position.

The run

• fastmap686 was run from phase 15,304 (M = 153,097, the old run's end) to phase 127,822,269 (M = 2,055,209,149). Output: work/c_long.txt.
• C lines: the full counter every 100,000 phases.
• P lines: ratio > 0.2 and every 1000th phase.
• X lines: ratio > 0.9.
• BREAK, HALT and ERR lines: none were written.
• Steps, estimated as the sum of 2M² per phase: 3.5e26.
• Ratio tail, phases 15,304..127,822,269: number of phases with k_align/(M-1) above each threshold.

Every phase above 0.5 on the whole orbit (q = floor(log3 M)):

Max ratio per window q (M in [3^q, 3^(q+1))):

What the margin looks like (new)

k_align is a sum of carry costs. - Each chain head needs two cell-level carries: a Gap-Inc merge (o2), then a J-rule sub-phase. - A carry with an aligned prefix of q frames costs r+1 Incs, where r is the prefix's distance to all-3s. That is 3^q - 1 when all digits are 1, the state chain resolution leaves. - Examples: - Phase 31,857: carries at prefix lengths 5, 5, 7, 8, 10, 10 and 11, giving k_align = 300,105. - Phase 1572: k = 12,879 = 3^8 + 2·(3^7 + 3^6 + 3^5).

Empirical bound. Over every phase, k_align/3^q <= 1.963 (q = floor(log3 M)). Unlogged phases have ratio <= 0.2, so k/3^q < 0.6 there. So the ratio is below 1.963·3^q/M <= 1.963. - The nearly full chains (k/3^q > 1.5) are only 10 phases so far, and all have M/3^q >= 1.71. - A break needs k/3^q > M/3^q: a nearly full chain while M is less than about 1.96·3^q.

How deep a break has to be to halt (new, scripts/forcebreak.py). - Method: take the 3,169 orbit phase starts with ratio > 0.2 from phases 15,304..1.5e7 (fastmap686d --dump 0.2 -> work/c_dump.txt). Force each bell down to M = f·k_align and run 3 exact phases.

• Breaks up to depth k/M = 1.43 never halt: 0 of 9,507 runs at f = 0.70, 0.75 and 0.95.
• From depth about 1.54 (f = 0.65) on, 3-30% halt, almost always in the next phase (3,489 of 3,511). The broken phase leaves a counter whose next walk halts.
• The 0.9893 phase itself does not halt under any forced bell, down to 1% of k_align (ratio 100): no halt in 12 phases at any of 13 depths (scripts/perturb.py -> work/perturb_43355647.txt).

A forced halt reproduced on 686 itself at scale (W5-5 style; work/forced_halt_*): 1. Start: orbit phase 10,562,630 (M = 151,485,246, k_align = 41,977,788), with its bell forced to 20,988,894 (f = 0.5). 2. The broken phase was checked directly: 17/17 components on 686 at full bell. 3. The model says the next phase (M = 20,988,895) halts at the carry after k = 4,865 Incs. 4. Running 686 from the configuration reproduce686.py builds just before that carry halts after 41,968,189 steps (D reads 1). 5. So the model's halts are real halts of the machine at M ~ 2e7, and the certification path (model -> configuration just before the halt -> tools/sim) works.

Consequence for the hunt. - A halt on the orbit needs a break of depth about 1.5 or more. That means k/3^q >= 1.5·M/3^q, so a nearly full chain (k/3^q up to 1.96) while M/3^q <= 1.3. - In 127,822,269 phases, nearly full chains appeared only at M/3^q >= 1.71. So the deepest "break" seen is 0.989, against the roughly 1.5 a halt needs. - The yield estimate is lower than the ranking's. Even a mild break (ratio 1-1.43) would not halt. The ranking's "mild break every 1e6-1e7 phases" did not happen either: 0 breaks in 127.8 million new phases.

Possible proof lead (not a result). Non-halting would follow from two lemmas: 1. k_align < 2·3^floor(log3 M) together with a coupling between chain depth and M/3^q that keeps the ratio below about 1.4. 2. Breaks of depth below 1.43 recover. This is supported by the forced tests: 0 of 9,507.

This is the margin lemma that 347's round 3 could not find, restated in log3 terms. It would cover 347, 441 and 686 together.

Outcome and what is left

• No halt to the horizon (phase 127,822,269, M = 2,055,209,149, about 3.5e26 steps). Every model step type was checked directly on 686 at full bell size up to M ≈ 1.2e9.
• Certification route if a halt ever appears: 1. The C map writes a HALT line with the phase start. 2. reproduce686.py builds 686's configuration just before the halting carry or crossing and runs tools/sim to the halt. 3. Certificate: RWLAcc62_BigUint solve_halt' with raised budgets, or a W5-5-style chunk replay.
• Resume: scripts/fastmap686 work/c_long.txt NPH OUT starts from the last C line. About 2e4 phases per second; M grows about 16 per phase.
• Files:
• scripts/{fastmap.py, fastmap.c, run686.py, direct686.py, dcheck686.c, compcheck686.py, reproduce686.py, forcebreak.py, perturb.py, startat.py}
• work/{orbit_ref.txt, c_ref.txt, c_ck10k.txt, orbit_long.txt, c_long.txt, c_347check.txt, direct_chain.txt, direct_points.txt, comp.txt, anchors_starts.txt, c_dump.txt, forcebreak.txt, forcebreak_fine.txt, forced_halt_starts.txt, forced_comp.txt, forced_halt_reproduce.txt, perturb_43355647.txt}