/machines/1RB0LD_0RC1RA_1RD1RF_1LA0LE_0RA0LC_0RA---/notes.md · raw

1RB0LD_0RC1RA_1RD1RF_1LA0LE_0RA0LC_0RA---

Status: CHECKPOINT_A Class guess (agent / Dennis): Shift-overflow counter: 4-state digit blocks in a bouncer, plus a one-time reset that leaves static walls / – Spreadsheet notes / Discord thread: Results row 621 has class "Shift-overflow structural counter"; status and notes are blank, with no link, no strikethrough and no xlsx comment. The machine is on mxdys's UBRRBA_TODO list (2026-08-24), which Dennis ruled fair game, and not on dyuan01's list. It is still in the 2026-10-07_778 list and has no proof in verify/. Its trajectory twin 1RB---_0RC1RA_1RD1RF_1LE0LF_1RB0LD_0RE0LC is also still a holdout (identical lo/hi/nonzeros at 1e9), so one proof likely gives 2 kills. Viewer: https://bbchallenge.org/1RB0LD_0RC1RA_1RD1RF_1LA0LE_0RA0LC_0RA---

Observation

Candidate rules

Config E at each right-edge D record: 0^inf L … b1 P^n1 b0 P^n0 T D> 0^inf. Tail A = the last P ends under the head; tail B = P^n0 101 D>.

rule transition steps validated
edge A→B (n0 same), B→A (n0+1) – 120/120
turn@D0 D0 P^a → D1 P^a, head turns 38a+22 (A) / 38a+30 (B) 61/61
turn@D1 D1 P^a → D2 P^a, head turns 38a+20 / 38a+28 59/59
carry@D2 D2 P^c → D3 P^c, carry continues +38c+14 69/69
carry@D3 D3 P^c → P D0 P^(c−1), carry continues +38c+36 71/71
wall X P^c unchanged, carry passes – 24/24
D1 meets X D1 X P^c → X P D0 P^(c−1), carry continues – 24/24
full-sweep model on the real orbit 297 sweeps @1e7 + 596 @1e9 – 893/893 (D–X adjacency excluded)

Tests: random configurations with small (2–6), large (40–2000), odd and even run lengths, both tails, and every digit state, each simulated exactly to the next D record (scripts/validate.py, scripts/validate2.py, scripts/check_real.py, scripts/check_x.py). Open: - D2·X and X·D1 adjacency make a transient block (10)^5 1^3 that is not modelled yet. - The left-prefix overflow (new digit, or reset) is not modelled. - Whether the reset recurs is unknown; it would come after 2e10, beyond direct simulation.

Template: nothing proved is within 8 transitions (SBCv6a, SBCv10, SOBLv1–3, SBCv6a2, Bouncer_v1). Only SBCv6a TM1's method fits (Longitudinal passes + an RIncs/WF digit list). Not a cryptid: no parity branching on growing numbers.

Checkpoint A (Dennis)

Informal proof

Formalization log

Outcome

Card data pass (2026-10-10)

Deepen pass (overnight 2026-10-10)

Confidence: med (unchanged), recommend: more observation. The gen-2 counter is now closed. The reset is now known to recur, so the machine is a nested generational counter, and the regrowth still has no rule. All scripts are under scripts/deepen_*.

1. Wall crossing (closes the D-X gap). - A digit moves right only through D3→D0. It therefore reaches a wall as D0, and the only adjacencies are D0·X and D1·X: - D3 P X → P D0 X (carry) - D0 X → D1 X (turn) - D1 X P^c → X P D0 P^(c−1) (carry, c≥1) - The net effect is that the digit gains +2 as it crosses. - The tape identities D0·X = X·D2, D3·X = X·D3 and X·D0 = P made the old parse ambiguous. deepen_model2.py (decode2, canon, predict2) fixes this by always writing D0 0 X. - The "(10)^5 1^3" transient in the earlier notes was an artefact of that parse. - Validation: - Real orbit: 3732/3732 right-edge sweeps from 3.8e7 to 2e8 match exactly (deepen_check_gen2_3.8e7_2e8.json). - Random instances: 300/300 (deepen_validate_cross_11.json; small/large/odd/even runs, both tails, random guards and carry chains with walls). - A longer real-orbit check from 2e8 to 3e9 was still running at write-up. It writes deepen_check_gen2_2e8_3e9.json.

