1RB0LF_0RC0RB_1LC1LD_1RE0RD_---0RA_1LA0LF

Status: CHECKPOINT_A Class guess (agent / Dennis): self-similar multi-wall bouncer (x3 epochs) / — Spreadsheet notes / Discord thread: Results tab "Unknown", no notes/sources; Level-0 tab ("not individually worked on"); not in dyuan01-24 or mxdys UBRRBA-86. Code-A Discord search of the string: Dennis. Viewer: https://bbchallenge.org/1RB0LF_0RC0RB_1LC1LD_1RE0RD_---0RA_1LA0LF

Observation

• 4e10 steps, no halt. Span 384,466 (lo −384,381, hi 84), nonzeros 192,262. Right edge: 56 from 4.2e6 steps, then 84 after ~2.5e9.
• Tape = alternating 10 background + domain walls (00, 11, (010)^2, 0^2 (1011)^2, dense (1011)^n blocks).
• Head sweeps flip 10↔01 and reflect at walls. Each phase repeats a fixed sweep program; exponents change linearly per cycle (multi-counter bouncer). See img/cycle_1e7.png, img/walls_1e9.png.
• Epochs: the anchor P(a,c,T) = 0^inf <A (10)^3 (010)^2 (10)^a (01)^2 1 (10)^4 (01)^2 1 (10)^c T is followed by a burst (a−2, b+6 per cycle) that ends the epoch.

Closed form: a_n = 171·3^n − 3; c_n = 217 + 171(3^(n+1) − 3)/2 − 7n. Epoch 5 was predicted before it was simulated, and it matched. - Tail T: each epoch reads 73–100% of it (scripts/tail_reach.py); token count grows 13 → 31; the E5 tail starts with the E1 tail's skeleton at a larger scale, which suggests nested fossil blocks. - Quick_Sim: block size 4, 76 one-off Diff rules, 200k loops reach 1.8e12 steps (no real acceleration). rulefit: no validated high-level rule; 2 sligocki low-level rules re-verified 10/10.

Candidate rules

