{
 "round": 2,
 "confidence": "med",
 "recommend": "more_observation",
 "mechanism": "Binary counter in swept-token form (filler 2=100; a digit is a token 1 0^k, k>=4, whose bit cell is index k-3) next to a unary marker. Each round does one increment and one marker step. A carry that leaves the left boundary prepends a 3-token, so the left end runs a 4-state prefix cycle (1 3 -> 3 5 -> 3 1 3 -> 3 4 5 -> ... -> 3 2.3 1 3 -> 5 2 5); that is round-level OP/OQ. When the marker reaches the LSB: EAT0 drops a 0-LSB, and EAT1 increments the rest and turns the LSB into a 4-digit walker. The walker soaks up carries and moves one filler left every 2 rounds. Merging into a bit-0 digit (7-digit LSB, then filler plus carry) lets it pass through. Merging into a bit-1 digit leaves a stale '1'. The next carry that reaches a stale '1' starts a multi-bounce cascade (10 -> 00 on the left sweep). The cascade wipes a run of digits to fillers and spawns a new walker: these are the counter resets. Arithmetic only chooses which local case fires. A 4-gram token language has 0 halts under closure fuzzing.",
 "closed_gaps": [
  "Counter representation: round start RS(S,P,b,g,m) = 0^inf S P b <E (110)^(g+1) 00 (110)^m 0^inf, with S in swept tokens (digit = token with k>=4 zeros, bit cell at index k-3).",
  "INC0: RS(S,P,0,g+1,m) -> RS(S,P,1,g,m+1) in 8g+16 steps, any LSB prefix (80/80).",
  "CARRY5: RS(S 5 Prod(2^hj (1 3)) 2^h0, 1, 1, g+1, m) -> RS(S (1 3) Prod(2^hj 5) 2^h0, 1, 0, g, m+1), any gaps hj>=1 (80/80).",
  "EAT0 (LSB bit 0 meets marker): RS(S D 2^h, 1, 0, 0, m) -> RS(S, 1, c, h, m+2) in 3h+14 steps, D a 5-digit with bit c (80/80).",
  "EAT1 (LSB bit 1 meets marker): RS(S 5 2^h, 1, 1, 0, m) -> NM(S (1 3) 2^h, 0, 0, m+2) in 8h+29 steps; marker absorbed, LSB becomes a 4-digit (80/80).",
  "BIRTH: NM(S,P,0,n+2) -> RS(S,P,1,n,1) (INC0 + R4) (60/60).",
  "WALK4: RS(S 2^(h+1), 0, 1, g+1, m) -> RS(S 2^h, 0, 0, g+1, m+1); a 4-digit LSB with a carry moves one filler left (60/60).",
  "Generic carry transducer (2 skip; k>=4 set; 2.3 walks left; 3 borrows: (a,j>=2)3 -> (a,j-1)4, '1 3' -> 5, '2.1 3' -> 6) explains the record-level 4/6/7 tokens. On the blank-tape run it predicts every carry it covers exactly.",
  "Coverage from blank to 1e9: 98.88% of 150,891 round transitions predicted exactly, 0 mismatches.",
  "Token alphabet appears finite: 10 interior tokens {1,2,3,4,5,6,7,2.1,2.3,2.5}, LSB prefixes {0,1,2,3,4}, 74 bigrams; no new bigram from 1e9 to 1e10 (671,489 round starts).",
  "Origin of 0^2 inside W: a stale marker created when the B-sweep crosses a lone swept '1' token (10 -> 00).",
  "Halting can only happen via A> 0 1 0 (a dense 1-token) or B reading a 1 that has 1 on its left and 0 on its right.",
  "Round 2: left-end overflow at round level. Boundary rule: a carry out of index 0 prepends a 3-token, and a leading 3 borrows from 0^inf. LEFTCYCLE RS(L Y 2^h0,1,1,g+1,m) -> RS(L' Y' 2^h0,1,0,g,m+1), L->L' in {1 3->3 5, 3 1 3->3 4 5, 3 4 1 3->3 2.3 5, 3 2.3 1 3->5 2 5}: 80/80; 3,004 blank-run overflows predicted exactly to 1e10.",
  "Round 2: general EAT1 (EAT1_c). RS(S D 2^h,1,1,0,m) -> NM(inc(S D) 2^h,0,0,m+2), where inc is the carry transducer and may run through bit-1 digits and into the left end: 80/80; 109 blank-run matches.",
  "Round 2: walker regime. MERGE5 RS(X 2^h 5,0,1,g+1,m)->RS(X 2^h,3,0,g+1,m+1) 60/60; MERGE13 RS(X 2^h 1 3,0,1,g+1,m)->RS(X 2^h 1,1,0,g+1,m+1) 60/60 (creates the stale 1); LSB7 RS(X 5 Y 2^h,3,1,g+1,m)->RS(X (1 3) Y' 2^h 2,0,0,g,m+1) 60/60; LSB7_INC0 40/40.",
  "Round 2: predictor v2 vs. the machine on 600 random words of the 4-gram language: 386/386 predicted transitions exact, 0 halts.",
  "Round 2: blank-tape coverage to 1e10: 99.898% of 671,488 round transitions exact, 0 mismatches. From step 320,000: 99.904%, and every uncovered transition (644) is a stale-1 cascade.",
  "Round 2: stale-marker regime located. The stale '1' token comes only from MERGE13 (249 to 1e10). A carry reaching it erases 10->00 on the left sweep (B1->0LD, D0->0LB) and starts a cascade. Cascades are the counter resets (the counter falls back to left end + LSB, e.g. '7 2^30 1' at 1.8e9). 3 shapes: stale before the LSB 246, before an interior bit-1 digit 241, 6-digit '2 3' borrow 159.",
  "Round 2: invariant candidate L4 = words whose 4-grams (filler runs abstracted f1/f2/F, LSB and marker state included) lie in K. Closure fuzz to a fixed point, twice. Uniform sampling from the 1e9 4-grams: 645 -> 760, new per iteration 88,17,3,0,7,0, 0 halts in 1,800 samples x 20 rounds. Weighted sampling from the union with the 1e10 run (768): 768 -> 806, new per iteration 15,21,2,0,0,0, 0 halts in 1,500 samples x 30 rounds. Every late addition is in the tiny-counter corner."
 ],
 "remaining_gaps": [
  "Stale-1 cascade has no rules (3 shapes, 644 blank-run transitions after 3.2e5). The results are not a plain +1, e.g. '3 5 2 1 3 2 1 3 2 5 2^3 1 1|b1' -> '3 1 3 2 5 2 1 3 2 2.3 2^4 1|b0'. Deriving them needs the multi-bounce micro-dynamics after 10->00.",
  "Eat variants that the 4-gram closure reaches but the blank run hits only before 2e5: g=0 with a 4-digit or 7-digit LSB (P=0/3), eats with h=0, counter-empty words, NM with b=1.",
  "L4 (806 4-grams) is closed only under random fuzzing: two fixed points, with the last 3 weighted iterations adding nothing. It needs an exhaustive bounded check (length >= 12 per rocq-notes) or a regular refinement whose closure is proved.",
  "No proof-grade non-halting argument yet. The candidate: L4 (or a refinement) is closed under the round map and excludes both halt patterns (A> 0 1 0, 11 D> 0), plus an init segment to about 3.2e5 steps by direct simulation.",
  "Untried route: a busycoq CTL certificate (CTL.v: RWL_mod with block length 3 and threshold >= 3, or NG with n of about 12-16). Search the parameters natively first, never inside Coq."
 ],
 "evidence": [
  "scripts/deepen2_validation.json: targeted 380/380 (LEFTCYCLE 80, EAT1_c 80, MERGE5 60, MERGE13 60, LSB7 60, LSB7_INC0 40); random 4-gram-language words 386/386 predicted exact, 0 halts in 600.",
  "scripts/deepen2_coverage_1e10.txt and _from320k.txt: blank tape to 1e10 steps; INC0 335,298, CARRY 328,605, CARRY_ovf 3,004, CARRY_WALK4 3,154, BIRTH 252, EAT0 240, EAT1 142, EAT1_c 109; 0 mismatches.",
  "scripts/deepen2_stale_1e10.txt: classification of uncovered transitions (stale-1 cascades vs early restarts).",
  "scripts/deepen2_kgrams4.json: the 806 4-grams (fixed point). Closure fuzz (deepen2_closure_fuzz.py / deepen2_kiter.sh): 0 halts in 3,300 samples (about 81,000 rounds) over both chains.",
  "Round 1 evidence still holds (440/440 round-1 rules; 0 halts in 1,500 realistic shapes; OP/OQ 240/240)."
 ],
 "rules": {
  "notation": "swept token 1^a 0^k written k (a=1) or a.k; RS(S,P,b,g,m)=0^inf S P b <E (110)^(g+1) 00 (110)^m 0^inf; NM(S,P,b,n)=0^inf S P b <E (110)^n 0^inf; P=1 (5-digit LSB) or 0 (4-digit LSB)",
  "INC0": "RS(S,P,0,g+1,m) -> RS(S,P,1,g,m+1) [8g+16]",
  "CARRY5": "RS(S 5 Prod(2^hj (1 3)) 2^h0,1,1,g+1,m) -> RS(S (1 3) Prod(2^hj 5) 2^h0,1,0,g,m+1)",
  "EAT0": "RS(S D_c 2^h,1,0,0,m) -> RS(S,1,c,h,m+2) [3h+14], D_0=5, D_1=1 3",
  "EAT1": "RS(S 5 2^h,1,1,0,m) -> NM(S (1 3) 2^h,0,0,m+2) [8h+29]",
  "BIRTH": "NM(S,P,0,n+2) -> RS(S,P,1,n,1)",
  "WALK4": "RS(S 2^(h+1),0,1,g+1,m) -> RS(S 2^h,0,0,g+1,m+1)",
  "boundary": "carry out of token index 0 prepends (1,3)='3'; a leading '3' with a carry borrows from 0^inf and becomes '4' (the carry then leaves the boundary)",
  "LEFTCYCLE": "RS(L Y 2^h0,1,1,g+1,m) -> RS(L' Y' 2^h0,1,0,g,m+1); L->L': '1 3'->'3 5', '3 1 3'->'3 4 5', '3 4 1 3'->'3 2.3 5', '3 2.3 1 3'->'5 2 5'",
  "EAT1_c": "RS(S D 2^h,1,1,0,m) -> NM(inc(S D) 2^h,0,0,m+2)",
  "MERGE5": "RS(X 2^h 5,0,1,g+1,m) -> RS(X 2^h,3,0,g+1,m+1)",
  "MERGE13": "RS(X 2^h 1 3,0,1,g+1,m) -> RS(X 2^h 1,1,0,g+1,m+1)",
  "LSB7": "RS(X 5 Y 2^h,3,1,g+1,m) -> RS(X (1 3) Y' 2^h 2,0,0,g,m+1)",
  "LSB7_INC0": "RS(X,3,0,g+1,m) -> RS(X,3,1,g,m+1)",
  "STALE_CASCADE": "OPEN: a carry reaching a stale '1' (from MERGE13); 3 shapes, no rule yet"
 },
 "files": [
  "scripts/deepen_rules.py",
  "scripts/deepen_validation.json",
  "scripts/deepen_coverage.py",
  "scripts/deepen_coverage_1e9.json",
  "scripts/deepen_token_bigrams_1e10.json",
  "scripts/deepen_closure_fuzz.py",
  "scripts/deepen2_predict.py",
  "scripts/deepen2_rules.py",
  "scripts/deepen2_validation.json",
  "scripts/deepen2_dump.py",
  "scripts/deepen2_coverage.py",
  "scripts/deepen2_coverage_1e10.txt",
  "scripts/deepen2_coverage_1e10_from320k.txt",
  "scripts/deepen2_stale_classify.py",
  "scripts/deepen2_stale_1e10.txt",
  "scripts/deepen2_closure_fuzz.py",
  "scripts/deepen2_kiter.sh",
  "scripts/deepen2_kgrams4.json",
  "scripts/deepen_coverage_1e10.json"
 ],
 "updated": "2026-10-10",
 "rounds": [
  {
   "round": 3,
   "stage": "funded closure_ctl (2026-10-10)",
   "confidence": "med",
   "recommend": "more_observation",
   "result": "L4 (806 4-grams) is refuted: exhaustively, words of at most 14 symbols reach 324 halts and 248,016 escapes. The least closed k-gram language over the blank run contains halting words for k = 4, 5, 6, 8 and 10. No CTL certificate: 118 native runs of the extracted busycoq CTL62 decider, none true.",
   "closed_gaps": [
    "rsim (C batch round simulator) reproduces 15,759/15,759 consecutive blank-tape round starts to 3e7 exactly (tokens, b, g, m, steps). A halting word re-checked with tmsim halts at step 197.",
    "Exhaustive one-round closure of L4, every word of at most 14 symbols: 67,601 words and 1,000,548 concretizations. 752,208 successors stay in L4, 248,016 escape and 324 halt.",
    "The round-2 predictor is exact on all 759,169 covered concretizations (0 mismatches). But 110,054 of these (14.5%) leave L4, so L4 is not closed even under the validated rules.",
    "All 324 halts are unruled CARRY_stop, i.e. a carry meeting a stale 1 (86 words). 285 have a stale 1 right before a bit-1 LSB, in contexts the blank run never shows; 228 of these have a 6-digit '2 3' left of a 3-filler run. The other 39 have two walkers ('4 4') and LSB 2.",
    "Words of at most 10 symbols: 3,546 words, 43,340 concretizations, 9,463 escapes (366 new 4-grams), 9 halts. The smallest is '1 3 2 3 2^3 1 1 <E (110)^2 00 110', which halts at step 197 (card Fig 5). Random long words (20-40 symbols): 4,000 words, 12,034 concretizations, 4,113 escapes, 14 halts.",
    "k-gram closure iteration seeded by the blank run to 1e9 (150,891 round starts) halts for k=4 (L<=12) at iteration 1, k=5 (<=14) at it 1, k=6 (<=14) at it 1, k=8 (<=16) at it 3 with 8,251 8-grams, and k=10 (<=18) at it 5 with 21,009 10-grams. No bounded token window up to 10 gives a halt-free invariant under this abstraction.",
    "Special units (walker, stale 1, 6/7-digit pieces, odd LSB prefix). The blank run after 3.2e5, to 1e9, shows 16 signatures with at most 2 units, and the 2-unit ones are left-end cases. All 324 halting concretizations have signatures never seen in the run (2-4 units). The missing ingredient is a global at-most-one-transient constraint.",
    "busycoq CTL62 decide_nonhalt extracted to OCaml (ctlx). Known certificates come out true (NG 9 48 on nonhalt321's machine; CPS_LRU 12 on CTLv2 nonhalt1). For this machine, 118 runs: plain NG n=10-20 (11), RWL_mod with block length 3 (28: 27 false, 1 out of memory at 5.3 GB), NG with cell history (24), NG with state history (36), CPS_LRU with block length 3-15 (19). Zero true."
   ],
   "remaining_gaps": [
    "A structural (non-local) invariant: a small DFA over special units (at most one transient away from the left end, the left-end cycle, the cascade's transients), to be checked with the rsim exhaustive closure (at most 14 symbols plus random long words).",
    "Stale-1 cascade rules, restricted to the contexts the run actually shows (the 3 deepen-2 shapes).",
    "Eat variants and counter-empty words in the tiny-counter corner (the k=10 iteration reaches the halting '3 2.1|b0 g0').",
    "CTL remains a low-odds background option: params_C.txt (RWL_mod at block lengths 1-12, NG with LRU history) was not run."
   ],
   "files": [
    "scripts/closure/README.txt",
    "scripts/closure/rsim.c",
    "scripts/closure/rs_common.py",
    "scripts/closure/selftest_rsim.py",
    "scripts/closure/closure_check.py",
    "scripts/closure/classify_L4.py",
    "scripts/closure/halt_shapes.py",
    "scripts/closure/kclosure.py",
    "scripts/closure/special.py",
    "scripts/closure/summary.json",
    "scripts/closure/cc_L10.json",
    "scripts/closure/cls_L4_L14.json",
    "scripts/closure/halts_L4_L14.json",
    "scripts/closure/cc_rand_L20_40.json",
    "scripts/closure/kc4_L12.json",
    "scripts/closure/kc5_L14.json",
    "scripts/closure/kc6_L14.json",
    "scripts/closure/kc8_L16.json",
    "scripts/closure/kc10_L18.json",
    "scripts/ctl_extract/README.txt",
    "scripts/ctl_extract/Ext.v",
    "scripts/ctl_extract/main.ml",
    "scripts/ctl_extract/sweep.py",
    "scripts/ctl_extract/params_A.txt",
    "scripts/ctl_extract/params_B.txt",
    "scripts/ctl_extract/params_C.txt",
    "scripts/ctl_extract/sweep_A.jsonl",
    "scripts/ctl_extract/sweep_B.jsonl",
    "scripts/ctl_extract/runs/",
    "img/closure_halt_L4word.png"
   ],
   "updated": "2026-10-10"
  },
  {
   "round": 4,
   "stage": "funded struct_invariant (2026-10-10)",
   "confidence": "med",
   "recommend": "more_observation",
   "result": "The structural invariant closes with 0 halts once eats are restricted to normal words. H = LE . pre . X . post holds at most one transient cluster X from a list of 37. Checks: 1,214,968 sampled successors plus an exhaustive small-size pass of 1,983,816 successors. All 670,604 blank-run round starts from 3.2e5 to 1e10 lie inside it, and every closure-stage halting example lies outside it. Missing: a quantitative flush lemma (transients resolve before the marker returns). It holds on the run with slack (max tau/epoch 0.34, 0.10 after 1e9) but is unproved.",
   "closed_gaps": [
    "Blank run 3.2e5..1e10: all 771 eat and no-marker events see a normal word (g0: LE D* P1, NM: LE D* P0 b0, LE in {'',3,'3 4','3 2.3'}). EAT0 always gives a normal word, and EAT1 starts a transient epoch.",
    "Flush slack on the run (470 epochs): EAT1 max tau/epoch 0.34 (step 8.1e5), 0.104 after 1e9, median 0.036; EAT0 tau = 0. A transient never has more than 3 normal digits to its right (0/1/2/3 digits: 12,302/6,988/2,976/512 round starts).",
    "Negative results: signature-partitioned 4-grams halt at iteration 4 (21 halts). Shape closure without the flush rule halts at iteration 5 (358 halts), through eats on transient words. So the invariant must forbid eats on transient words.",
    "Epoch check over every normal word with r<=5 digits and gaps 1-3 (37,324 words): INC/CARRY normal 74,648/74,648; EAT0 normal 37,320/37,324 (4 digit-free counters); eat epochs 74,644/74,648 return to normal, 0 halts, max tau 169. With r<=3 and gaps {1,2,4,7}: 4,676/4,680 return, 0 halts.",
    "Shape closure in flush mode from 24 normal shapes: fixed point S444 (recheck 110,388/110,388; r<=3: 297,429/297,429), then S562 with r<=6 and fillers up to 9. Exhaustive pass with r<=2, f 1..4, D* gaps 1..3: 1,983,816 successors, all in S562 except a 5-shape chain that lies inside H. 0 halts and 0 flush violations in every run. All 670,604 run round starts lie in S444.",
    "Hand-written invariant H = LE . pre . X . post (LE 4 forms; pre in {'',D*,d,'D* d'}; X in 37 cluster words; post in {'',D* P1,P1}): 1,024 shapes, 2,182 keys. Closure: 259,323 successors (cap 100), then a verification with 1,214,968/1,214,968 in H (cap 600, fillers 1,2,3,4,7, D* gaps 1,2,4). 0 halts, 0 flush violations.",
    "All 130 stored closure-stage halting examples lie outside H: 70 have >=2 clusters, 58 have one cluster word not on the list ('3 f 1', '3 3 f 1', '4 f P2', ...), and 2 are eats at g=0 on a transient word."
   ],
   "remaining_gaps": [
    "Flush lemma (quantitative): at every EAT1 the new marker distance (about the unary U) is at least the flush time tau of the EAT1 output. tau is exponential in the normal digits right of the transient (tau_check: 323 of 8,824 S444 concretizations with 3+ digits right stay transient for 690 rounds), so H must first be refined to post in {P1, (d f){1,3} P1} and that refinement re-closed. Then tau <= c*L and U >= c*L are needed; U/L rises from 2.1 (6.5e5) to about 17 (1e9).",
    "Explicit token-level cascade rules. The shape-level transitions are implicit in S562/H.",
    "Init lemma to step 3.2e5 (direct simulation).",
    "proof.md, after the flush lemma."
   ],
   "files": [
    "scripts/struct/README.txt",
    "scripts/struct/summary.json",
    "scripts/struct/shapeclosure.py",
    "scripts/struct/epoch_check.py",
    "scripts/struct/tau_check.py",
    "scripts/struct/hand_grammar.py",
    "scripts/struct/flush_slack.py",
    "scripts/struct/sigclosure.py",
    "scripts/struct/shc_flush_S444.json",
    "scripts/struct/shc_flush_S562.json",
    "scripts/struct/shc_exhaustive_E1.json",
    "scripts/struct/shc_hand.json",
    "scripts/struct/shc_hand_verify.json",
    "scripts/struct/hand_seed.json",
    "scripts/struct/epoch_R5_g123.json",
    "scripts/struct/epoch_R3_g1247.json",
    "scripts/struct/tau_check_S444.json",
    "scripts/struct/shc_noflush_large.json",
    "scripts/struct/sigclosure_k4_L12.json"
   ],
   "updated": "2026-10-10"
  },
  {
   "round": 5,
   "stage": "funded flush_lemma (2026-10-10)",
   "confidence": "med",
   "recommend": "park",
   "result": "Stop rule fires. The bounded-post refinement H_3 (at most 3 normal digits right of the transient) escapes at iteration 1 (867 of 1,054,812 successors have k = 4), and the flush time from NORMAL_EAT words is not linear in L: for LE (1 3 2)^(j+1) 5 2 1 |b1, tau/L rises from 1.2 to 27.3 over j = 0..14 (tau = 2^(j/2+5) - 3 exactly for LE 3, even j). The transient cluster is a slow carry through the run of 1-bits, so the flush bound must be in the counter value (as in #28), not in L. 0 halts in every check.",
   "closed_gaps": [
    "Post-counted shape abstraction (scripts/flush/shapeR.py) reproduces the run's k counts (12,302/6,988/2,976/512 for k = 0..3).",
    "H_3 is not closed: first escape is the 2.3 walker meeting a bit-1 digit on its left (stale 1 left behind, digit becomes 5, k 3 -> 4); confirmed with tmsim (228 steps). 30 iterations: 1,273,992 successors, k up to 6, still growing. From normal seeds: k up to 8. 0 halts, 0 flush violations.",
    "Flush from eats (flush_epoch.py, g re-placed each round; 60/60 identical to the true unary): 3,000 + 2,000 random NORMAL_EAT words all return to normal, 0 halts, tau/L max 4.71 rising with kmax; 1-run family tau exponential in j (about 2^(j/2)), kmax about j/2.",
    "Run facts: value budget v <= m - 5 at all 647,826 normal round starts, m - v >= 158 at all 245 EAT1s; 1-run above the LSB at EAT1 <= 8; max tau/N 0.351, min m/L 3.4, kmax <= 3."
   ],
   "remaining_gaps": [
    "Flush lemma in value form: tau <= f(v) + a linear term for the bit-0 digits and fillers walked (the 1-run family suggests f(v) ~ sqrt(v), with exact powers of two like #28's F = 2^(1+D_F)).",
    "Budget lemma v <= m, proved inductively (INC/CARRY +1/+1, EAT0 halves v and adds 2 to m, a flush must end with v <= m).",
    "m >= c*L at every EAT1 for the linear term (growth comparison, unproved).",
    "Cascade rewrite rules, init lemma to 3.2e5, proof.md."
   ],
   "files": [
    "scripts/flush/README.txt",
    "scripts/flush/summary.json",
    "scripts/flush/shapeR.py",
    "scripts/flush/flush_epoch.py",
    "scripts/flush/budget_run.py",
    "scripts/flush/run_eat1.py",
    "scripts/flush/tmcheck.py",
    "scripts/flush/shR_H3.json",
    "scripts/flush/shR_normal.json",
    "scripts/flush/fe_rand_R10_G3.json",
    "scripts/flush/fe_rand_R6_G12.json",
    "scripts/flush/fe_ones14_g1.json",
    "scripts/flush/fe_ones11_g3.json",
    "scripts/flush/run_eat1_1e10.json"
   ],
   "updated": "2026-10-10"
  }
 ]
}