2. The future, by hybrid fast-forward (deepen_hybrid.py, log deepen_hybrid_events.txt). - Method: - Ordinary sweeps use predict2. - Any sweep the model does not cover is simulated exactly in C on a copy with runs capped at 12. Every such event gave the same result at cap 20. - Model sweeps were spot-checked against capped direct runs 381 times; all agree. - Starting from step 4e8, the carry first enters the raw left prefix 130,171 sweeps later. Ten such events are absorbed there with no left record. - The first true left record (type DA) is at sweep 6,202,107. A reset (CDAEA) follows at sweep 13,979,318, when the span is about 5.6e7 cells. By the rough t ≈ 15·s² fit, that is around 3e15 steps (an estimate). - So the reset does recur, far beyond direct simulation.

3. Which kind of left overflow happens. - If the tape starts with 7 ones (1111111 0), the overflow is type DA: the tape grows 2 cells and then starts with 9 ones. - If it starts with 9 ones, a reset happens, and the rebuilt tape starts with 7 ones again. - So DA and reset alternate. This fits every gen-1 left event except the start (DA at 51, 264, 739, 1992, 39589; reset at 107, 394, 1603, 5272, 29,787,121). It also predicted the DA-then-reset order in step 2.

4. What the reset does. - The full left pass leaves the tape in Q form (Q = 01010010). An inner bouncer then grows from the left at +8 cells per inner sweep (1032 of 1051 front steps at the 2.97e7 reset; deepen_reset_turns_2.98e7.txt). - At each old digit the front jumps +4/+34/+16, and that digit becomes a static wall. The inner left turns stay at ≥ 34. - The predicted 2nd reset (deepen_prereset_state.json) was run on copies with runs capped at 16/32/64/128 (deepen_force_reset.json): - All four give the same structure: digits 22→46, walls 10→30, and the same 194-cell prefix, which starts with 7 ones. - After that, 399/400 sweeps match predict2. - The one miss is the first sweep after regrowth, a new right-edge transient D3 P^0 tail B → X P^1 tail A.

Still open (for proof work): - A parametric rule for the regrowth over Q-territory. - Rules for the left zone. There are D–D adjacencies and D2·X, and the events are so far only simulated directly. - A generation invariant: a tape language closed under sweeps, prefix events, DA and reset.

Cryptid check. Not a cryptid. Digit values, including the +2 at walls, only move when events happen; whether the tape stays in the grammar does not depend on arithmetic.

Superseded. deepen_force_overflow.py (hand-mutated digits, unnatural configurations) and deepen_ffwd.py (model-only, wrong at the prefix) are replaced by deepen_hybrid.py.

Deepen pass 2

Confidence: med (unchanged), recommend: more observation. The reset is no longer a separate mechanism: it is the same counter with a different right edge. The open part is now just the left zone, plus the invariant that rests on it. Scripts and result files are in scripts/deepen2/. Run them with python3 -B; ana.py summarises a dump.

0. Round-1 leftover closed. The real-orbit check of predict2 on 2e8–3e9 matches 16391/16391 sweeps (0 bad, 0 unmodelled; scripts/deepen_check_gen2_2e8_3e9.json).

1. Every sweep converts P to Q and back. - Low-level traces of ordinary sweeps (2.9733e7) and of the reset sweep (2.9754e7) show the same mechanism: - The left-moving carry runs a D/A and E-C-F-A-B-C-F-A cycle that rewrites each block into Q form: P→01010010, D0→010010, D3→010101, X→01. Checked token by token on the real tape: 1080/1080 P and all 17 blocks. - The return pass writes P form back and applies the carry rules. - The "full left pass" before a reset is therefore simply a carry that ran off the left end (the 9-leading-ones case). It leaves the whole tape in Q form, and the regrowth is that sweep's return pass.

