1RB0LC_1RC0RC_1LD0RB_1LA0LE_1LD1LF_1LD---

Status: STUCK (2026-10-10), informal_proof stage, after the skeptic review. The fatal gap (no invariant, proof.md §5) stands. The major gap (no rule for 45 events) is fixed by the general rule G (proof.md §3.5–3.6). See ## Outcome. Class guess (agent / Dennis): parent #11's binary counter plus a new "partial overflow" at u = 1 digits. Skelet 1-like Class 2 on the sheet. / _ Spreadsheet notes / Discord thread: line 395 of data/holdouts/2026-10-07_778.txt (holdouts.py contains: exit 0, byte-exact). Results tab: class only (Skelet 1-like Class 2), with no status, notes, sources or Done By. Classifications tab: listed under that class. It is on no Level/category/link/strikethrough tab and in no data/discord/*.txt. Not claimed. reports/targeting.md lists it as #32 ("follow-on to #11, different trajectory"). Viewer: https://bbchallenge.org/1RB0LC_1RC0RC_1LD0RB_1LA0LE_1LD1LF_1LD--- Parent: machines/1RB0LE_1RC0RC_1LD0RB_1LA0LE_1LD1LF_1LD--- (KILLED_NONHALT). The two tables differ only in A1: the twin has 0LC, the parent 0LE.

Observation

• Over 1e10 steps there is no halt. The span is −81..271,700: the right edge reaches 89,969 at 1e9 (parent 77,513). The left edge barely moves (−69 at 1e9, −81 at 1e10), while the parent's moves 3 cells per overflow.
• The twin runs the parent's trajectory exactly up to step 283, K((0,0,3),(1,1,2); 4, 1). The two first differ in state at step 28, but C0 = E0 = 1LD, so the paths stay together. Head and tape first differ at step 322.
• Images:
• img/bounce_twin_K283.png and img/bounce_parent_K283.png: the same start config img/bounce_from_K283.txt, 330 rows each. The twin turns at the u = 1 digit; the parent sweeps on to d_1.
• img/records_3e5.png.
• Data: scripts/kdump.c, a C simulator that prints every K-config as right-aligned 2-cell tokens. Output to 1e10 (67,857 K-configs) is in the session scratchpad, not kept. Rebuild it with gcc -O2 -o kdump scripts/kdump.c && ./kdump "$TM" 1e10.

Candidate rules (the delta)

Window-lemma level (scripts/twin.py, checks L and T): - 17 of the parent's 20 window lemmas hold verbatim. - T3, T5 and T12 write the same tape but exit in C instead of E. Because C0 = E0 = 1LD, they act as the parent's lemmas whenever the next cell read is 0. - The only reachable divergence is T5 followed by a 1. That is the parent's Lb on a bit-1 digit with u = 1 whose left neighbour cell is 1: a previous digit's 01, or the leading 10 01. (T3 with a = 0 would also diverge, but M only ever meets a ≥ 1.) - New lemmas: - T5b: 110 <D → 010 B>, 5 steps (D0 A1 C1 B0 C1). - Lt (bounce): 1 10 (01)^v <E → 01 (10)^(v−1) 000 B>, 8v+1 steps (T4, S3(v−1), T5b, S6(v−1), T10).

The leftward sweep turns at that digit, eating its 10, and moves one cell of the left text (1 becomes 01).

Macro level. Each rule below is checked by scripts/twin.py on random configs (300 each, exact tape and step count):

M  parent M, unchanged, when every trailing bit-1 digit the carry crosses has u >= 2 (and a >= 1).
   Left text arbitrary (misaligned junk included).
O  parent O, unchanged, when all bits are 1, the wall is the plain 10 01 and every digit has u >= 2.
P  NEW (partial overflow). The sweep meets its first bit-1 digit with u = 1 at index p, and the left text L ends in 1:
     L · (1,1,v_p) (u_i,1,v_i)_{i>p} (10)^a 000 (10)^b B>
   → L[:-1] 01 (10)^(v_p-1) 00 (01)^u_{p+1} [(10)^(v_i-1) 00 (01)^u_{i+1}]_{p<i<m} (10)^v_m (01)^a (10)^(b+3) 000 10 B>
     (p = m:  L[:-1] 01 (10)^v_m (01)^a (10)^(b+3) 000 10 B>)
   steps 77 - 4k + 8a + 20b + 4·Σ_{i>=p} u_i + 8·Σ_{i>=p} v_i      (k = m-p+1)

P is O applied to the suffix d_p..d_m, with the far-left turn T9 (and Lb/Ro on d_p) replaced by Lt. It is 12 steps cheaper than that O. P can come from an M-type carry (a bit-0 digit left of p; 15 of the 43 P events to 1e10) or from an O-type all-ones sweep (28). Its result is not in the parent's family: the left text is shifted by one cell. Read from the right, d_{p−1} = (u',β',w) becomes (w−1,1,1) plus misaligned text ...0, and runs of 11 and bare 00 digits ((u,0,0)) appear.

Every transition to 1e10 (scripts/classify.py), with the exact text and step count of the next K-config:

