1RB1RA_1LC0RE_1LE0LD_0LB1LB_1RA0LF_1LD---
Status: STUCK (seams stage 2026-10-10: seam alphabet still growing at 1e10; confidence low) Label: W4-8 (740 list line 644; 778 list line 680) Class guess (agent / Dennis): fossil bouncer over a 01001111 sea (sheet: Unknown) / - Spreadsheet notes / Discord thread: Results tab "Unknown", no status, no notes. No Discord export mentions it. Sibling 61 is on mxdys's "50 random holdouts" tab (Category 2), with no status. Viewer: https://bbchallenge.org/1RB1RA_1LC0RE_1LE0LD_0LB1LB_1RA0LF_1LD---
Pre-checks
- Byte-exact match on data/holdouts/BB6_holdouts_740.txt (line 644). The string is on every older list back to 2024-07-12.
- No claim: not in data/discord/*.txt; the sheet has it only on Results (Unknown, empty status) and on Classifications under "Unknown".
- Upstream:
solved_indexhas no entry for this string or its canonical form. The only hits for the table are Eqv_v2.v TM2046 (start-B table <-> 61), which is an equivalence, not a decision.
Family (canon up to state renaming + mirror, all 6 starts)
| start | list entry | note |
|---|---|---|
| A | 644 (this machine) | |
| B | - | = TM2046's tm 1LB0RC_1LC0LE_1RD0LF_1RA1RD_0LA1LA_1LE---, Eqv_v2: halts iff 61 halts |
| C | - | not on any list (different dynamics: 3440 ones in 2e5 steps) |
| D | - | not on any list |
| E | 61 1RB0LF_1RC1RB_1LD0RA_1LA0LE_0LC1LC_1LE--- |
same 01001111 sea and seams at 1e8; no halt to 1e9 (span -31140..1107) |
| F | 704 1RB---_0RC1RC_1RD0LE_1RE0RB_1LF0RA_1LC1LF |
mirrored (sea word 11110010 = reverse of u); no halt to 1e9 |
Siblings: 61, 704. They build the same sea but run different orbits, so a proof covers them only if it is a closed-language argument (or is re-run from their starts).
Observation
- Halting: F1 is the only undefined cell. F is entered only by E1 (0LF), and E reads a 1 with a 1 on its left only after C0 (1LE). So the machine halts iff C reads 0 with 11 on its left:
11 0 <C-> halt in 3 steps (rule H, 40/40 random contexts). - No halt to 2e9 (C sim to 1e9; record tracker to 2e9). At 1e9: cells -30659..1159, 22,003 ones. The left edge grows like t^0.5; the right edge grows only in bursts (hi 566 at 9.4e7, 866 at 1.44e8, 878 until 2.66e8, 1057 at 3.9e8, 1159 at 1e9, 1219 at 1.45e9).
- The sea. Almost the whole tape is u = 01001111 in some rotation (10100111, 11010011, ... are the same cyclic word). Between u-runs sit short seams, e.g.
(110100)^2 1^6,(010011111)^2(one extra 1),0100 1^k,1 (10100)^2,(10100111111)^2,(01001)^2, plus long 1-runs (deposits). - One bounce per cycle (cycle = from one left record in state B to the next). The head sweeps right through the sea at 20 steps per 8-cell block, turns at a wall, and sweeps back at 40 steps per block (Fig: cycle_Q). It never reaches the right end in a quiet epoch; everything right of the wall is fossil (untouched).
- Per cycle: the left edge moves 3 cells (LT), the left reservoir u^a gains one block, the active sea moves -3 cells (= +5 mod 8), seams ride right at +5 cells per cycle, and the wall eats one block from its left and leaves
111behind, so the deposit 1^c grows by 3 and the wall walks left 3 cells per cycle. - Segment map (img/segmap_1e9.png, img/segmap_2e7.png; scripts/segmap.py): every cell is classified as sea / 1-run / (10)-run / other, bright if it changed since the previous cycle. It shows the light-blue active sea from the left edge to the green turning point, grey wedges of 1-deposits growing left behind the wall, dark-blue fossil u-runs on the right, and red seams riding diagonally right into the wall. When a seam reaches the wall, the deposit is rewritten as a fossil u-run and the wall resumes.
- Reservoir freezes. At 22 cycles to 2e9 the left reservoir u^a stops growing and becomes a new fixed segment, behind a new seam, and a fresh u^a starts at the left edge. Sizes at the freeze: 9, 20, 12, 41, 62, 45, 61, 59, 156, 74, 402, 11, 606, 678, 29, 752, 641, 1434, 921, 2483, 29, 2535 (steps 9431 ... 1.15e9). The trigger seems to be the head returning from a wall event in a different phase and rewriting seams all the way left in one pass (e.g. cycles 3723-3748), but I have not pinned it down.
- Distinct seam words between u-runs (compress tokens, 1-runs abstracted; a crude count): 170 by 1e6, 375 by 1e7, 526 by 1e8, 800 by 1e9, 829 by 2e9.
Candidate rules (scripts/validate_rules.py, work/validate_rules.out; two seeds, 40 instances each)
| rule | from | to | steps | validated |
|---|---|---|---|---|
| RS | 111 A> (01001111)^n |
111 (01110111)^n A> |
20n | 80/80 (random L, R, n <= 40) |
| LS | (01110111)^n 0 <B |
0 <B (01001111)^n |
40n | 80/80 |
| LT | 0^inf <B |
0^inf 111 A> |
5 | 80/80 |
| RO | A> 1^n |
1^n A> |
n | 80/80 |
| Q | 0^inf <C (10100111)^a 1 (110100)^2 1^6 (10100111)^d (010011111)^2 (11010011)^e (10100111)^2 0100 1^10 (01001111)^b 1 (10100)^2 1^c (10100111111)^2 (10100111)^f 0100 1^5 0^inf |
same with a+1, b-1, c+3 | 60(a+b+d+e)+595 | 80/80 random (a,b,c,d,e,f >= 1, independent); 247/247 consecutive cycles from blank (scripts/q_history.py) |
| H | 11 0 <C |
halt | 3 | 40/40 |
Notes: - RS converts the blocks in place to (0111)^2, which is 4-periodic. LS reads them back 4 cells off, so a full pass moves the sea by -3 cells (= +5 mod 8). The extra 4 cells at the left come from the seam next to the reservoir; that is why a gains a whole block per cycle although the edge moves only 3. - In Q the deposit 1^c and everything right of it are never read (c and f do not enter the step count). The Q epoch from blank runs from (a,b,c) = (9,247,2) at step 94,875,591 to (256,0,743) at 110,287,156 and ends when the reservoir b is used up. This is the scout's rulefit rule C0(a,-a+407,3a-32) -> C0(a+1,-a+406,3a-29) with the constants freed. - A first guess "LE: 0^inf 0111 0 0^inf <B 01001111" was wrong (0/40): the left end of the return needs the seam's extra 4 cells. It was dropped.
Template comparison
No proved machine is within 3 transitions in any start (scout-templates; critic re-run at upstream HEAD 9cf9e88). The nearest proof by class is Bouncer_v2.v TM1 (1RB0LB_1RC0LC_1LD1RF_---1LE_0RC1LA_0RB1RA). It proves S1 n -->+ S1 (1+n) with one es' after init (4,760,139 steps): the tape becomes a fixed list of words with two blocks repeated (1+n) times. Our rule Q is the same shape (one big step, exponents +1/-1/+3), but it only holds inside one epoch: new seams and segments keep appearing (22 freezes), so no single S1 n exists. Applies: no. Bouncer_v1/v3/v4 have the same one-skeleton structure.
Cryptid check (ground rule 6)
Not flagged. No Collatz-like or parity branching has been found. But the freeze sizes are irregular and the epoch grammar is open, so pseudo-random control cannot be ruled out yet. If the seam-alphabet stage shows that the freezes depend on arithmetic of the reservoir sizes, re-flag as CRYPTID_CANDIDATE.
Proof idea (if funded)
A closed tape language: u-runs of any length separated by seams from a finite set S, plus the wall and deposit forms. Show one cycle maps the language into itself and that no word in it contains the halting pattern 11 0 <C at the head. RS, LS, LT, RO and Q are the inside-epoch lemmas; the seam collisions (seam meets wall, b = 0, freeze) are the finite case table. This is CTL-like, so a mechanised closed-set search over phase-tracked sea tokens is the first experiment.
Checkpoint A (Dennis)
(pending: card.html, decision.json)
Files
- scripts/segmap.py: segment map (work/seg_1e9.log; img/segmap_1e9.png, img/segmap_2e7.png)
- scripts/validate_rules.py, scripts/fit_q_steps.py, scripts/q_history.py (work/q_history.json)
- work/track_2e9.txt: every new skeleton at B-records (and every 500th), to 1.91e9
- work/reach_1e9.txt: turning point per cycle (rightmost cell changed since the previous left record), to 1e9
Informal proof
Not started (confidence low).
Formalization log
-
Outcome
Open.
Decision (2026-10-11)
Question: Fund one 2 h stage to map the seam words and test a closed tape language for this table, or park W4-8 as STUCK at observe? Answer: seams (One stage (at most 2 h): seam alphabet and closed-language test). Dennis: go with recommendations (2026-10-11).
Funded stage (2026-10-10, seams)
Scope (decision answer seams): seam extractor on the phase-tracked sea, distinct seam words and seam/wall collisions to 1e10, saturation test; closed-language test only if the set saturates. Stop rule: still growing at 1e10, or not closed in 2 h, means park. The stop rule fired: every seam count is still growing at 1e10.
Extractor. scripts/seamscan.c (direct C simulation; a cycle starts at each left record in state C, the start form of rule Q). At every cycle start it parses the whole span losslessly into tokens: U<len>r<rot> = maximal u-run (>= 24 cells, phase = rotation of its first cell), D<len> = 1-run >= 12, S<bits> = seam material. Output: work/tokens_1e10.txt (33,051 cycles, one line each, 6.7 MB). scripts/seamtok.py decodes it; verify re-simulates with tools/sim.py: 3,197/3,197 cycles to 1e8 identical. The 1e10 end state (lo -99,184, hi 1,687, no halt) matches tools/sim/tmsim.
Saturation test (all to 1e10; scripts/seamstats.py, seamabs.py, seamelem.py, collisions.py; files work/seams_*.txt, work/collisions.txt). A seam word is (left neighbour with its phase at the boundary, bits, right neighbour with its phase).
| count | 1e6 | 1e7 | 1e8 | 1e9 | 1e10 |
|---|---|---|---|---|---|
| cycles | 317 | 941 | 3,197 | 10,211 | 33,051 |
| distinct seam words, verbatim | 178 | 366 | 513 | 783 | 1,028 |
| same, 1-runs >= 6 and (10)-runs >= 4 reps abstracted | 170 | 331 | 449 | 662 | 844 |
| same, also u-pieces >= 16 cells inside seams abstracted | 170 | 335 | 454 | 669 | 860 |
| elementary pieces (split at u >= 8 cells, 1-runs >= 6, (10)-runs >= 8 cells; longest piece 17 cells) | 114 | 160 | 182 | 226 | 270 |
| collision cycles (abstracted skeleton or wall token changes) | 244 | 553 | 877 | 1,797 | 2,785 |
| distinct collision types (wall token + neighbours, abstracted) | 152 | 301 | 416 | 635 | 842 |
Every measure grows by a roughly constant amount per decade of steps (elementary pieces +44 per decade, 1e8 to 1e10). The pieces seen after 1e9 are short (<= 11 cells) phase variants such as u0 [111110110] u4 or I [010100] I, so the alphabet is not closing. Longest quiet stretch: 5,612 cycles.
New structure seen in the token view.
- The tape is short in tokens (about 10-15 at any time): left reservoir u^a, seam, the run u^b that the wall eats, the wall seam 1 (10100)^2, deposit 1^c, then older segments.
- The right part is not just fossils. Deposits are later rewritten through long (10)-runs (up to (10)^8429 inside one seam) into u-runs of about c/8 blocks, e.g. 1^16863 -> (10)^8429 -> u^2108 at cycles 28,990-28,993. Of 32 deposits >= 300 that disappear, the replacement differs: a u-run in rotation 4, 5 or 7, a (10)-run, or a merge with a neighbouring deposit, depending on c mod 8 and on the local context. Fig: img/segmap_1e10_right.png (rendered from the token file).
- So the epoch-level process transforms segment lengths, roughly c = 3 x (blocks eaten) and then c -> c/8 blocks, with residue-dependent branches. I did not test whether this map is Collatz-like. Not flagged as cryptid, but this is the open risk.
Closure evidence that points the other way (scripts/fuzz_lengths.py, work/fuzz_lengths.out; seed 7). I took real cycle-start configurations (cycles 300-8,000) and re-drew the run lengths, then simulated each for 5e7 steps: - V0 unchanged: 0/300 halt. - V1 u block counts 3..60 with end phases kept, deposits with c mod 8 kept, (10)-runs with parity kept: 0/300 halt. - V2 deposits and (10)-runs free: 0/300 halt. - V3 u-run lengths free in cells as well, so the phases change: 0/300 halt.
The skeleton language with free exponents does not lead to a halt (1,200 instances). Non-halting does not seem to rest on the length arithmetic. The obstacle is describing the language, not a fragile orbit.
Near-halt census (scripts/census.c, census_b.c; work/census_1e10.txt, work/census_b_1e9.txt). C is entered only by B0 (1LC), and halting needs C to read 0 with 11 on its left. From blank to 1e10, C reads 0 33,051 times, exactly once per cycle and always at the blank left edge. It never reads 0 inside the tape. To 1e9, B reads 0 66.7M times inside the tape and always has a 1 on its left: 50.2M entered from A0 (which writes that 1 itself), and 16.6M entered moving left from D (16,588,734 with 11 on the left, 9 with 01). So non-halting is equivalent to one local invariant: D never steps left onto 0 0 inside the tape (00 <B occurs only at the blank left edge). A closed language needs to carry only that.
Still open. - No finite seam alphabet. The phase-tracked count, both abstractions, the elementary split and the collision types all still grow at 1e10. - No closed language was built (the funded scope did not reach it). - The epoch-level map on segment lengths (deposit -> (10)-run -> u-run, residue branches) is not modelled.
Outcome. STUCK, parked by the funded stop rule; confidence stays low. A possible next step, which needs Dennis: a native closed-language search for the single invariant "no 00 <B inside" over phase-tracked tokens (u-phase, 1-runs, (10)-runs, short pieces), not seeded from the growing orbit alphabet (new decision.json).
Files: scripts/seamscan.c, seamtok.py, epochs.py, seamstats.py, seamabs.py, seamelem.py, collisions.py, segmap_tokens.py, fuzz_lengths.py, census.c, census_b.c; work/tokens_1e10.txt, epochs_1e10.txt, seams_growth.txt, seams_first.txt, seams_wall.txt, seams_abs.txt, seams_elem.txt, collisions.txt, fuzz_lengths.out, census_1e10.txt, census_b_1e9.txt, tmsim_1e10_end.json, segmap_1e10_full.png; img/segmap_1e10_right.png.
Decision (2026-10-12)
Question: Keep W4-8 parked, or fund one 2 h native search for a closed tape language that only has to forbid 00 <B inside the tape? Answer: park (Keep parked (STUCK)). Dennis: apply recommendations (2026-10-12).