2. Regrowth = the same counter with a Q-territory edge. At each inner front turn the tape is L [counter tokens] TQ | 0010 Q^k M … with TQ = 1010101 (head: state A on the last cell of TQ). - One inner sweep: n0 += 1 (exactly one Q is consumed), then the unchanged predict2 carry rules (turn at D0/D1, carry through D2/D3, wall crossing). - Random instances: 600/600 exact tape matches (valq_*.json). They cover all 7 carry targets, small/large/odd/even runs, k = 2–60 and d0/d3 next markers, on the real 94-cell prefix. - Real orbit: 1001/1065 inner sweeps of the gen-1 reset (dump1.json). Also 1081/1442 of the 2nd reset run on a cap-64 copy (dump2_64.json, start reset2_cap64.json).

3. Old digits in the Q territory become walls, each giving birth to 2 new digits. Every regrowth sweep that does not fit the model falls in a short episode of fixed shape:

shape sweeps front jumps leaves seen
i 9 8,4,34,8×6 X P^2 D2 P^1 D1 P^7 15
ii 7 38,8×6 X P^1 D2 P^1 D1 P^7 6
iii 2 34,8 X P^1 X P^1 D0 P^3 (old digit next to an old wall) 4

4. End of regrowth. The round-1 rule had the wrong tail. The correct rule is L [.. b1 P^n1] D3 P^0 tail-B → L [carry(.. b1 P^n1)] X P^1 tail-B, with the carry continuing. Random instances: 400/400 (valendB_*.json). After it, ordinary 0^inf-edge sweeps resume (187/187 in the cap-64 run).

Still open (for proof work): - Left zone. There are no parametric carry rules for zero-length runs (D_i 0 D_j, D2 0 X, D3 P^0 followed by X or D). This one gap covers the raw prefix (digit births, the gen-2 "absorbed" events, the DA/reset alternation of 7 and 9 leading ones) and the inside of the marker and start episodes. - Marker episodes. The 3 shapes, and the phase that picks between them (last digit D1 or D2 when the front arrives), are observed only (21 real + 20 capped instances), not randomised. - Generation invariant. It is not written yet. It needs a tape language closed under sweeps, both edge modes, the episodes and the left-zone events.

Cryptid check. Still not a cryptid. Run lengths only affect timing, and which episode shape occurs depends on the counter phase, not on arithmetic of large numbers.

Correction. Round-1 "post-regrowth transient D3 P^0 B → X P^1 A" should read → X P^1 B (carry continues).

Decision (2026-10-10)

Question: Fund one more deepen stage on #9's left zone (parametric rules for zero-length runs, plus validated marker episodes), aiming to reach high confidence and go on to proof.md? Answer: left_zone (One targeted stage on the left zone, then proof.md). Dennis: go with all recommendations (2026-10-10).

Funded stage (2026-10-10, left_zone)

Confidence: med (unchanged), but the open part has moved. The left zone of ordinary sweeps is closed by one finite object. What is still open is the reset and its regrowth (left-end overflows of type CDAEA), plus the marker episodes inside it. Scripts and results are in scripts/deepen3/; run them with python3 -B.

1. A better alphabet: x/v words. At every sweep end the tape, read from its first 1 in cell pairs, is a word over x = 11 and v = 10. The tokens are just words in it: P = xxvv, D0 = xvv, D1 = vxx, D2 = vvx, D3 = xxx, X = x. This explains every parse identity at once (D3 = XXX, X·D0 = P, D0·X = X·D2). The left zone contains words outside the token language, e.g. v^5 at the start of the 94-cell prefix (xxxvvvvv...) and v^6 at the start of the 194-cell one. Per-pair zero-run rules (exp1.py-exp3.py) showed the problem: the carry's effect at b1 0 b2 depends on more than the pair (D1 0 D2 -> D3 0 D2, carry continues; D2 0 D2 -> vvv D3, stops; X 0 X P^r -> D1 0 D0 P^(r-1), stops; vvv acts like D2). So I dropped the per-pair rule table and tested whether the whole sweep is a finite-state process.

