/machines/1RB1LE_0RC1RC_0RD0RB_1RE0RF_1LA0LE_---1RB/notes.md · raw

1RB1LE_0RC1RC_0RD0RB_1RE0RF_1LA0LE_---1RB

Status: CHECKPOINT_A Class guess (agent / Dennis): fractal call-stack bouncer, FractalType7/TM20 shape (sheet: Chaotic Fractal Type 1) / _ Spreadsheet notes / Discord thread: Results tab "Appears to be solvable"; Level 0 tab "Looks like a solvable fractal". No status, no Done By, no link, not struck, no xlsx comment. Not in data/discord/*.txt. Nobody visibly on it. Viewer: https://bbchallenge.org/1RB1LE_0RC1RC_0RD0RB_1RE0RF_1LA0LE_---1RB

Observation

Diagrams (img/): state_ER_3e6.png (best), records_1e6.png, blaze_1e9.png, epoch_end_site.png (from the step-15000 config in img/epoch_end_start_config.txt, rendered with --as-site --steps 9000 --ox 0.85, so cells −144..255), default_site.png, viewer.html. Every card diagram's labels (start, rows, window, legend, style) are in observe.json → diagrams.
state_ER_3e6.png rows are entries into E moving right: 1,402 of the 1,937 are right-edge turnarounds, 535 are inside the tape. records_1e6.png stops at its 2,400-row cap at step 999,391.
1e9 steps (C core): no halt, span 75,124 (left edge frozen at -16 from step 4,428), 59,751 nonzeros, t ~ 0.18 span^2.
qsim: 1.99e13 steps in 129 s, 8.5M nonzeros, no halt. 305 prover rules, all one-off whole-tape Diff rules (not reusable).
rulefit: tests pass (fast suite 23/23); fit found no validated rule (time caps, 4 fits failed), see rulefit_out.txt. Rules below are hand-fitted.
Top skeleton (right end): 0^inf L 1^a 001 10^b 1^2 01^c E> 0^inf. History in observe.json (24 rows to step 8.3e8, all consistent with the YY rule).
Epoch starts (b resets, a=2..4, c=2..5): step 1,237 b=11; 4,853 b=30; 23,891 b=75; 114,023 b=225; 877,799 b=676; 9.90e6 b=1,783; 5.69e7 b=5,351; 5.78e8 b=13,413. Ratio x2.5 or x3, not affine.

Candidate rules

All validated by direct simulation from concrete configs (random left context L, random right context R; small, medium, large and every residue class mod 2 and mod 3). Scripts: scripts/validate.py.

Y(a,b,c) := L 1^a 001 10^b 1^2 01^c E> 0^d R        X(a,b,c) := L 1^a 001 10^b 0 01^c E> 0^d R
XY   X(a,b,c) 0^(d+3)      --> Y(a,b,c+1) 0^d          4c+5         87/87
YX   Y(a,b+1,c) 0^(d+3)    --> X(a+2,b,c+2) 0^d        4b+4c+17     85/85
YY   Y(a,b+1,c) 0^(d+6)    --> Y(a+2,b,c+3) 0^d        4b+8c+30     87/87
XY1  X(a,b,c+1) E> 1^(d+1) --> Y(a,b,c+1) E> 1^d       4c+7         87/87   (R starts with 0)
YX1  Y(a,b+1,c) E> 1^(d+1) --> X(a+2,b,c+1) E> 1^d     4b+4c+15     83/83
Ret  L0 1^a 001 1^2 01^c E> 0^(d+1) R --> L0 <E 0^(a+1) 1100 1^(2c+1) 0^d R    a+2c+14   85/85  (L0 ends in 0)

Open (not yet rules): what happens when a zero gap ends with leftover 0, 1 or 2 (three different call paths, probed in scripts/probe.py style runs), and the epoch-level map. In the run, gap residues mod 3 vary (81 runs: 1 -> 41, 2 -> 23, 0 -> 17), unlike TM20 where everything stays 0 mod 3.

Template check: FractalType7v4.v TM20 1RB0LF_1RC0RA_0RD0RB_1LE0RF_1LB0LE_1LE--- is 7 transitions away (A1 B0 B1 D0 E0 F0 F1), no relabel or mirror closer; nearest in FractalType7v2/v3 is 8. Its S1 + Inc does not transfer (0/20; our machine halts within 6 steps from S1). Verdict: partly (same architecture, new local rules). scripts/tmpl.py.

Cryptid check: no Collatz-style parity map found; the structure is a deterministic recursion with mod-3 cases. Not flagged.

Checkpoint A (Dennis)

Informal proof

Formalization log

Outcome

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/state_ER_3e6.png, Fig 2 = img/records_1e6.png, Fig 3 = img/blaze_1e9.png, Fig 4 = img/epoch_end_site.png, Fig 5 = img/default_site.png (Figs 1-3 primary). - Mechanism, full observer version: - Inner loop Y(a,b,c) = 1^a 001 (10)^b 11 (01)^c E>: each round a+2, b-1, c+3, eats 6 blank cells. - When b hits 0, E wipes the 1^a block and walks left (Return), leaving 0^(a+1) 1100 1^(2c+1). - The level to the left resumes the same loop: eats zeros 3 per half-round, then ones 1 per half-round. - When its gap runs out it calls the level to its right again: a call stack, so each epoch replays shrunken copies. - Top epochs b = 11, 30, 75, 225, 676, 1783, 5351, 13413 (x2.5 or x3); no halt to 2e13 steps (qsim). - Checkpoint questions before the rewrite (some were decisions, not questions about a figure): - state_ER_3e6.png: do the small staircases left of each wide white band look like shrunken copies of the earlier picture (a call-stack replay)? - records_1e6.png: does each white triangle end exactly where the gray (10)^b block runs out, before the next ~3x bigger one starts? - OK to spend the next stage deriving the 3 mod-3 call paths (TM20 Column-style) before any Rocq work?

Deepen pass (overnight 2026-10-10)

Verdict: confidence med (unchanged), recommend more_observation. Not a cryptid so far. Data in deepen.json. Scripts (new): scripts/deepen_validate.py (+.txt), scripts/deepen_sigs.py (+deepen_sigs_1e9.txt), scripts/deepen_irregular.py.

Picture (TM20-shaped call stack, with residue branches). A frame Y/X(a,b,c) eats the tape on its right. That tape is a list of columns 0^g 1100 1^m, each left behind by an earlier Return. The zero-gap leftover mod 3 picks the branch: - leftover 1: the frame swallows 01100, then eats the ones; - leftover 0 or 2: the frame suspends as X/Y plus one separator 0, and the ones block becomes a new frame (a call); - b = 0: Return. The frame becomes a column 0^(a+1) 1100 1^(2c±1), and its caller resumes on the returned zeros.

F 0 <E w is the same machine configuration as F E> 0 w (E on the separator cell), so the resume needs no rule of its own.

Y(a,b,c) := 1^a 001 10^b 1^2 01^c      X(a,b,c) := 1^a 001 10^b 0 01^c      (new rules; all from random L/R contexts)
Gap1Y     L Y(a,b+1,c) E> 0 1100 R              --> L X(a+2,b,c+3) E> R                          62/62
Gap1X     L X(a,b,c) E> 0 1100 R                --> L Y(a,b,c+2) E> R                            62/62
RetOnes   L0 Y(a,0,c+1) E> 1^(m+1) R0           --> L0 <E 0^(a+1) 1100 1^(2c+1) 0^2 1^m R0       62/62  (L0 ends 0, R0 starts 0)
CallYodd  L Y(a,b+1,c) E> 0^2 1^(2k+1) 0^6 R    --> L X(a+2,b,c) 0 X(3,k,1) E> R                 81/81
CallXodd  L X(a,b,c+1) E> 0^2 1^(2k+1) 0^6 R    --> L Y(a,b,c) 0 X(3,k,1) E> R                   75/75
CallYeven L Y(a,b+1,c) E> 0^2 1^(2k+2) 0^9 R    --> L X(a+2,b,c) 0 X(3,k-1,4) E> R               75/75 (k>=2)
CallXeven L X(a,b,c+1) E> 0^2 1^(2k+2) 0^9 R    --> L Y(a,b,c) 0 X(3,k-1,4) E> R                 76/76
Gap leftover 0: E> 1100 1^m = YX1 then XY1 (existing rules), leaving E> 0^2 1^m, the call case.

Census (deepen_sigs.py 1e9): - 46,374 E:R-to-E:R transitions, 72 distinct abstract signatures. - New signatures per epoch: 31, 18, 11, 2, 3, 5, 1, 1, so the set is nearly closed. - XY/YX/XY1/YX1 cover 96.3% of transitions. The other 3.7% fall into 68 rare signatures.

Real run 18413-19401 shows the column list: the tail Y(62,0,92) returns 0^63 1100 1^185, then a left frame returns 0^13 1100 1^35 0^7 1100 1^185.

The minimum head position per epoch is -16, 56, 142, 242, 394, so the frozen prefix keeps growing. TM20, by contrast, always returns to a fixed root.

Still open (these are what block 'high'): 1. Replay entry. A Return that reaches a bare block (left neighbour 1001^2 10^n, i.e. X(2,n,0) with no separator) starts a cascade of small frames X(0,1,1), X(2,0,5), ... carved out of (10)^n. Most of the rare signatures come from this. Reproduce with python3 scripts/deepen_irregular.py --from '0^inf 1 0 1 0 0 1^2 001 10^6 0 1^9 001 1^2 01^7 E> 0^30 1^3 0 1^2 0^inf' 3000. 2. Transit callees. While a callee has a < 3, its sweep turns the caller's (01)^c into (10)^(c+1) for one round. The call rules above assume 6 or 9 zeros of room. Calls that meet the next column sooner (the epoch-6/7 signatures) are not written yet. 3. Leftover 2 at a 1100 column (E> 0^2 1100 1^m): the callee comes out with a=0 in transit form. Seen, not validated. 4. Epoch-start sweep. 0^3 1^2 01^c E> 1^m 0^inf makes one left sweep and one long right sweep, turning the ones into the next tail's (10)^b (steps 23352 -> 23570 -> X(2,75,1) at 23882). 5. Invariant. Needed: a TM20-style Good grammar over (frozen prefix | suspended frames + separators | columns | tail), with case splits on gap mod 3 and parity, plus inequalities. The epoch map is b_new = c_old minus the ones eaten by leftover-1 callers (x2.5 or x3), so it is not affine. 6. Non-halting argument. Halting needs the right sweep to read B> x 0 1 0. No validated rule produces it, but the rare transitions have not been checked against it.

Next stage: write rules for 1-4 with deepen_irregular.py, aiming at a signature census with zero unexplained transitions to 1e9. Then build an abstract column/frame simulator, check it against the real run, and draft the Good-style grammar.

Deepen pass 2

Verdict: confidence med on the mechanism, recommend stuck. Not flagged as a cryptid. Data in deepen.json (stage deepen2). New scripts: scripts/deepen2_validate.py (+.txt), deepen2_census.py (+_1e9.txt), deepen2_fmargin.py (+_1e9.txt), deepen2_danger.py (+_small.txt, _medium.txt), deepen2_perturb.py (+.txt), deepen2_stack.py (stack parser used by the others).

What round 2 changes. Round 1 split calls only by the parity of the called block. Round 2 shows the room g after the block decides as much. Rooms below 6 give transit callees, a call on 11 gives a phase-shifted callee, and when that callee returns, the caller faces a fixed 1^6 block. These produce column shapes outside the round-1 grammar. One shape halts.

Ya = Y(a,b+1,c)   Xa = X(a,b,c)   Xc = X(a,b,c+1)          (random L/R contexts; 731/731 instances in total)
Call4Y     L Ya E> 0^2 1^(2k+1) 0^4 1100 R        --> L X(a+2,b,c) 0 X(3,k,2) E> R              83/83
Call4X     L Xc E> 0^2 1^(2k+1) 0^4 1100 R        --> L Y(a,b,c) 0 X(3,k,2) E> R                67/67
Call2Xodd  L Xa E> 0^2 1^2 0^2 1^(2k+1) 0^6 R     --> L Y(a,b,c) 0 010 X(2,k,1) E> R            76/76
Call2Yodd  L Ya E> 0^2 1^2 0^2 1^(2k+1) 0^6 R     --> L X(a+2,b,c+1) 0 010 X(2,k,1) E> R        82/82
Call2Xeven L Xa E> 0^2 1^2 0^2 1^(2k+2) 0^3 R     --> L Y(a,b,c) 0 010 X(0,k,1) E> R            72/72
Call2Yeven L Ya E> 0^2 1^2 0^2 1^(2k+2) 0^3 R     --> L X(a+2,b,c+1) 0 010 X(0,k,1) E> R        78/78
ResumeTY   L Ya 0 01 E> 0^(u+4) 1100 R            --> L X(a+2,b,c+1) E> 1^6 0^u 1100 R          71/71 (u>=1)
HaltRoom2Y L Ya E> 0^2 1^(2k+1) 0^2 1100 R        --> HALT                                      69/69
HaltRoom2X L Xc E> 0^2 1^(2k+1) 0^2 1100 R        --> HALT                                      71/71
HaltOne    L Ya E> 0^2 1 0^2 R                     --> HALT                                      62/62

Call2 covers round-1 gap 3 (leftover 2 at a 1100 column). The call on 11 passes straight into the next block. The round-1 "bare block" neighbours are the 0 010 prefixes it leaves.
ResumeTY covers part of round-1 gap 1 (replay entry). For u = 4 and u = 3 the 1100 merges instead (1^8 0^2, 1^4 0^2 1 0^2). Not stated.
Callee birth by hand trace: s 1 0 D> 1^(2k+1) 0^6 becomes X(3,k,1) in two sweeps; the first sweep leaves 1 001 (10)^(k-1) 101 E>. The callee's 1^3 is the caller's last 1, the cell after it, and the first cell of the block.

Halting condition. The machine halts exactly when a right sweep has C on 0, then D on 1, then F on 0. To 1e9 there are 23,450 D-on-1 events, and F reads 1 in every one. The ones run F lands on has length 1, 3, 4, 5, 6, 7 or ≥9. Its 23 local shapes are the same at 1e8 and 1e9.

Fragility (why stuck). - Small sizes halt often. Caller X/Y(20,16,5) E> 0^2 1^n 0^2 1^m 0^g 1100 1^5 with n 2-12, m 1-8, g 2-9 or 30: - 640 of 1584 halt before the caller returns; - halts occur in every class of n mod 2, m mod 2 and g mod 3. - Medium sizes do not. With n 31-34, m 60-62, g 20-25, 0 of 144 halt within 2e7 steps. - The real run comes close. At step 458654411 (epoch 7) it makes exactly this kind of call with room 2: Y(14,10,18) E> 0^2 1^129 0^2 1^570 0^179 1100 .... Changing 129, 570 or 179 by -6..+6 never halts within 5e8 steps (36 runs). - So the danger is confined to small blocks. A proof has to show that small blocks appear only at the low recursion levels, in fixed shapes.

The census is not closed. Round 1 called it nearly closed, but that came from collapsing exponents ≥3 to N. - To 1e9 there are 46,375 E:R moments. 45,716 parse as a standard frame (40 front classes); 659 are transit forms (86 local shapes). - 2 parsed classes and 7 transit classes first appear in epoch 7. - The root at each epoch end is itself transit-shaped: 1^a 001 (10)^b 1 with no separator. The root also drifts right (min head position −16, 56, 142, 242, 394), so TM20's fixed LO/LE root does not carry over.

Still open: 1. Births with room 3 or 5. These include merges like 1^9 0^3 1^7 becoming X(5,8,1). 2. The X-caller version of ResumeTY, and returns of X(0,k,1) callees. 3. The epoch-start sweep and the drifting root. 4. A column grammar that includes 1^6 blocks, 0^2 gaps between ones blocks and 010 prefixes, plus inequalities that keep every call away from the halting patterns. 5. A non-halting argument.

What would unstick it: - an abstract simulator over run-length words, driven by the validated rules and checked against the real run at every E:R moment, so the full transition list is generated automatically rather than by hand; - or a decider-style closed-language search with larger parameters; - or Dennis decides this machine is not worth that effort.

Decision (2026-10-10)

Question: Park #20 (it stays STUCK), or fund one more stage to build an abstract run-length simulator that generates its full call-stack rule table? Answer: park (Park: keep STUCK, no more agent time now). Dennis: go with all recommendations (2026-10-10). Parked by Dennis 2026-10-10 (decision queue: park).