W6-2 · 1RB0RD_1LC0LE_0RA0LB_1RC1RF_1LB1RD_0RC--- (740 line 96)

Observe stage, 2026-10-14 (Wave 6). Sheet class: Unknown. Claimed in coord/claims.tsv (Wave 6 W6-2).

Checks

• Byte-exact on data/holdouts/BB6_holdouts_740.txt, line 96.
• No claim: the sheet rows (2026-10-09 classifications and results) give only the class Unknown, with empty Status, Notes, Sources and Done By. Nothing in data/discord/*.txt.
• Not in upstream busycoq BB6 at cdaf693 except as an Eqv_v2 mention (TM1194, TM1468, TM1778: equivalences, not verdicts).
• Siblings on the 740 list: none. Canon (renaming + mirror) over all 6 starts: only start A is on the list (line 96). Starts B, D and E are eqv-1590 members (1RB0RE_0LC0RA_1LA0LD_1LB1LF_1RA1LD_0LB---, 1RB1RF_0RC0LD_1RD0RA_1LB0LE_1LD1RA_0RB---, 1RB1LE_1RC0RA_0LD0RB_1LB0LE_1LC1LF_0LC---), all off the list. A proof would cover them through upstream's Eqv modules.
• Nearest kill: W5-5's table (KILLED_HALT) started in its D is 1RE0RD_1LC0LE_0RA0LB_1RC1RF_1LB0LD_0RC--- in our naming (canon check: yes). It differs in A0 (ours 1RB, W5-5 1RE) and E1 (ours 1RD, W5-5 0LD).

Long runs

• tools/sim.py: no halt to 1e9 (span -69..25596, 8,997 ones).
• scripts/lt.c (direct C): no halt to 1.55e11 steps (88 deep cycles; still running at the end of the stage, output work/lt_2e11_comp.txt).
• Local windows around the head (scripts/win.c): (state, 2r+1 cells) with r = 4, 6, 8, 10 give 357, 856, 1,615 and 2,588 distinct windows. The counts are identical at 1e7, 1e8, 1e9 and 1e10 steps: nothing new appears after 1e7.

The tape: segments and markers

Read the tape as the gaps between consecutive 1s (scripts/toks.py). Almost every gap is 2, so the tape is long runs of 100 blocks ("segments") joined by a few markers:

At a round start the head is at the right end in state B:

K(a, b, m_1..m_k, c) = 0^inf L 1 (100)^a 0 (100)^b [101 (100)^m_i]_(i=1..k) (101)^c B> 0^inf

Example at step 986,714,482 (compress view): ... 0110 (010)^839 1 (100)^4736 0 (100)^6 (101)^445 B>, so k = 0, b = 6, c = 445.

Rule HUB(k): exact, validated

K(a, b, m, c)  ->  K(a + 3^(k+1), b - 3^(k+1), m, c + 1)
steps = 24c + 12·3^(k+1)·b + sum_i 12·3^(k+1-i)·m_i + d_k     (b, c before the round)
d_0 = -29, d_1 = -329, d_2 = -3821, d_3 = -37625
conditions: a >= 1, c >= 2, every m_i >= 1, b >= 3^(k+1); L is never read

• k = 0: steps = 24c + 36b - 29. k = 1: 24c + 108b + 36m_1 - 329.
• How a round goes (img/hub_round_k0.png): the head zigzags left through the (101)^c field, carrying a defect at 1/5 speed. At the hub it makes 3^(k+1) short trips, each moving one 100 block from the b side to the a side. Every 101 separator between the hub and the counter triples the number of trips (img/hub_round_k1.png: 9 per round with one separator). Then a straight sweep returns right and adds one 101 block to the counter.
• The head never goes more than 2 cells left of the hub marker, so a and L play no part.
• Random instances (scripts/val_hub2.py, seed 11; work/val_hub2_seed11.json): 1,200/1,200 exact, step count included (k = 0: 415, k = 1: 370, k = 2: 218, k = 3: 197; a 1..50, b up to 3^(k+1)+80, c 2..120, m_i 1..30, random L).
• Real run (scripts/ev.c + scripts/check_real.py): every round that ends at the right edge up to 1e9, 8,363 of them (k = 0: 7,666, k = 1: 673, k = 2: 24), matches the rule exactly, step count included. 0 failures.
• b + a is conserved and c counts rounds: the "conserved budget plus a round counter" seen by the scouts. Their hub rule C1(a,b+3,c+1) -> C1(a+3,b,c+2) is HUB(0); their +9/-9 skeleton is HUB(1).

What is NOT modelled yet

1. Exhaustion (b < 3^(k+1)). 99 events up to 1e9 at the right edge. The outcome depends on the residue b and on the neighbours: - k = 0, b = 2: the hub turns into a gap-0 marker (11): 2^a 3 2^2 (10)^(c-1) 1 -> 2^(a+4) 0 (10)^(c-1) 1 (e.g. steps 6,644, 20,511, 155,831, 200,100). - b = 0 or 1: usually a sweep to the far left (a deep sweep, below). - k = 1, b = 1, 4, 6, 7: the hub moves and the segments are re-cut (e.g. step 152,444: ... 2^22 3 2^1 10 2^12 10 1 -> 2^4 3 2^54 10 2^28 3 2^8 (10)^2 1).
2. Drain phase. After a deep sweep the counter field shrinks one 101 block at a time, (100)^j (101)^c -> (100)^(j+1) (101)^(c-1), each step being a long trip with many inner hub rounds in the old segments (e.g. steps 856.8M to 966M: c goes 1056 -> 1040 -> ... with no right-edge record for 110M steps).
3. Deep cycle. Once per cycle the head reaches the left edge in state C, and the left edge moves one cell left. 88 cycles to 1.55e11; the gaps between them grow (1.2e8 at 1e9, 2.9e10 at 1.5e11). At a deep sweep the tape reads [fossils] 2^X (10)^Y (deep-sweep alignment). Often X' = X + Y + δ with δ in {0, 4, 6, 12}, but the active part is sometimes re-cut (steps 3.65e9, 6.2e9, 15.8e9, 50e9-103e9). Y has no clean law: 554, 1830, 2018, 2632, 3316, 1397, 2505, 989, 3807, 4138, 5409, 2262, 8592, 9348, 12214, ...
4. Fossils. Segments left of the active part stay frozen: 58, 106, 1452, 393, 165, 338, 838, 12269 (frozen at ~3.6e9), 41798 (at ~5e10). Their lengths follow no visible law.

Template comparison (W5-5)

• Same 3-cell words, mirrored. W5-5's bell 101 (001)^b 0001 (001)^c is our (100)^a 0 (100)^b read right to left: our hub marker 0 is W5-5's 0001 defect.
• W5-5's .v rules: bellpart (B> 0 bellw (S b) c -->+ K b (S c): the defect moves one block per round) and round = a counter call (callw) + bellpart, with base-4 digit lemmas (abs0, abs1, absm, pass2, callw_inc) for a signed base-4 counter on 3-cell digits.
• Here the two changed transitions (A0, E1) replace W5-5's base-4 counter by a unary counter (101)^c and make the defect jump 3^(k+1) blocks per round. HUB(0) is W5-5's round with a unary counter; none of W5-5's digit lemmas carry over.
• W5-5's checked-runner HALT technique applies only if this machine halts; nothing points that way (below).

Cryptid check

• Arithmetic: the transfer unit is 3^(k+1), and exhaustion branches on b mod 3^(k+1). Fossil lengths and the counter values at deep sweeps look irregular. This is the Collatz-type signal the scouts saw (qsim: 31 of 33 rules Collatz-type).
• Halting branch: none found. Halting needs D to read 1 with a 1 right of it (D1 = 1RF, F1 = halt), i.e. D arriving inside a 1011 marker in the wrong phase.
• Random tapes built from the segment vocabulary (segments with 0/101 markers, a counter field): 0 halts in 300 runs of 2e5 steps (Python), and 1 halt in 2,000 runs of 2e7 steps (scripts/runc.c + gen_seg.py, seed 3, tape 1,726).
• That one tape is malformed at its left end (an empty first segment, so it starts 1101 101). It halts after 676 steps as A> 1 1 1: A1 = 0RD, D reads 1 (1RF), F reads 1. The local halting pattern is a 111 met from the left in state A or D.
• The real tape does contain 111: the 0^2 tokens at every deep sweep (... 2^106 3 0^2 2^1452 ...). The head meets them there in state C, moving left, and the next pass restores them. Whether the orbit can ever meet a 111 in state A or D moving right is the open halting question.
• Random dirty gap tapes (gaps 0, 1, 3, 4 mixed in): 1 halt in 400 runs of 3e5 steps.
• Plain NGramCPS (scripts/ngcps.py, untrusted) reaches a halting configuration for every n from 2 to 20 (n = 24: too big). So the obvious n-gram invariant fails; the saturated head windows still suggest a regular invariant on 3-cell words might close.
• Verdict: not a cryptid stop under the Wave 6 rule (that needs pseudo-random residues and a halting branch). The residue arithmetic is real, though, and a proof that tracks it would be a tarpit. The promising route is one that does not track it: a closed regular language.

Figures

• img/default_site.png: the site's Default view (10,000 steps).
• img/hub_round_k0.png: 3 HUB(0) rounds from a constructed start (b = 9 -> 6 -> 3 -> 0), every step, scale 2.
• img/hub_round_k1.png: 2 HUB(1) rounds with one separator (b = 20 -> 11 -> 2), every step, scale 2.
• img/every2e6_1e9.png: one row every 2,000,000 steps to 1e9.
• img/records_1e9.png (records to 3.4e7, 5,000 rows) and img/viewer.html (all site views) are extra.

Files

• scripts/tm.py, rules.py (K and run_to_Bright), toks.py (gap tokens), val_hub2.py, fit_hub.py, check_real.py, ev.c (round-end tokens), lt.c (deep sweeps), win.c (head windows), ngcps.py, gen_seg.py + runc.c, halt_probe2.py.
• work/val_hub2_seed11.json, work/lt_2e11_comp.txt (deep sweeps to 1.55e11), work/ngcps_big.txt.

Wave 6, stage 1 (2026-10-14)

Goal: find a closed regular language that contains the blank-start orbit and no halting configuration. Result: none found. Every generic search fails, and the failures show why. The stage did find two facts that point to a better route: the exact halting route, and a small, finite alphabet of junction words.

1. Generic searches: all fail (exploratory, untrusted)

• ctl2.py is a generic closed-set explorer: each tape side is a deterministic push automaton, pops use the recorded edges, and the left and right sides keep separate edge sets. Its output has the same shape as Astra's regular certificate (edges plus keys), so a closed result could be exported to that checker.
• Why they fail: stitching. The closure glues windows from different places into junctions the orbit never has, for example gaps 3 1 0 0 or 0 1 1 1 3. The fake junctions then feed back, and one of them leads to a halt. Larger windows only delay this, and the state count grows too fast.
• A check version (absn.py SegJ3, scripts/run5.py) stops as soon as a finished junction falls outside the alphabet in section 3. It stops at once on 0 0. That word is real, but only next to the head (a passing transient). So the check has to skip a local zone around the head.

2. The halting route, exactly

• F reading 1 is the only halt. F comes only from D reading 1. D comes from A reading 1, or from E reading 1; in the E case D reads the 0 that B has just written, so that route is safe.
• So a halt is exactly A moving right and reading 1 1 1: the right-moving run C, A, D, F meets 111.
• Right runs (states C, A, D, F) start from A on a 1:
• gap 2 continues the run, and the 1 moves one cell right;
• gap 0 then gap 2 continues the run, and the 11 loses a 1;
• gap 1, or a gap of 3 or more, turns the head left;
• gaps 0, 0 (a 111) halt.
• Left runs (states B, C, E) swap neighbouring cell pairs (01 and 10). They turn right at 00 (C on a 0) or at 11 (E on a 1).
• On the real tape every 111 sits inside the junction 300 (gaps 3, 0, 0). The 3 in front of it turns a right run before the run reaches the 111.
• Turns open other routes. For example, 0 0 E>0 1 halts in 5 steps. work/danger_patterns.txt lists 38 minimal local halting patterns of up to 9 cells (scripts/danger.py).

3. Away from the head, junction words come from a small finite set

Read the tape as segments (100)^n joined by junction words, the gap sequences between segments (scripts/junc.c).

• Far from the head (more than 40 cells away), every junction seen is one of the words below (samples every ~1e6 steps to 2e9: work/junc_2e9.txt; every 3e7 steps to 3e10: work/junc_3e10_raw.txt):

• The counter (101)^c sits at the right end and is entered through one of a few prefixes: 30, 4, 12, 3, 5, 31, 1202, 3002, 402.
• 40, 120 and 300 may be three phases of one junction that changes each time the head passes it. This is a guess and has not been checked.
• Near the head the words vary more (1, 00, 4, 30, 330, 321, 4300, ...). These are transients while the head passes.
• So the static tape is close to the regular language (segment junction)* with junctions from this alphabet. Segment lengths carry the residue arithmetic, and a regular invariant can ignore it by letting segment lengths be anything at least some small T.

Next step (stage 2)

Build the invariant by hand at the junction level instead of searching blindly. 1. List exactly how each alphabet word changes when the head passes through it: the right run, the left zigzag, the hub trips, a deep sweep. 2. Run the closure with a side automaton that accepts only (segment junction)* with junctions from the alphabet, plus an exact local zone around the head. Head windows saturate by 1e7, so the zone is finite. 3. If the closure needs a junction outside the alphabet, check it against a longer run: either the alphabet grows, or it is a spurious stitch to remove.

If that does not close, fall back to modelling the exhaustion branches exactly and decide whether this is a cryptid.

Files (stage 1)

scripts/ngc.c, ctl2.py, absn.py, run3.py, run5.py, junc.c, samp.c, danger.py; work/ngc_22_28.txt, junc_2e9.txt, junc_3e10_raw.txt, danger_patterns.txt.

Wave 6, stage 2 (2026-10-14)

Goal: build the invariant at the junction level (stage 1's plan). Result: no closed language, so still no proof. The stage did produce one solid new fact: the real tape's junction alphabet, collected exactly rather than by sampling, is tiny and complete by step 2.1 million.

1. The exact junction alphabet (scripts/cw.c, cw2.c)

Method: - Keep a zone of k = 20 cells on each side of the head. - A cell is committed on a side while it lies outside that zone. Committed cells cannot change: the head is too far away to write them. - The collector keeps, for each side, a stack of the committed 1s. It pushes and pops as the head moves, and records every junction word the moment a following 2 2 completes it. - Nothing is sampled, so every committed word that ever occurs is recorded.

Result to 1e9 steps (work/cw2_1e9_k20.txt). Junctions are written as gap words, left to right on the tape:

• The last new word first appears at step 2,106,481. Nothing new appears after that, up to 1e9.
• To 1e10 (work/cw2_1e10_k20.txt): the same words and segment-length classes. The only extra entries are counter words cut short: after step 1.9e9 the counter passes 2,000 blocks, and the collector stops each word at 4,000 gaps.
• The two sides use different forms. Left of the head the hub is 3 and a separator is 10. Right of the head they appear as 40, 120 and 300. The head turns one form into the other as it passes.
• Segment lengths next to the words (the run of 100 blocks just before each word on its side):
• 3, 10, 120, 40 and 300 follow segments of every length from 2 blocks up.
• The rare words (1023, 3210, 310, 0, 50) only ever follow segments of 9 blocks or more.

2. Closure runs on fixed languages (exploratory, untrusted)

Each run uses scripts/ctl2.py's explorer. Each side automaton has two parts: an exact zone of k cells next to the head, and a fixed language for the committed part. - A run fails when a push leaves the language. That is an "escape", and it is not a halt. - Every run starts from the real configuration at step 1e6 (scripts/cfgat.c). Starting from blank fails at once, on early-orbit shapes.

• Why they fail. The real tape keeps order and length constraints that a free-order junction language forgets:
• rare junctions sit only next to long segments;
• the hub, the separators and the counter stay in a fixed order;
• the counter is open on the left of the head while the head zigzags through it.
• The closure builds tapes the orbit never builds. Examples: a hub followed directly by the counter (3 (10)^c committed), and a 50 junction next to a short segment. Each fake word then produces new compound words.
• The Python explorer tops out near 1M configurations, so a closure with more state needs a C port.

3. The cryptid question

Not a cryptid under the Wave 6 rule. That rule needs pseudo-random residues and a halting route. - The residue arithmetic is real: transfers of 3^(k+1) blocks per round, and exhaustion that branches on b mod 3^(k+1). - The halting route is not arithmetic. A halt needs A, moving right, to read 111. On the real tape, every 111 sits inside the right-hand junction 300. Its 3 turns every right run before the run reaches the 111. - The real alphabet is finite and complete by step 2.1e6.

So a regular invariant very likely exists. What is missing is an abstraction precise enough to keep the order constraints. Verdict: STUCK on tooling, confidence low.

If a third stage is funded

1. Port the closure to C (10-50M configurations).
2. Learn the language from the exact collector, not from samples. The side state is the last junction word, the class of the segment before it (2-8 blocks or 9+), and a counter flag (open counter field, yes or no). Raise the zone to k = 30.
3. A closed result has the edges-plus-keys shape that Astra's baseline-safe NFA certificate package accepts (astra/autonomous-20261014/certificate-package/package.py, with --startup for the 1e6-step entry).

Files (stage 2)

• scripts/cw.c, cw2.c: the exact committed-word collector (cw2 also records segment lengths).
• scripts/dump.c, cfgat.c: sampling, and the exact configuration at step N.
• scripts/lang2.py, lang3.py, fl2.py-fl6.py: the side languages and the closure runs.
• work/cw2_1e9_k20.txt, work/cw2_1e10_k20.txt: the exact alphabet to 1e9 and to 1e10.