2. Every ordinary sweep is one finite transducer (tlearn.py, ttable.json). Take the crossing sequence (the states in which the head crosses, in order) at each pair boundary during one sweep: - Only 10 crossing sequences occur, the empty one included (e.g. LD RB LA RA LD RA inside P-runs, LE RA / LC RD LA RC at the turn). - The crossing sequence at a boundary is a function of the sequence one pair to its right plus the 4 input pairs to its left (lookahead 3). The output pair is then fixed by the two sequences around it. - Learned on 30,000 random words (seed 21, iid x/v words and token words with runs 0-3, raw vvv, every digit and wall): 100 table keys, 0 ambiguous. - Validated on 30,000 fresh random words (seed 22): 26,813/26,813 sweeps that stay inside the word match the table at every boundary, with 0 unseen keys (tval_2.json). This includes 419 sweeps whose carry reaches the first pair. - Real orbit from blank to 1.1e8 steps (exact Python simulation, treal.py): 4,347/4,347 ordinary sweeps match the table exactly, across gen 1 and gen 2 (treal_1.1e8.json; to 2.9e7: 2,151/2,151, treal_gen1.json). The other 10 sweeps are left-end events, the last being the 8.0e6-step reset at 2.975e7. - No halts inside the word: in haltwhere.py (20,000 iid random words), 0 of the 17,183 sweeps that stay inside the word halt. All 63 halts happen after the head has crossed the left end of the word. - Consequence: zero-length runs, D-D adjacency, D2 0 X, D3 P^0 X/D, raw v-runs, digit births and the gen-2 "absorbed" events are not separate cases. The same 10-state table handles them, for any x/v word, so the left zone needs no extra rules for ordinary sweeps. predict2 is the reading of this table on the canonical parse with long runs.

3. Left-end events depend on the first symbols only (tleft.py). - Prefix xxxv (7 ones), random body, carry runs off the left end: 645/645 are type DA (left records D, A), the new word starts xxxxvv, and none halt (tleft_x3v.json). - Prefix xxxxvv (9 ones, the real post-DA form), random body: all 326 left-end events start with CDAEA, and the regrowth ends with prefix xxxvvvvv or xxxxvvxx. But with random bodies the regrowth often overflows again inside itself: 77 plain CDAEA, 98 CDAEA+DA, 55 CDAEA+DA+CDAEA, 92 deeper chains, and 4 halts, all after the chain CDAEA DA CDAEA DA (tleft_x4vv.json). - The real orbit has nested events too: the reset at step 1,603 contains a DA at 1,992 in the same sweep (treal_gen1.json, sweep 14). The left-end sequence from blank is vv → xxxvv → xxxxvvvv → xxxvvvvv → xxxxvvxx → ..., which fits the DA/reset alternation. - So a DA is safe for any body, but a reset is not: whether the regrowth's inner counter overflows, and whether a nested overflow is safe, depends on the body. In the real orbit the body is a counter whose old digits sit at roughly doubling positions. Each old digit adds 2 digits to the inner counter (capacity ×4) while the Q-run to the next marker only doubles. That is a monotone capacity argument, not a cryptid, but it is not yet written or checked.

4. Not done in this stage. - Random-instance validation of the 3 marker-episode shapes. A harness was started (tmark.py), but its first version failed to parse the post-episode tape, and the script file was then lost. No numbers came out, so the shapes remain observed only (21 real + 20 capped). - With the transducer, the episodes should reduce to the same table plus a finite front rule at the Q-territory edge, but this is untested.

Generation invariant (draft). Reachable sweep-end tapes are x/v words W with: - (a) W starts with xxxv (next left-end event: DA) or xxxxvv (next: reset). - (b) Ordinary sweeps are the transducer above. They are total, never halt, keep (a), and append 2 symbols at the right. - (c) DA maps (a)'s first case to its second for every body (validated). - (d) Reset: the body must be in a counter language K, where the digits sit between P-runs whose lengths grow so that the regrowth never overflows the inner counter, or overflows only harmlessly. The new tape must again be in K with prefix xxxv.

(d) is the open core. It needs the front rule over Q territory (Q-edge rule, done 600/600; marker episodes, open; end of regrowth, done 400/400) and the capacity inequality.

Proof route this suggests. Part (b) is a finite crossing-sequence fact, which is checkable exhaustively and does not depend on parameters. That makes a regular-language (CTL-style) certificate plausible for everything except the reset's capacity argument. busycoq's CTL deciders can check such a certificate if the search is done natively (never inside Coq; see rocq-notes).

Decision (2026-10-10, auto-applied)

