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

W7-4 · 1RB0LD_1RC0RF_0LD0LE_1RF1LC_0LB1LE_0RA--- (740 line 82; table family 464, 722)

Status: CHECKPOINT_A (observe at table level, 2026-10-14). Confidence on the mechanism: high. Class: sheet "Skelet 1-like Class 1". Ours: an exact base-4 counter whose digits are 10-regions in a sea of 100 words, with births at the right end and a left wall that eats digits. Viewer: https://bbchallenge.org/1RB0LD_1RC0RF_0LD0LE_1RF1LC_0LB1LE_0RA---

Checks

Halting condition

F1 is the only undefined transition. F is entered by B1 (0RF) and D0 (1RF). So a halt needs B> 1 1 (B reads 1, then F reads 1) or D> 0 1. Never seen.

Mechanism (exact)

Notation: W = 100, V = 10. A digit is D(m,p) = X V^m Y with X0 = 10, X1 = 11, Y0 = 10, Y1 = 00; its phase is p = 2x + y (0: 10..10, 1: 10..00, 2: 11..10, 3: 11..00). In real runs m is always even (0, 2, 4, 6, 8). A C-record is the moment the head enters a fresh cell at the right end in state C; there the tape is

0^inf <wall> W^a D(m1,p1) W^f1 ... D(mk,pk) W^c 11 C> 0^inf

(scripts/macro.py decodes any tape into this form via the gaps between 1s.)

  1. Sweep = increment (R1, R2). From a C-record the head runs left to the first digit that does not wrap and back. Every digit it passes goes p -> p+1 (3 -> 0 wraps and carries on). A digit going 1->2 or 3->0 shifts one W left (takes 1 from its left field, gives 1 to its right field). The right field gains 1 W per sweep. Steps: 8 per W crossed, 5m+12 per wrapping digit, 11 (p = 0, 2) or 5m+23 (p = 1) at the stopping digit (R3). Validated: scripts/rules.py 400/400 and 300/300 random sweeps; the step formula is exact (matches below).
  2. J invariant and merges. For an interior field f between a left digit of phase pL and a right digit of phase pR, J = f + 2pL + floor(pR/2) - floor(pL/2) (mod 3) is unchanged by every increment. Check: pR 0->1 and 2->3 change nothing; pR 1->2 takes 1 from f and raises floor(pR/2) by 1; pR 3->0 takes 1 and lowers floor(pR/2) by 1 (-2), and the carry moves pL by one step, which adds +2 (mod 3) in each of its four cases (0->1: +2; 1->2: +2-1+1; 2->3: +2; 3->0: -6+1+1). In real runs J = 0 on 1,456/1,456 fields (scripts/jcheck.py on 300 snapshots to 3e9). With J = 0 a field reaches 0 only when the next wrap glues Y0 X0 = 10 10, i.e. the two digits become one D(m+m'+2, 2xL + yR); a negative field never happens. scripts/jtest.py: 1,986/1,986 sweeps on random J-valid configurations with fields 0..18 and glued digits match the counter rule exactly.
  3. Overflow (O1, O2) and births. When every digit is at phase 3 the carry reaches the far-left field. [10100] W^a -> [] W^a (1 sweep, right field +2), [] W^a -> [10100] W^(a-2) with either a new D(0,0) born at the right end or 2 extra W there (2 sweeps). scripts/overflow_check.py: 300/300 (O1 172, O2 birth 57, O2 no-birth 71). Counting the top digit's own shift, the far-left field loses 4 W per two overflows, alternating [] and [10100] (far run: 773, 770, 769, 766, ...).
  4. The wall eats the top digit. When the far-left field is gone, the wall eats the top digit from its left end, one remnant per overflow, while its Y bit keeps toggling: 11(10)^k{10,00} -> 1(10)^k{10,00} -> (10)^k{10,00} -> 1(10)^(k-2){..} -> ... -> 110100 -> [], then the field after it becomes the new far-left field. Entry cases seen: [] W^1 (remnant 11..), [] W^3 (remnant 10100.., then 1011..), [] W^2, [10100] W^0..3. All distinct clean walls in the three runs to 1e14: 35 strings, all of these shapes (work/far_*.jsonl). scripts/wall_probe.py: 80/80 small-field families (wall x a in 0..4 x m in 0..6 x 2 field sizes, including collisions where the remnant runs into the next digit) return to a clean wall; none halts.
  5. Self-similar sizes. At overflows the fields are multiples of 3·2^k (1536, 6144, 24576, 98304, 393216, ...). The right field resets at each birth; digit count stays 6-10.

All three starts (start-parametric)

At the first C-record after 20,000 steps: - 82 (A): [] W^1 D0.0 W^6 D0.0 W^73 at step 20,576 - 464 (B): [10100] W^9 D0.3 W^7 D0.0 W^67 at step 20,393 - 722 (D): [10100] W^11 D0.3 W^7 D0.0 W^67 at step 20,541

Same language, different far-left field (the "far-end junk" of the plan). One closed-language argument covers all three; each start needs only its own entry lemma (blank -> L in about 20,600 steps).

Simulation evidence

Cryptid check

Not a cryptid on the evidence. Every event rule is affine in the field sizes and digit sizes; the only residues are fixed moduli (J mod 3, the parity of m, the far-left field mod 4 picking the wall entry case), and each branch has been run and stays in the language. No x(p/q) maps, no growing-residue branching; the sizes are powers of two times 3. Unlike K42, merges cannot "glue" badly, because J = 0 is invariant.

Template check

Route and next step

Stage 1 is go as far as it goes: the interior counter is closed and exact. The open part is the wall: write its case table as affine rules (entry cases a = 0..3 for both wall forms, the remnant families with general k, the collision chains), then run an exhaustive closure check of the candidate language L = wall grammar · W^a · (D(even m, p) W^f with J = 0)* · W^c 11 C> over small parameters. If closed, proof.md is one closed-language argument plus three entry lemmas. A regular-language certificate may also exist (everything is mod 2 / mod 3 / finite prefixes), which Astra's certificate package could check.

Attempts

Files