The 54 "other" transitions realign the left text, which a later sweep re-pairs. Some act like an M (a+1, b+2), others like an O/P (b → 1). python3 -B scripts/classify.py <kdump file> --examples 3 prints them as digit lists.

Why the parent's invariant cannot carry over: - Class A ends its cycle at an all-ones state with top (1,1,v). In the twin, that overflow is always a P, at d_1 or at a lower u = 1 digit, never the parent's O. - Along the parent's own orbit (2·10^5 macro steps from step 483), class-A overflows are the only steps that would bounce: 39 of 39. All 199,923 M steps and all 38 class-C overflows have only u ≥ 2 digits in the sweep, because class C's u_j = ubar_j ≥ 2^j ≥ 2. So they run unchanged. - In the twin itself, M-type P's do occur (15 of 43 to 1e10). They come from the structures that earlier P's leave behind. - The run leaves the parent family at the first P. That is an M-type P at step 283→428, before the parent's INV start (step 483).

Checkpoint A (Dennis)

Informal proof

2026-10-10, informal_proof stage: proof.md written, incomplete (STUCK at the invariant, proof.md §5). Done and checked by check_proof.py (10/10 PASS): - rule table facts and an exact token-machine reformulation (proof.md §1); - 23 atomic window lemmas: the parent's 20 with T3/T5/T12 exiting in C, plus S4c, T2c and the bounce T5b; the composite Lt (§2); - M and O with their narrower twin domains; P derived as a chain and checked link by link (§3); - the exact initial segment to step 609 (§4); - census to 1e9: M 22,349 / P 35 / O 6 / other 45, 0 mismatches; - every step of every transition (all to 1e7, all non-M to 1e9) lies in the 23 windows, and F always reads 0 in them. The three "other" types are new compositions, not new local behaviour; - arithmetic cannot be dropped: K((1,0,2);2,1) halts at step 2535, and 807 of 5,472 small canonical configs halt; - a lemma plan against the parent's .v (§7).