Question: Fund one more stage on #9's reset (front rule at the Q-territory edge, randomised marker episodes, the inner-counter capacity bound), aiming at high confidence and proof.md? Answer: reset (One targeted stage on the reset, then proof.md). auto-applied: Claude's recommendation, under Dennis's standing instruction 'do your recommendations and continuously orchestrate' (2026-10-10, while he was at lunch). Override any time.

Funded stage (2026-10-10, reset)

Confidence: med (unchanged). Two of the three targets closed: the regrowth front is now one finite table, and it covers every marker arrival on random instances. The third, the capacity bound, is stated and checked numerically, but it is not proved. It turns out to depend on the left zone (the prefix) of each generation, so it needs an induction over generations. Scripts and results are in scripts/deepen4/; run them with python3 -B.

1. The regrowth in pair letters (rg.py, look.py). Use the pair letters x=11, v=10, a=01, o=00 in the grid of the new word. - The reset's left records CDAEA grow the tape by 5 cells, so the new grid is shifted by one cell from the old one. In the new grid, the Q-territory reads Q = aovv and P = xxvv, so every Q-edge sweep turns one aovv into xxvv. - Real gen-1 regrowth (from deepen2/at_left2.json; 1,075 inner sweeps under the round-2 cut): - 1,059 front turns are in state A on an even cell. 15 are the ordinary state-D right records after the end, and 1 is the start. - The front advances 8 cells in 1,046 sweeps. At an old digit it advances 4 then 34 (4 times), or 38 (3 times). - So at the cell level, a marker "episode" of round 2 is just one long front jump. The other sweeps of the episode are ordinary 8-cell advances whose token parse looked unusual.

2. Every inner sweep is one finite table (tfront3.py). - The round-2 cut (the head goes 24 cells left of its maximum) is not local. Short inner sweeps merge, and the front side stays ambiguous even with 20 pairs of lookahead (ktest_c11_gapcut.txt; 150 random regrowths, 11,128 sweeps). - New local cut: a sweep ends when the head enters a new front cell from state F (Q edge), or makes a new global right record in state D (0 edge, as in deepen3). - The table has two sides. Inner side (b <= hp, where hp is the pair the head starts in): right-to-left key (crossing sequence at b+1, pairs b-3..b) -> crossing sequence at b, with crossings labelled

as in deepen3. Front side (b >= hp): left-to-right key (crossing sequence at b, pairs b..b+3, b-hp) -> crossing sequence at b+1, with crossings labelled . The old state is needed to see the F-cut. A first try that dropped it gave 15 spurious ambiguities (tfront3_31_localcut_2label.txt). - Learned on 68 random regrowths (seed 51, 9,128 inner sweeps): 213 keys (69 inner side, 144 front side), 0 ambiguous, 23 crossing labels. The front side reaches at most 8 pairs right of the head. - Validation (tfront3_51_52.json): - Fresh random regrowths (seed 52, 68 instances): 24,457/24,463 inner sweeps match, 0 contradictions. The other 6 sweeps each have a key the 68 learning runs never saw (the table is not saturated yet), and nothing contradicts the table. - Real gen-1 reset at 2.975e7: 2,207/2,207. - Real 2nd reset (run-capped at 64, deepen2/reset2_cap64.json): 2,705/2,705. - Excluded: the sweeps that cross the word's left end (233 random, 2 + 2 real). These are the CDAEA start and the nested left-end events, which item 3 covers. - The random pre-reset words are a 9-ones prefix (xxxxvv, xxxxvvxx or xxxxvvvv), then 2-12 random blocks D2/D3/X/D1 X with P-runs that are small (0-6), doubling or mixed, then the right end. Every inner sweep of all 68 + 68 regrowths was checked: Q-edge sweeps, every marker arrival (d0/d3/x, adjacent markers, zero runs), the start and end episodes, and the 0-edge sweeps that follow. - So the 3 marker shapes are no longer separate rules. They are what the same table does when the Q-territory window holds a marker. That is the randomised-marker validation asked for (thousands of marker arrivals; I did not count them per shape). - Caveat: the table is learned, not derived. Turning it into a proof needs an exhaustive check of the tiles, which are finite: 23 labels, 4 pair letters, the head marks.