Tested by direct simulation from concrete configurations (scripts/validate_*.py): - Epoch map P(a,c,T) → P(3a+6, 3a+c+2, T') for a even ≥ 2, c odd ≥ 3: 34/34, including 4 different tails T0–T3 swapped in, so the left recursion does not depend on the tail. Case splits: c even → c' = 3a+c+3 (5/5); c = 1 → c' = 3a+5 (10/10); a = 0: no anchor. On the orbit a is always even and c always odd. - Burst cycle (10)^(a+2) (01)^2 1 (10)^b → (10)^a (01)^2 1 (10)^(b+6), 20a+210 steps, a even ≥ 2, any b and any right context: 420/420. Odd a gives a different cycle (never on the orbit). - Slow-phase cycle (epoch 1, ~1e7; 7 counters, rule in observe.json), 20(a+b)+10(c+d+e+f)+340 steps; needs a,b,c,e,f odd and d even ≥ 2: 86/86 (d=0 fails). - Missing: the full phase list inside one epoch (collisions) and the tail rule T → T'.

Checkpoint A (Dennis)

Questions are in observe.json. The main redirect would be: decode T → T' first (fossil nesting?) or attack the left recursion alone.

Informal proof

Not started (waits for Checkpoint A).

Formalization log

—

Outcome

—

Repro: scripts/walls.py (wall diagrams), scripts/anchors.py <burst-start steps>, scripts/validate_epoch.py epoch_cases*.json, scripts/validate_cycle.py {burst|slow} N SEED. Large runs are gzipped (records_4e10.jsonl.gz and others).

Card data pass (2026-10-10)

The card now shows at most 3 short mechanism bullets and yes/no questions that point at figures by number (primary figures first). The text they replaced is kept here. - Figure order on the card: Fig 1 = img/default_blank_1500.png, Fig 2 = img/epochs_2v3.png, Fig 3 = img/walls_time_4e8.png, Fig 4 = img/records_epochs.png, Fig 5 = img/blaze_1e9_labeled.png (Figs 1-2 primary). - Mechanism, full observer version: - Tape = alternating 10 background plus a few domain walls (00, 11, (010)^2, dense 1011 blocks). - Head sweeps flip 10<->01 and bounce off walls; each phase repeats a fixed sweep program with run lengths changing linearly. - A phase ends when a run hits 0; phases chain into epochs. Each epoch ends with a burst where a 11 wall races to the left edge. - Epoch anchors P(a,c,T): a'=3a+6, c'=3a+c+2 exactly (a_n = 171*3^n-3); span x3, time x8.5-9.9 per epoch. - Tail T (right part) is rewritten every epoch; its rule T->T' is the open question. - Checkpoint questions before the rewrite (some were decisions, not questions about a figure): - walls_1e9 + walls_6e7: same picture at x3 scale per epoch (green lines). Prove one generic epoch? - cycle_1e7: is this a multi-wall bouncer (sweeps flip 10/01, reflect at walls), not a counter? - walls_1e9 right side (red triangles, wall bundle): decode the tail rule T->T' before any proof work?

Deepen pass (overnight 2026-10-10)

Goal: close the open gaps (phase list, tail rule T -> T', invariants). Result: the micro-mechanism and the halting condition are now exact and validated; the tail rule is NOT closed. Confidence stays med. Tools: scripts/deepen_* (C tracers; build with gcc -O2; sources say how to run).

1. Crossing lemma (exact, validated). A sweep complements every cell it crosses (10<->01, 00<->11) and never moves a wall. All tape changes happen at turns, within 8 cells of the turn point. - Left sweep (F/A): complements until it reads two 0s in a row (A reads 0); it always turns at the first 00. - Right sweep (B,C,D,E,A cycle, 4 cells per 6 steps): crosses 00/11 at one parity and turns at the other (C0 starts a C-run left, or A1 -> F). - Checked on all 931,918 sweeps from blank to the E5 anchor (3.54e10 steps; deepen_ccheck.c). Non-complement changes lie <= 8 cells from the sweep ends, except 5 right-edge sweeps (<= 12 cells; these are the right-edge growth events). - Consequence: write the tape as a list of maximal alternating segments. Sweeps leave the segment lengths alone; only turns rewrite them (local, <= 8 cells).

2. Halting lemma (exact; hand derivation + validation). Halt = E reads 0. E is entered only by D0. D can reach a 0 followed by a 0 only after a D1, and D1 happens only after a C-run that follows a left-sweep turn. - D1 happens exactly when the configuration 1 0 0 <F 0 0 occurs: F reads 0 at u+1, the cells u-1,u = 1,0, and u+2,u+3 = 0,0 (already complemented by the sweep). - The machine halts exactly when the configuration is 1 0 0 <F 0 0 0 0 or 1 0 0 <F 0 0 1 0 0. - Validated on random tapes (deepen_haltlemma.py, 40k runs): 7,886/7,888 halts after step 40 match. The 2 misses are at steps 40-41 and come from the random start state. 32,118/32,119 D1 events match. - On the blank-tape orbit to 3.54e10 steps, D1 happens only 6 times: steps 130, 309, 2,306,898, 2,380,763, 2,488,620,044 and 2,497,241,765 (deepen_d1log.c). All 6 are at the right edge and are the right edge's growth steps (hi 8->14, 44->50, 72->78). Each time the D-run is 6 long and E then reads 1. The pattern never occurs in the bulk. - So non-halting = "the pattern 1 0 0 <F 0 0 (0 0 | 1 0 0) never occurs", and in practice the question is only open at the right edge.

3. Phase lists (exact periodic turn programs; deepen_wturns.c + deepen_seg.py). Phases with at least 5 cycles, as period k x cycle count: - E1: 16x254 | 20x63, x26, x48, x139 (the same 7-counter slow cycle; the turn-wall index drops 8->5 as interior walls are absorbed) | 44x46 | 44x197. - E2: 16x767 | 20x87, x88 | 44x29 | 48 (7 sub-phases, x8 to x233) | 100x78 | 104x12 | 100x173 | 44x104. - E3: 16x2306 | 20x532, x533 | 44x178 | 48x133 | 100x469 | 104x22 | 212x8, x58 | 436x9 | 44x1106. - E4: 16x6923 | 44x1961 | 104 (4 sub-phases) | 212/216/220 (7 sub-phases) | 436x25 | 100x1935 | 436x155. - The programs nest: k' = 2k+4 (or +12) each time one more wall joins the bounce (16, 20, 44, 48, 100, 104, 212, 436). - The phase list is different in every epoch and its depth grows. There is no fixed per-epoch phase list; only the left part (a, c) repeats exactly.

4. Tail = growing register system (open). A processing front moves right through T during the epoch (snapshots: deepen_dumpat.c | deepen_cmp.py). - Dense blocks (1110)^n (1101)^n (1011)^n (0111)^n act as registers and are converted block to block. E2 values: 87/93, 52, 128 -> 174, 177, 175, 173 -> 45, 126 -> 14, 48, 18 -> 467, 15 -> 7. - The wall-cluster count at the anchors grows: 15, 14, 15, 20 (E1-E4). - Tail gap values show no affine pattern (first gap 192, 349, 2129, 3920, 16848). - T -> T' therefore needs a register machine whose number of registers grows. It was not decoded. There is no sign yet of residue (Collatz-type) branching; branching is on which register empties first.

5. Local-language saturation (deepen_factors.c). Distinct 16-cell windows (mod complement) around turn points: 1768 / 1939 / 1967 / 2022 / 2363 at the E0..E4 anchors. - The bulk (pos <= -150) has produced no new window since step 258,986,194 (epoch 2). - All 341 new windows in epoch 3 are at the right edge (pos > -150): the growing 1^k run and the small dense block there (1^6 -> 1^8 -> 1^10). - So the bulk lives in a fixed finite local language, which looks like a regular closed language. The right end is the only region that keeps producing new local patterns.

6. Tail robustness (deepen_gentails.py + deepen_runcfg.c). Real tails were perturbed: gaps rescaled by up to +-1/3, and 15% of the walls dropped. - 80 perturbed tails on the E1 left part (5e8 steps each) and 20 on the E2 left part (1.2e9 steps each): 0 halts. - 33 runs had D1 events (E always read 1). - 18 runs entered another right-edge regime: the right edge ran away to about 50k cells. - So non-halting looks robust to the tail, but the bounded right edge of the real orbit is specific to it.

Assessment. Mechanism: a nested wall bouncer with exact micro rules (crossing = complement, local turn rewrites). Halting reduces to one local pattern, which has never occurred in the bulk. - The epoch-induction route is blocked on the tail: there is no finite phase list and T -> T' is a growing register system. - More promising route: a closed regular language. Crossing lemma + saturated bulk windows + halting lemma: build the language from the bulk's walls/segments, then handle the right-end region (where all near-halts happen) separately or inside the same DFA. - Next steps: (a) a FAR/CTL search with a larger DFA than the bbchallenge deciders used (or a hand-built language from the segment catalogue); (b) a turn-by-turn decode of the right-end region (deepen_redge.c); is it a finite-state process plus one growing 1^k? - Not a cryptid on current evidence: no pseudo-random arithmetic has been shown, though the tail values are irregular. - Addendum to item 5: when this pass was written up, the window scan was partway through epoch 4 (after step 3.82e9) and had found no new window there at all, either in the bulk or at the right edge. That run was still going in the background; its output is in the session scratchpad, not in this folder.

Deepen pass 2

Goal: close round 1's gaps (tail rule, right end, a non-halting invariant, cryptid status). Result: the gaps are not closed. The new data rule out the two cheap proof routes, so the recommendation is now STUCK (confidence med; not a cryptid on current evidence). Tools: scripts/deepen2_* (sources say how to run them); outputs in scripts/deepen2_out/; figure img/deepen2_tail_fossils.svg.

1. Accelerated observation to epoch 8 (new). sligocki's Quick_Sim works here with block size 4 and the prover on: 1.87M loops reach step 4.31e13, the middle of epoch 8 (deepen2_qanchors.py; the log is deepen2_out/qanchors_1.87Mloops.jsonl.gz). - Cross-checks against direct simulation: - From blank: the Quick_Sim tape at step 4,785,511,149 equals the direct C simulation, cell for cell (166,105 cells; deepen2_dumpat.c). - Between consecutive Quick_Sim visits at 8.58e12, 3.99e13 and 4.30e13 (deepen2_qpaircheck.py): equal. - All 72 E8 intervals in item 6: equal. - No halt to 4.31e13 steps. Past that point the run slows to ~100 loops/s (it was stopped there). - The tape grows x3 per epoch: 1,932 cells (E0 start) up to 13,462,976 (E8 start, step 3.09e13). The left part keeps the round-1 form at every epoch start.

2. Particle view of the tail (new; deepen2_yparts.py, deepen2_tailmap.py). Write y = t XOR (pos mod 2). The 1010... background becomes constant runs, and walls become run boundaries. - Runs of 12 or more cells are gaps. Each maximal group of shorter runs between gaps is a particle; long period-4 blocks are written D(...)^n. - At each epoch start the tape is: left part, 8-19 particles (13-37 tokens counting gaps), then the right-end particle. The full lists for E0-E8 are in deepen2_out/tailmap.txt. - Fossil suffix. Each epoch rewrites a prefix of the tail and leaves a suffix untouched. Untouched suffixes, counted in tokens (particles and gaps): 9 (E1), 1 (E2), 21 (E5) and 19 (E6). The same 19-token block g10526 [1 4 1 1 1] g1736 | g3607 ... g32 [right end] is unchanged from E5 to E7. - The right-end particle is rewritten only in epochs E0, E3, E4, E7 and E8 (E8 from 3.99e13 on); it is untouched in E1, E2, E5 and E6. This fits "epoch n ≡ 0 or 3 (mod 4)" for n = 0..8. That is a hypothesis from 9 epochs, not a rule. It predicts no right-end change in E9 or E10 and a change in E11 and E12. - Figure: img/deepen2_tail_fossils.svg has one row per epoch start. Particles are placed by their distance from the right end (log scale): grey = unchanged since the previous start, blue = rewritten. The right-end particle is red when it was rewritten since the previous start and pink when it was not.

3. Right end decoded at the cell level, to E5 (deepen2_visits.c, deepen2_hilog.c). - Crossings of cell -300 (1,045 to step 3.6e10) come in bursts: <=5.3e6, 1.17e8-1.27e8, 2.59e8-2.71e8, 2.08e9-2.26e9, 2.42e9-2.69e9, 9.11e9-9.19e9, 1.167e10-1.19e10, and from 1.84e10. - The last 60 cells change only in E0, in E3 (2.42e9-2.69e9) and once in E4 (1.17e10). - hi grows in steps of +2 or +4 (the C-run writes 1s into 0^inf) or +6. The +6 steps are exactly the D1 events: E0 at 42->48 and 48->54, and E3 at 70->76 and 76->82. - Every D1 context so far is ..0110[1]11111 0 1^m with m >= 4. The D-run is 6 long and E reads the first 1 of 1^m. It would halt only if that 1^m were missing (1^6 0 0^inf). - Robustness check: start from the E3 anchor with the trailing 1^6 replaced by 1^k, for k = 3, 4, 5, 6, 7, 8, 9 (deepen2_dh2cfg.py + deepen_runcfg.c), and run 2.4e9 steps, through the E3 right-end burst. All 7 runs: no halt, exactly 2 D1 events, and hi shifted by exactly k-6. The parity of the 1-run does not matter. - E8 rebuilds the right end. In Quick_Sim the trailing 0 1^10 disappears in E8. At 4.069e13 the tape ends in ...1001 0010 (1010)^3 0^inf; at 4.30e13 it ends in ...0100 0101 1000 0^inf. The right end is not a "fixed block + growing 1^k" process. - D1 census for E5-E8: see item 6.

4. Invariant candidates tested, none closes. - Plain n-gram CPS (deepen2_ngcps_path.cpp, from #13's ngcps.cpp): abstract HALT for n = 2..12, 16, 18 and 20 (n = 14 gave up at 2e7 configurations). - The abstract counterexample glues a right-end 1-run into the bulk: a D-run over a 1-run writes 0^7, and the head then halts on 1011 0^7 1 E[0]. Such a run exists only at the right edge. - Parity-aware CPS (deepen2_ycps.cpp): the machine is run on y = t XOR parity, with the head carrying pos mod 2, so (10)^n and (01)^n are told apart. Abstract HALT for n = 3..14. The counterexample again uses long 1-runs with bulk context. - Static forbidden factor 0011 (the core of the D1 precursor 1 00 11): present in only 2 of 4,000 sampled snapshots to 4e9, both at step 2.57e8 near pos -368. But a write creates it 744,280 times to 4e9 (deepen2_f0011.c), mostly next to the head. It is not a static invariant. - Round 1's "bulk local language saturates" holds only to E4. New particle types appear in the tail in E7: first 4 3 1 1 1 at 7.06e12, about 2,300 cells from the right end, then ~25 more in E7 and many in E8. Over 29,643 left-edge visits there are 363 particle types (246 interior, 100 right-end, 17 left-edge), and the count is still growing. - So no regular/local closed language is in reach. A proof would need an invariant on particle sequences (order and phase), with a complete collision table.

5. Cryptid question. - No arithmetic branching is visible. The left part is exact (a' = 3a+6), the tail keeps fossil suffixes, and right-end processing may follow a mod-4 schedule. - The register values inside the particles are irregular, and the collision catalogue keeps growing. - Verdict: not a cryptid candidate on current evidence, but not decodable in the deepen budget either.

6. Near-halt (D1) census extended (direct simulation). - From blank to 3.3e11 steps (the start of E6; deepen2_longrun.c, log deepen2_out/longrun_3.3e11.txt): no halt. There are still exactly the 6 D1 events of round 1, none after step 2.497e9. hi = 84 from 2.636e9 on, and lo = -1,062,733 at the end. - E7 right-end touch: from the Quick_Sim visit at step 8,579,487,434,271, 3e10 cell-level steps (deepen2_qcfg.py + deepen2_cfgrun.c): no D1, no right-edge growth. - E8 rebuild, sequential: from the visit at 39,905,849,711,211, 4e11 cell-level steps (to 4.0306e13): no D1, no halt. The right edge grows +2, +4 and +2. - E8 rebuild, interval check: every Quick_Sim inter-visit interval in 3.9e13-4.32e13 that contains a far-right change was re-run at the cell level (deepen2_e8intervals.py + deepen2_ivrun.c). These are 72 intervals (8.6e9 steps); the 3 longer ones lie inside the sequential run. - Results: 0 D1, 0 halts, 0 mismatches (each interval ends exactly at the next Quick_Sim visit). - The right edge grows 12 times, always by +2 or +4 (32 cells in all, counted from the last nonzero cell at each interval start), never by the +6 of a D1. - So the E8 rebuild of the right end, which removed the 1^10 run, happened without a single near-halt. - Coverage: every change of the far-right end to 4.3e13 (the last 8 macro blocks in Quick_Sim) was re-run at the cell level, and a right-end D1 always changes that window (hi +6). So to 4.3e13 the only right-end D1 events are still the 6 of E0 and E3, and all of them read 1. - The bulk is watched at the cell level only to 3.3e11 and inside the E7/E8 windows; no bulk D1 has ever been seen there.

Assessment / recommendation: STUCK (stage deepen2). - Micro rules: exact. Epoch map of the left part: exact. - Tail: a fossil-processing particle system with a growing collision catalogue. The right end is rewritten in E0, E3, E4, E7 and E8 and was rebuilt without its 1-run in E8. - Halting is possible only through one local pattern, and only at the right end in practice. The safety evidence is simulation only: no halt to 4.31e13, and only 6 right-end near-halts, all in E0 and E3 (item 6). - Both cheap routes are closed: epoch induction (T -> T' needs the whole particle dynamics) and a regular closed language (CPS n <= 20, parity CPS n <= 14, saturation refuted). - A possible next route is multi-day: a particle-level accelerated simulator plus a collision table, then an invariant on particle sequences. First test the mod-4 right-end schedule to E11/E12, which needs faster acceleration than Quick_Sim gives past 4.3e13. - Priority call for Dennis: park #17, or fund that project.

Decision (2026-10-10)

Question: #17's cheap proof routes are closed: epoch induction is blocked on the tail, and no regular closed language exists at the sizes tried. Park it, or fund a multi-day particle-level simulator plus an invariant on particle sequences? Answer: park (Park #17 as STUCK). Dennis: go with all recommendations (2026-10-10). Parked by Dennis 2026-10-10 (decision queue: park).