Still open: closed forms for the 3 "other" types, and a family plus invariant closed under M/O/P/other (the parent's A/B/C classes do not survive P, and P moves the left text by one cell).

2026-10-10, skeptic revision: proof.md revised (Review log at its end), check_proof.py 12/12 PASS. - General rule G (proof.md §3.5). Phases 1–2, then Lb/Lb1 over the maximal swept suffix, then one of five turns on the left text X, then Rb or Ro and the M or O right end. The turns: - Lf: 00(01)^v; - T3S2: 1100 → 01 C>11; - Jc: 00(01)^v00 → 10(01)^v C>11; - T2: 000 → 100 B>; - Lt: the bounce.

G is derived from 24 windows (new: T3j 0100<E → <D1011; new composite Lb1 for a u = 1 digit with a 0 on its left). It predicts every transition exactly, 22,435/22,435 to 1e9 and 67,856/67,856 to 1e10. M = Lf; O = T2 after Lb1 on the wall (T9 = Lb1 + T2c + Ro); P = Lt. The 45 old "other" events are T2 31, T3S2 8, Jc 2, Lf 4. - Sweep case analysis (proof.md §3.6). The left-moving part of the table is a 5-state automaton, and the ending of X falls in exactly one class: - covered: Lf, T2 (k ≥ 1), T3S2, Jc; - halting: H1 (11), H2 (111(01)^v); - uncovered: U0 (T2 with k = 0), U1 (011(01)^v), U2 (10(01)^w0100), U3 (11(01)^w0100).

Non-halting is now exactly "no reachable K-config is in H or U". The halting example K((1,0,2);2,1) ends in H1 at step 2384. - Scratch for this stage (not kept): t32/ in the session scratchpad. It holds gen.py (G), the dumps to 1e9 and 1e10, and turn/seq tracers.

Old text: no proof.md. A delta proof needs the parent's family, rules and invariant to survive with local changes. Here the family changes (misaligned left text, (u,0,0) digits, a 10 (01)^v wall), the overflow rule changes (P), and 3 event types are still without rules.

Formalization log

Outcome

• 2026-10-10, delta stage: OPEN, not a delta of #11.
• Carried over:
• all of the parent's shift and turn lemmas (3 of them with exit state C, which is harmless before a 0);
• M (99.8% of transitions to 1e10);
• O when all u ≥ 2.
• New:
• the bounce Lt and the partial overflow P (validated, exact);
• 3 realignment event types (54 of 67,856 transitions to 1e10), not yet characterized.
• Next, as a standalone proof: 1. Pin down the realignment events. These are sweeps that reach a (u,0,0) junction, the misaligned text, or a 10 (01)^v wall. Get window lemmas for each. 2. Choose a configuration family that is closed under M/O/P/realign. Probably: a left part in a small set of shapes, then right-aligned digits. 3. Find a new invariant. The parent's A/B/C classes do not survive P.

Not assessed for cryptid-likeness. The left-text shapes look irregular, but no pseudo-random arithmetic has been seen. Budget for this stage is used. - 2026-10-10, informal_proof stage: STUCK at the invariant. proof.md is complete except §5 (family + invariant) and the closed forms of the 3 "other" transition types. New: the token machine, 23-window coverage of the whole run, the P chain, init to 609, and evidence that arithmetic is needed. check_proof.py 10/10 PASS (64 s). Next: the route in proof.md §5. - 2026-10-10, skeptic revision (informal_proof): STUCK, fatal gap stands. - Fixed: the major gap (closed forms for all events, rule G) and the 3 minor gaps (§6 coverage wording, §3.3 "moves left" wording, M/O chains written out, T9's twin trace). - Open: a family closed under G with no member in H1/H2/U0–U3. The left text is a multi-level counter (R4's fossil walls), so this needs a recursive invariant. - check_proof.py 12/12 PASS (79 s default; 52 s --seed 2026 --n 1000 --quick). - Priority call shared with R4. - Files: - scripts/twin.py: checks L, T, M, O, P, X; ALL PASS at --n 300. - scripts/classify.py. - scripts/kdump.c. - img/*.

Decision (2026-10-10)

Parked by Dennis 2026-10-10 together with R4 (same table, 1RB0RE_1LC0RD_1LD0LD_1RA0LC_1RA1RF_1RA---): multi-level counter invariant open. (R4 decision queue: park_both.)

Reopened (2026-10-12)

Dennis: close out Skelet 1-like Class 2. The class's 8 kills (#3's and #11's tables) are the templates to learn from.

Class 2 close-out, stage 1 (2026-10-12)

Track R4 + #32 (one table), stage 1 of at most 3. Outcome: progress, not closed. Halting turns out to be decided by residues mod 5 of "fuel" values at the exhaustion events of a multi-level counter. A regime-I state whose fuel N is cut to 2 or 7 halts, from every real state tried, while the other residues pass. R4's real orbit has its top in regime I with N = 27 ≡ 2 (mod 5) (section 5), so R4 may actually halt, at a step count far beyond direct simulation; a deeper level with fuel 1083 has to run out first. Scratch (c2/ in the session scratchpad) is not kept; the scripts are kept as scripts/c2s1_* (list at the end).

1. The delta against #11, exact. - In the token machine (proof.md §1.3) the one changed transition (A1: 0LE → 0LC) changes exactly one entry: A entering an X token. Parent: X → a, continue left in F. Twin: X → o, turn right (C'). In digit terms this is the bounce of Lt: a bit-1 digit with u = 1 whose left cell is 1. - So #11's INV cannot be extended level by level. Every class-A overflow of #11 has the top (1,1,v) right after the wall's last 1, so in the twin it is always a P. INV counts R_j, ubar, vbar against one wall and one full overflow; the twin's overflows are partial (P re-pairs only the suffix below the bounce digit, T2 only the suffix below a junction), and a P followed by a T2 swaps u and v twice, so fuel is not refilled. - Check (c2s1_kickinv.py): #11's INV on the re-paired lower counter after every O-type kick to 1e10 (87 kicks: 43 Lt, 44 T2; one Lt has an empty suffix) holds in 0 of 86*. After the 42 Lt kicks Common holds but no class does (the parities of v + beta are mixed); after the 44 T2 kicks S < 0 or T < 0. - Drops happen inside the lower counter: to 1e10 there are 36 carries into a bit-0 digit with v = 1 and 42 sweeps of a v = 1 digit, some of them 7–10 digits below the top. A lower-counter invariant would need #11's B/C-style drop analysis as well.

2. Two regimes. Every kick below is a G transition (proof.md §3.5): c2s1_events.py recomputes each extracted kick and finds 0 mismatches in tape, a, b and step count (the plain carries are covered by check_proof.py check 8). The one exception is the U2 event of the N = 0 cut (section 3), where G makes no prediction. The cycle maps are read off the runs; they are not derived symbolically. W = 10 01; digits as in proof.md. - Regime I, at a full overflow: I(N, M) = K(W (0,0,N) (0,0,M) D; a, 1). - One big cycle is 16 kicks, Lt T2 Lt T3S2 T2 Lt T2 Lt T2 Lt T2 Lt Jc T2 Lt T2, plus 6–8 carries into the top text. - Map: N → N − 5, M → M + 1; the digit d places below M: u − 12·2^(d−1), v + 2^d (exact for d = 1..6 between the last two real cycles). N + 5M is conserved. - Real run: I(136, 360) at step 276,440,631; I(131, 361) at 943,552,925; I(126, 362) at 7,098,925,607. The second cycle took about 9 times as long as the first (6.7e8 and 6.2e9 steps). - The top pieces after each kick (left-to-right digit parse; · = a v the top does not depend on). Checked against all 16 kicks of the cycle from step 943,552,925 (N = 131, M = 361):

| # | kick | top after the kick |
|---|---|---|
| 0 | | `W (0,0,N) (0,0,M)`; a carry then flips `(0,0,M)` to `(1,1,M−1)` |
| 1 | Lt | `W (0,0,N−1) (0,0,0) 1 (M−2,0,·)` |
| 2 | T2 | `W (1,1,N−1) (0,0,M−1)`; a carry then gives `(1,1,M−2)` |
| 3 | Lt | `W (1,1,N−2) (0,0,0) 1 (M−3,0,·)` |
| 4 | T3S2 | `(1,0,0) 1 (N−2,0,0) (M−2,0,·)` (W is now `10001`) |
| 5 | T2 | `(1,0,0) 1 (N−3,1,0) 1 (1,1,M−1)` |
| 6 | Lt | `(1,0,0) 1 (N−3,1,1) (M−2,0,·)`; a carry into `10001` then gives `1 (N−2,0,0) (M−1,0,·)` |
| 7 | T2 | `1 (N−3,1,0) 1 (1,1,M)` |
| 8 | Lt | `1 (N−3,1,1) (M−1,0,·)`; a carry into `1` then gives `(N−2,0,0) (M,0,·)` |
| 9 | T2 | `(N−3,1,0) 1 (1,1,M+1)` |
| 10 | Lt | `(N−3,1,1) (M,0,·)` |
| 11 | T2 (blank) | `(1,1,N−3) (0,0,M+1)`; a carry then gives `(1,1,M)` |
| 12 | Lt | `(1,1,N−4) (0,0,0) 1 (M−1,0,·)` |
| 13 | Jc | `W (N−4,0,0) (M,0,·)` |
| 14 | T2 | `W (N−5,1,0) 1 (1,1,M+1)` |
| 15 | Lt | `W (N−5,1,1) (M,0,·)` |
| 16 | T2 (Lb1 on W) | `W (0,0,N−5) (0,0,M+1)` |

• With N = 2, kick 2 already leaves W (1,1,1), the double wall of the halting mechanism (section 3).
• Regime II: II(P, f, Q) = K(W (0,0,P) (f,0,Q) D; a, 1).
• One big cycle is 4 kicks: Lt on (1,1,P−1); T2 on the blank, after carries have absorbed the wall into 10001 and then 1; Lb1 + T2 on the new wall (1,1,P+3); T2 full overflow.
• Map: P + 3, f − 5, Q + 2; the digit d places below the top (d = 1 is the f digit): u − 5·2^(d−1), v + 2^d. Exact for d = 1..7 over 2 consecutive cycles of the N = 1 cut run. 5P + 3f is conserved.
• II(P, 0, Q) is I(P, Q): the f = 0 cut runs the 16-kick cycle.

3. Fuel exhaustion (fuel-cut runs). A cut takes a real full-overflow K-config and changes only one fuel value (c2s1_cut.py), then runs the machine from it (c2s1_kfrom.c).

Regime II, cut at II(373, f, 179), the state the N = 1 cut reaches at step 6.2e9; 2e10 steps each, no halt:

Regime I, cut at I(N, 361), the K-config after step 943,552,925; 2e10–3e10 steps:

N = 2 halts from every regime-I state tried: I(2, 361) from step 943,552,925 (halt at 1,024,792,782 steps), I(2, 360) from step 276,440,631 (202,227,190), I(2, 362) from step 7,098,925,607 (15,416,326,862), and I(2, 180) from the f = 2 cut's regime I (17,558,927,962). The mechanism is the same each time: - the first two kicks leave a double wall, W (1,1,1) = 10 01 10 01; - the next Lt leaves 10 01 1 in front of a digit with u ≥ 2; - the next overflow sweep crosses that digit and reaches 10011, class H1 (E reads 1, then F reads 1).

4. What this means for #32. - Non-halting needs at least: no regime-I exhaustion with N ≡ 2 (mod 5), ever. Deeper exhaustions have their own residue-dependent outcomes (the tables above). - N at a regime-I entry is P_end + δ(f mod 5) with 5·P_end = 5P + 3f − 3·(f mod 5) and δ = 0, −1, +1 for f ≡ 0, 2, 4. P and f come from deeper digits, which are consumed at 5·2^(d−1) or 12·2^(d−1) per cycle and merged when they run out (as P + Q + 3, or by #11-style drops). - So the residues that decide halting follow a piecewise-affine map with mod-5 case splits over an unbounded hierarchy. No invariant that controls them was found. If none exists, this is cryptid-like. - #32's real orbit so far: before about 2e8 steps the top is a deeper stack than either regime (e.g. W (0,0,10) (0,0,10) (0,0,122) at step 1,326,678, three fuels at once), whose exhaustions merge it down ((133,1,7) (358,1,61) at 1.7e8). Then II(133, 5, 358) at step 184,166,036 gives the first clean regime I, I(136, 360), with N ≡ 1 (mod 5); N = 1 passes when it runs out (cut table). Its next structural events are the lower digits' exhaustions, not N's: u_3 = 24 (−12 per cycle) and u_4 = 50 (−24), while N = 126 lasts about 25 more cycles. A direct run to 5e11 (c2s1_kdumpb1.c, b = 1 dump) does not halt: I(121, 363) at step 170,047,445,118 (N − 5 and M + 1 again; the third digit's u 24 → 12 as the map says). At step 4.9e11 that u is 7, so it runs out near the end of the current cycle, beyond 5e11. - G's case analysis is incomplete as a hazard list: the N = 0 cut passes a U2 text without halting.

5. R4's orbit (same table, D start). Dump of R4's orbit in #32's orientation (c2s1_kdumpq.c / c2s1_kdumpb1.c with start D), 2e10 steps, no halt: - II(30, 7, 29) at step 51,277, II(33, 2, 31) at 115,809 (one regime-II cycle: P + 3, f − 5, Q + 2), then I(32, 32) at 475,465. That last step is exactly the f ≡ 2 rule of the table above (II(P, 2, Q) gives I(P − 1, Q + 1)). - One regime-I cycle later: I(27, 33) at step 14,968,044,039, so N − 5 and M + 1 as the map says. The cycle ended with a long stretch (1e8 to 1.4e10) in which the top digits had little fuel left ((27,1,1) (32,0,6) (57,0,6) (59,0,22) (103,0,30)). - 27 ≡ 2 (mod 5). If the top's regime-I map keeps holding for 5 more cycles, N reaches 2 and, going by the four N = 2 cuts, R4 halts there. (Cutting R4's own state to N = 2 does not show this within 4e10 steps: the top does not move at all, because R4 is active deeper down; see the next item.) - But the top is not where R4 is active. Its full digit list at that step is W (0,0,27) (0,0,33) (4,0,59) (2,0,63) (14,0,111) (14,0,77) (0,0,1083) (240,0,477) ... (20 pieces). The (0,0,1083) seven digits down is a second, deep level, and the kicks after 1.5e10 happen there (steps 17,443,368,848 and 19,117,748,741: (14,0,76) (0,0,0) 1 and (15,1,76) (0,0,1082)). Carries reach the top only through the four digits in between, which count the deep level's kicks, so the top regime I(27, 33) moves very slowly while the deep level spends its fuel (1083). - So R4's fate depends on the residues at the deep level's exhaustions as well as on the top's N ≡ 2. The top's small lower fuels (u = 4, 2, 14 against a use of 12, 24, 48 per regime-I cycle) will also run out inside its next cycle. The one top cycle observed (N 32 → 27) kept the map. A run of R4 to 3e11 (b = 1 dump) does not halt. The top stays I(27, 33) the whole time, and every kick from 1.5e10 to 2.74e11 is at the deep level, whose fuel goes 1083 → 1076, one unit per two kicks, with the kicks 2e9 to 5e10 steps apart and growing. - The step count of such a halt is not known. Cycles grow by large factors (the first took about 1.5e10 steps), so 5 more cycles are far beyond direct simulation.

Validated. Every listed kick is an exact G transition. The cycle maps hold on 2 real regime-I cycles of #32 and 1 of R4, on 1 real regime-II cycle of R4, and on 1–5 regime-II cycles in each of three cut runs. The exhaustion tables come from 12 cut runs. N = 2 halts from 4 different regime-I states. N = 7 halts too (from the step-276,440,631 state: one full 16-kick cycle, then the N = 2 path, halt after 1,692,042,796 steps), so the halting residue carries through the cycle map: N ≡ 2 (mod 5) at a cycle start.

Open. A symbolic derivation of the cycle maps; what lower-digit exhaustions inside regime I do to N; the residues of the true orbits at future exhaustions; any invariant; whether R4 halts.

Next (stage 2): an exact event-driven abstract simulator. The text is kept as alternating runs, plain-M stretches are jumped in closed form between non-plain events, and G is applied exactly at the top. Validate it against the direct runs (#32 to 5e11, R4 to 3e11), then project R4's orbit to its N exhaustion and #32's through many exhaustions. Possible results: - R4 reaches N = 2 and halts: a halting proof becomes possible (the abstract run would give the step count); - a lower exhaustion moves R4 off the residue, or a residue invariant shows up: a non-halting proof route; - irregular residues with no invariant: flag both as cryptid candidates.

Scripts (scripts/): c2s1_kfrom.c (K-config dumper from a given start; @file for long texts), c2s1_kdumpb1.c (dumps only b = 1 K-configs), c2s1_kdumpq.c (start state as argument; D gives R4's orbit mirrored), c2s1_gm.py / c2s1_dparse.py (G from check_proof.py, digit parse), c2s1_events.py / c2s1_topev.py / c2s1_deepev.py (event extraction), c2s1_s0.py (full-overflow states), c2s1_pinv.py / c2s1_kickinv.py (#11's INV on the kicks), c2s1_cut.py (fuel cuts).

Class 2 close-out, stage 2 (2026-10-12)

Track R4 + #32 (one table), stage 2 of at most 3. Outcome: progress, not closed. The exact fast simulator now exists and is validated. With it both orbits run to 8.5e37 steps without halting. R4's top has not moved since step 6.2e15. Projecting R4 to its N exhaustion needs more than 128-bit step counts and a level-by-level acceleration.

1. The simulator (scripts/c2s2_tsim.c). - The tape is two stacks of runs of 2-cell tokens (proof.md §1.3), with the pairing fixed from the start cell. The token table is computed from the cell table. - Three exact accelerations: - chain: a whole run passed in one state; - zig-zag: a 3-visit cycle that turns twice and writes the hole token back, applied to a whole run. These are the S-type sweeps at the other token parity; without them a sweep costs 3 visits per token; - carry jump: at a K-config, the right-hand block of digits with u, v ≥ 1 is advanced n times by rule M in closed form. n is the largest count for which every step is a plain M: the stop digit has v ≥ 2, the swept digits have u ≥ 2 and v ≥ 2, and the carry stays inside the block. It works at both K parities (R lines are the odd parity). - K-configs at both parities are detected exactly. The output format is kdump's; c2s2_tk.py converts R lines and parses digits, and c2s2_dv.py prints the parity-free defect view (constant runs Z_k / O_k and the alternating gaps between them).

Validation.

Speed: 5e11 in 0.1 s without jumps (the cell-level run took minutes); 1e17 in 3 ms with jumps; the 2^126 guard (8.5e37 steps) in 8–11 s.

2. The orbits. - #32: no halt to 8.5e37 steps. - Regime I continued with N − 5, M + 1 per cycle: I(121, 363) at 1.70e11 and I(116, 364) at 1.14e12. - Then the third digit ran out (stage 1 predicted this), and the top left regime I. Its defect view became 1 Z3 0 O2 224 Z2 0 O2 710 Z3 316 O2 ... at step 5.8e14. - The first 12 defects of the top have not changed since 5.8e14. - R4: no halt to 8.5e37 steps. - I(27, 33) at 1.50e10. - The carry into M at 2.5e13 flips (0,0,33) to (1,1,32). - Kick 1 of the regime-I cycle (Lt) at 6.24e15 leaves W (0,0,26) (0,0,0) 1 (31,0,·); in the defect view, 1 Z2 1 Z3 51 Z2 0 O2 .... - The first 60 defects of the top have not changed from 3.5e25 to 8.5e37. - So the next top kick (kick 2 of 16 in this cycle) comes after 8.5e37 steps. Each top kick waits for a full exhaustion of the levels below, and those levels are refilled with values that grow like 2^k (a = 2.9e17 at 8e37). - Cuts on R4's own state ((01)^N replaced in I(27, 33) at step 14,968,044,039; N = 0, 1, 2, 3, 7, 12): - none halts by 8.5e37; - all six reach the guard within a few hundred steps of each other, so the top never moved in any of them.

3. The mod-5 halting rule, tested further (c2s2_sweep.sh, carry jump on, cut to 2^126 steps):

• The 943M base is one regime-I cycle after the 276M base. Its N = 17 halt is the 276M base's N = 22 halt: the step counts differ by exactly the 6.67e8 steps between the two bases.
• So N ≡ 2 (mod 5) halts through four full cycles (N = 22 from the 276M base).
• The fifth cycle does not finish by 8.5e37: N = 27 from the 276M base (= N = 22 from the 943M base). Halting times grow by ×8 to ×20 per cycle, then jump from 1.4e14 to more than 8.5e37. A lower digit runs out in that cycle and opens a deep slow level.

What is validated. The simulator: exact, with the six checks above. The two orbits to 8.5e37, the cut table and the halting step counts are exact runs of the machine, not projections of an abstract model.

Open. - Whether R4's top ever reaches N = 2. That is 5 more cycles of 16 top kicks, and the next top kick alone lies beyond 8.5e37 steps. - Whether the mod-5 rule survives the deep-level exhaustions. The first test of that (N = 27 from the 276M base) is beyond 8.5e37. - A residue log of every exhaustion at every level. Not done yet: the orbits now run far enough to produce many lower-level exhaustions, but no logger reads them. - No invariant.

Next (stage 3, the last of this track). 1. Remove the 128-bit limits: big-integer step count (or log10 steps plus an exact residue) and 128-bit run counts. 2. Add one more acceleration level: apply a whole regime-II/kick cycle at a deep level in closed form, checked against the carry-jump run where both reach. 3. Log (level, N or f, P) at every exhaustion in both orbits and in the N = 27 cut, then look for a residue invariant.

The stop rule applies. If the residues at deep exhaustions show no invariant, flag both CRYPTID_CANDIDATE (the halting question is the mod-5 residue of a fuel produced by an unbounded piecewise-affine hierarchy) and write the decision. If R4 reaches N = 2 in the abstract run, that is the case for a halting proof.

Scripts (scripts/): c2s2_tsim.c (simulator; NOJUMP=1 turns the carry jump off), c2s2_tk.py (line parser, R-line re-pairing, digit parse), c2s2_dv.py (defect view), c2s2_cmp.py (compare with kdump output), c2s2_selftest.py (random differential test against a direct simulator), c2s2_mkcut.py + c2s2_sweep.sh (N cuts). Run outputs are in the session scratchpad (s2/) and are not kept; each regenerates in seconds.

Class 2 close-out, stage 3 (2026-10-12)

Track R4 + #32 (one table), stage 3 of 3, the last. Outcome: cryptid. Both machines are flagged CRYPTID_CANDIDATE, confidence med. No invariant was found, and there is a concrete reason none of the simple kind exists. Halting is decided by modular conditions on fuel values, one per level of the hierarchy, and the outcome already depends irregularly on the level just below the top. Both real orbits are frozen at the top to 1e80 steps. The decision for Dennis is in R4's decision.json (recommended: stop).

1. Simulator with wide integers (scripts/c2s3_tsim.c). This is c2s2_tsim.c with the 128-bit limits removed: - steps are unsigned _BitInt(2048) (guard 2^2000); - run counts are unsigned _BitInt(512) (guard 2^500); - the carry jump is computed in 2048-bit arithmetic and capped at 2^JCAP plain carries (env JCAP, default 450).

Stage 2 had a hard-wired cap of 2^40. Above about 1e35 almost every jump hit that cap, which made the run slow. Needs gcc ≥ 14 (gcc -O2 -std=gnu2x).

• Speed on #32's orbit: 1e60 in 0.13 s, 1e68 in 0.25 s, 1e80 in 2.5 s.
• 1e100 is not reached in 100 s, because the number of non-plain events explodes after about 1e80 (zig-zag passes: 77k to 1e68, 671k to 1e80).
• The level-2 acceleration was not built. Deep levels are not copies of the top regimes: R4's deep wall loses 1 fuel per 2 kicks, while the top loses 5 per 16. So each deep level would first need its own derived cycle map.

The base state of the cuts is the b = 1 K-config at step 276,564,068: I(136, 360), with first lower digit (48,0,169). Stages 1 and 2 named it by its event step, 276,440,631. scripts/c2s3_mkbase.py extracts it from a dump.

2. The real orbits, to 1e80 steps. - #32: no halt to 1.0e80. The first 40 defects of the left text (scripts/c2s3_top.py) are unchanged from 5.8e14 to 1e80. - R4 (D start): no halt to 1.0e80. The first 40 defects are unchanged from 4.8e17 to 1e80; the first 8 have been fixed since kick 1 of the current top cycle at 6.24e15. - So in both orbits the top waits behind deep levels whose next event lies beyond 1e80. R4's top is mid-cycle at W (0,0,26) ..., and that cycle started at N = 27 ≡ 2 (mod 5).

3. N cuts from I(N, 360), N = 0..44, to 1e80 (scripts/c2s2_mkcut.py, scripts/c2s3_runcut.sh): - exactly N = 2, 7, 12, 17, 22 halt; - N = 0, 1, 3–6, 8–11, 13–16, 18–21 do not halt by 1e80; - for every N ≥ 23 the END step (at 1e80) is linear in N, 188 steps more per unit of N. So the runs differ only in the cost of sweeping the top's (01)^N, and the top never moved in any of them.

The reason for the freeze is that the first lower digit (48,0,169) loses 12 per regime-I cycle. It therefore runs out in the 5th cycle (48 = 4·12). N = 22 needs 4 cycles before its halting path; N = 27 needs 5.

4. Lower-digit exhaustion changes the outcome irregularly. This is the new result. Each cut changes both N and u1, the u of the first lower digit, which is 48 in the base (scripts/c2s3_mkcut2.py). Every run goes to 1e80 with a 40 s limit, and none hit the time limit.

• If u1 is large enough that the digit never runs out (u1 ≥ 25 for N = 12, u1 ≥ 37 for N = 17), the run halts at the unperturbed step: 2.2e10 for N = 12, 4.5e11 for N = 17.
• Otherwise the halting times scatter between 6.8e9 and 2.4e14 steps.
• If u1 runs out in the first cycle, u1 ≡ 1 (mod 3) tends to halt (4, 7, 10 for both N = 12 and N = 17). There are exceptions: u1 = 1 halts for N = 12 but not for N = 17, and so does u1 = 11. In later cycles the pattern breaks up (N = 12 halts at 13–17, N = 17 only at 13 and 16).
• With N ≢ 2 (mod 5), no u1 tested gives a halt (N = 11, 13: 0 of 50). So in this sample a lower exhaustion only ever cancels a halt; it never creates one.

5. Verdict. - At the top, halting is a residue condition: a regime-I exhaustion with N ≡ 2 (mod 5). - Whether that condition is met depends on the next digit's residue when that digit runs out first (roughly mod 3, with exceptions), and those exceptions come from deeper digits. - Every one of these values comes from the piecewise-affine maps of stages 1–2: - per cycle, the top changes by (−5, +1) in regime I and by (+3, −5, +2) in regime II; - digit d loses 12·2^(d−1) or 5·2^(d−1) of its u per cycle and gains 2^d in v; - exits split on residues mod 5, and merges add (P + Q + 3). - This is mixed 2-adic / 5-adic arithmetic over an unbounded hierarchy. An invariant would have to control residues at every level at once. No finite family of residue classes was found, and the u1 table is not periodic in any simple modulus. - So halting is decided by pseudo-random-looking arithmetic. Under the cryptid protocol (PLAN.md rule 6) both machines are flagged and proof work stops. - Heuristic, not evidence: if each top-level regime-I exhaustion is a fresh draw with roughly a 1/5 chance of halting (less after lower cancellations), and the top keeps cycling, the random model leans to an astronomically late halt, not to non-halting. This differs from Antihydra-type cryptids. R4's current top cycle already has the halting residue.

Validated. - The simulator (all three checks above). - All halt and no-halt claims to 1e80 are exact runs of the machine, not projections.

Open. - Exact cycle maps for the deep levels. - Whether R4's or #32's top ever reaches its next exhaustion, and with which residue. - No invariant. - The rules in Rocq: only rule G and the token machine are written up and checked, in proof.md and check_proof.py. Nothing for this reduction exists in Rocq.

Scripts (scripts/). - c2s3_tsim.c: the simulator. JCAP sets the jump cap; NOJUMP=1 turns jumps off. - c2s3_mkbase.py: a K-config from a dump as a cell string. - c2s3_mkcut2.py: cut both N and u1. - c2s3_runcut.sh: run one cut. - c2s3_top.py: the top's defect view over time. - c2s3_sweep.py: locates the turn of a K-config's sweep on run-length text (proof.md §3.6 automaton).

Run outputs are in the session scratchpad (s3/) and are not kept. Each regenerates in seconds, or in under 40 s per cut.

Class 2 close-out, stage 2 (2026-10-12), re-run

The workflow issued stage 2 of this track a second time, with only stage 1 in its history. Stages 2 and 3 had already run today (the two sections above). The track ended at stage 3 with both machines flagged CRYPTID_CANDIDATE, and the priority call in R4's decision.json is still unanswered (tools/decisions.py --lint: ok). Under the cryptid protocol (PLAN.md rule 6) and with that call open, this re-run did no new proof work. It did two things: it checked that the kept scripts reproduce the earlier results, and it ran one new probe of the mechanism behind the flag. Outcome: cryptid, unchanged; confidence med. No new decision.json.

1. Reproduction from the kept scripts. Fresh builds (gcc 15.2) of scripts/c2s2_tsim.c and scripts/c2s3_tsim.c:

2. New probe: the second lower digit decides too.

The base's first digits below the top are

W (0,0,136) (0,0,360) (48,0,169) (98,0,818) (7,0,1797) (271,0,847) ...

so u1 = 48 (it loses 12 per regime-I cycle) and u2 = 98 (it loses 24). Stage 3 cut N and u1. Here N, u1 and u2 are cut together (scripts/c2s2r_mkcut3.py, the same pattern as c2s3_mkcut2.py), and every run goes to 1e80 steps or to its halt.

N = 12 (the unperturbed run halts after 2.22e10 steps, in the third cycle). Entries are halting step counts; - means no halt by 1e80:

N = 11 and N = 13 (residues 1 and 3), u1 = 0, 1, 2, 3, 4, 7, 10 and u2 = 5, 13, 23: no halt in any of the 42 runs by 1e80.

What the tables show: - The outcome is not a function of (N, u1). For u1 = 1, 4, 7, 10 the halt is fixed while u2 ≥ 40: the same step for every such u2. Once u2 runs out before the halting path ends, the halt moves (to as early as 2.4e9 or as late as 6.5e12 steps), and in 3 of these 16 cells it disappears. - For u1 = 11, which runs out late in the first cycle, the halting step depends on u2 even for u2 = 47..98, there is no halt for u2 = 13..40, and there is a halt again at u2 = 5. So the dependence on u2 is not monotone. - For u1 = 0, 2, 3, no u2 tested brings the halt back. - With N ≢ 2 (mod 5) no lower exhaustion created a halt (0 of 42 here, 0 of 50 in stage 3). In every sample so far a lower exhaustion only moves or cancels a halt of the N ≡ 2 residue.

3. The obstruction, stated precisely. Non-halting needs a family of configurations, closed under rule G, with no member in H1, H2 or U0–U3 (proof.md §3.6, §5). Every probe so far says that membership in such a family would have to be decided by the following data: - Halting at the top happens at a regime-I exhaustion with N ≡ 2 (mod 5). This is exact on N = 0..44 from one base. - Whether that exhaustion is reached depends on which lower digit runs out first, and on its residue at that moment (stage 3: u1, roughly mod 3 with exceptions). - Whether the halt survives that exhaustion depends in turn on the digit below it, once that digit runs out first (section 2 above: u2), and not monotonically. - The per-cycle maps that produce these values are affine with 2-power rates (u_d − 12·2^(d−1) or − 5·2^(d−1), v_d + 2^d), with mod-5 exits and P + Q + 3 merges (stages 1–2).

So a closed family would have to fix a residue condition at every level of an unbounded hierarchy of floor-divisions by different moduli. No finite set of residue classes is visible, and the same picture now holds one level deeper than in stage 3. This is the cryptid flag of stage 3, reinforced, not a new route.

Validated: every number in sections 1 and 2 comes from an exact run of the machine with the kept simulator. Open: as at the end of stage 3: no invariant, R4's fate unknown (its top is frozen behind deep levels to 1e80), and the rules exist in proof.md / check_proof.py but not in Rocq.

Scripts: scripts/c2s2r_mkcut3.py (new), with c2s3_runcut.sh and c2s3_tsim.c. The base comes from a 3e8 dump (NOJUMP=1 c2s3_tsim TM 3e8 A all) through c2s3_mkbase.py. Grid outputs are in the session scratchpad (s2r/), not kept; each cut regenerates in under 40 s.