3. Capacity: when does a regrowth overflow its own inner counter? (tcap.py) Each run is a pre-reset word, run exactly through its whole reset sweep. I recorded the left records after the initial CDAEA and any halt. Bodies: 4-9 random old markers, with Q-runs that grow by a random factor in [1, R] per marker.

prefix R runs plain CDAEA +1 nested DA nested reset halt
real gen-2 prefix (50 cells) 2 200 155 22 0 0
real gen-2 prefix 3 100 58 29 1 0
bare xxxxvv 2 150 42 46 39 1
(round 3) xxxxvv, iid bodies – 326 77 98 147 4

The rest are runs with no left event: the first sweep's carry stopped inside the word, for example at a zero-length run (D2 0 D2). - The real orbit: the 5 resets from blank (sweeps 3, 5, 14, 30, 2188) have 0, 0, 1 (a nested DA), 0, 0 nested events. The 2nd reset (caps 16-128) has 0. - Statement (conjectured lemma). Suppose a reset starts from a 9-ones word whose left zone is at least as large as the real gen-2 prefix, and whose Q-runs at most double from one old marker to the next (real gen-2 body: ratios 1.96-2.03 for the long runs). Then the regrowth has at most one nested left-end event, and it is a DA. So there is no nested reset and no halt, and the next left event alternates as before. - Why: each old marker gives the inner counter 2 new digits (capacity x4), while the next Q-run only doubles. So overflow can only happen in the first few markers, and there the left zone sets the margin. - Not proved: (i) the run growth of at most x2 in the real pre-reset body of every generation; (ii) the base case. With the bare 6-pair prefix and the same x2 bodies, 39 of 150 regrowths nest a reset and 1 halts. So the left zone of each generation matters, and the 2 known real ones (gen 1, gen 2) are fine. Both need an induction over generations (static walls, drifting digits, and the left zone after each reset). Gen 3 is beyond any direct check (about 2^46 sweeps).

Still open (for proof.md): - (a) The generation induction behind the capacity lemma. - (b) An exhaustive, derived check of the two tables (the deepen3 ordinary-sweep table and this inner-sweep table), replacing the sampled ones. - (c) The 6 unseen-key sweeps: re-run with more learning instances to saturate the table.

Not a cryptid: the open part is a monotone counting bound, not parity arithmetic.

Decision (2026-10-10, auto-applied, round 3)

Question: Fund one stage on #9's generation induction (show every reset body grows at most x2 per marker and keeps a large enough left zone), or park the machine? Answer: induct (One stage on the generation induction, then proof.md). auto-applied: Claude's recommendation, under Dennis's standing instruction 'do your recommendations and continuously orchestrate' (2026-10-10, while he was away). Override any time.

Funded stage (2026-10-10, induct)

Confidence: med (unchanged). Outcome: parked by the stage's stop rule. The right part of the induction is closed: the x2 run growth follows from counter arithmetic, and the real data fit it. The left zone is not closed. Every left zone computed (generations 2-5) is safe, but the zone is neither stable nor growing. Its size alternates between generations. Scripts and results are in scripts/induct/; run them with python3 -B.

1. The left window map (phi.py). - Key fact: the left part of the tape (raw prefix plus the first K blocks) changes only when a sweep's carry reaches it (an "arrival"). The next reset is the arrival at which the left end overflows for the second time after a reset (first a DA, then the CDAEA). So the window at the next reset is a function of the window at this reset. The digits to its right decide only when arrivals come, never what they do. - The map: Phi(W) = the exact reset sweep of W + P^R + tail, then the hybrid fast-forward (predict2 sweeps, exact C-simulated sweeps at left-zone events) until the next CDAEA. - Real-orbit check, gen 1 to gen 2 (val12seq.json). The start is the real gen-1 pre-reset window (pre1.json, step 29,754,243). - Windows of 11-12 blocks, with R = 6, 12 or 30: 6/6 runs reproduce the real gen-2 left-zone event sequence exactly (11 events plus the reset, taken from the full-tape hybrid in deepen_hybrid_events.txt). Their pre-reset prefix and leading 12-17 tokens equal the real gen-2 pre-reset state. - 9-block windows get the final prefix right but not the event sequence, because the window is too small. - Reset 2 with the near runs exact (gradcap2_8000_64.json, gradcap2_30000_64.json): runs left of cell 8,000 (or 30,000) are exact, and runs further right are capped at 64. The left records are CDAEA only, with no nested event, and the post-reset prefix is the known 194-cell one. - The round-1 uniform caps (16-128) also cut the near runs 173-1711, and those carry most of the arrivals. So this is the first reset-2 check that keeps them.

2. The right part: x2 growth (counter arithmetic, plus the real data). - Over a arrivals, a digit passes the carry ⌊a/2⌋ or ⌈a/2⌉ times, ±1, and moves right ⌊a/4⌋ ± 1 P. A wall crossing adds one pass and one move (D0 X → D1 X → X P D0: two extra visits). - So the j-th digit right of the window receives about 2^j·N_W arrivals per generation, where N_W is what the window received. Its drift is about 2^(j-2)·N_W, and the gap between consecutive digits tends to ratio 2. - Real resets, digit gaps with walls ignored: gen 1 ratios ≤ 2.18. Gen 2 ratios 1.44-2.007, and the last 14 are 2 ± 0.01 (1,711.8, 3,430.8, 6,837.8, ... P). - Consequence (derivation only, O(1) error terms not tracked tightly): the arrivals reaching the window during a regrowth are N_reg ≲ (first gap) + Σ_j gap_j/4^j + O(1) ≈ (first gap) + ¾·N_W(previous generation). The far tape never matters, so capacity is decided by the left window alone.

3. The left zone over generations. Phi was iterated from the real gen-2 pre-reset state (iter2_8_10*.json). Each generation was run with 8- and 10-block windows, continuing from the 10-block result. The two window sizes agree on 203, 2,185 and 229 cells for gens 3, 4 and 5; gen 3 also agrees with a 12-block window (val23_nb12.json).

gen raw prefix (cells) left-zone events DA at event same cells as gen g−2
2 (real) 50 12 8 –
3 168 123-128 21-26 –
4 96 20-21 10-11 53 (gen 2)
5 128 98 37 91 (gen 3)
6 212 410 – 99 (gen 4)

All five start with xxxxvvxxxxx. Gen 3 and gen 2 share only 23 cells. Gen 6 comes from iter2_8_10_g7.json (the same run continued; its gen-7 step did not finish within the stage). - Capacity of the predicted zones (tcapgen.py; same x2-body test as round 4's tcap.py): - gen-3 zone: 0/80 nested events (72 plain CDAEA, 8 with no left event). - gen-4 zone: 0/80 (75 and 5). - Real gen-2 zone, for comparison: 22/200 nested DA, 0 nested resets. - No halts.

Result. Every left zone computed is safe, and safer than gen 2's. But the zone is not stable: its size and event count jump around (50, 168, 96, 128, 212 cells; 12, ~125, ~20, 98, 410 events). It is also not monotonically growing. The only hint of structure is a possible 2-cycle: generations g and g−2 agree on 53, 91 and then 99 cells (gens 4, 5, 6). The event counts do not cycle, though. The stop rule ("park unless the left zone is shown stable or growing") applies, so the machine is parked.

Still open (for whoever reopens it): - An invariant of Phi on the left zone for all generations, for example a 2-cycle on the first ~100-200 cells. Iterating Phi is cheap: gens 3-5 took 5-34 s each. The question is whether the 2-cycle agreement keeps growing. - A proof that Phi's output on the zone depends only on the zone. Window-size independence is sampled only, with 2-3 sizes per generation. - The N_reg bound, as a written inequality with explicit error terms. - Both finite tables (deepen3/ttable.json, deepen4 inner sweeps) are still learned, not derived.

Superseded / scratch: iter.py (6-block windows; too small, the windows disagree with 8 blocks), cmp12*.py (exploration). Not a cryptid (unchanged).

Note (2026-10-10, orchestrator)

The marker-episode harness reported lost above was found in the repo root and moved to scripts/deepen3/: tmark.py, tmark_test.json, root_tmark_test.log (60/60 UNPARSED, the first version). scripts/deepen3/tmark_test.log is a different, earlier log.

Decision (2026-10-11)

Question: Keep #9 parked, as the stop rule says, or fund one stage to test whether its left zone settles into a 2-cycle across generations? Answer: park (Keep parked). Dennis: go with recommendations (2026-10-11).