W6-7 observe notes: 1RB1RF_0RC0LE_1RD0RF_1LB---_1LB1LE_1RA0LC

740 line 198. Sheet: Unknown, no status, no "done by". No claim in data/discord. Not in upstream busycoq at cdaf693. Claimed 2026-10-14 (coord/claims.tsv, "Wave 6 W6-7"). Observe took about 1 h 55 min.

Table

Halting pattern (from the table)

• D is entered only from C0, so a halt needs C0 at x and a 1 at x+1.
• C is entered from F1 (then C sits on the cell F came from; if it reads 0, D reads the 0 that F1 just wrote) or from B0.
• B is entered from A0, D0 (B then reads the 1 that C0 wrote) or E0 (then C reads the 1 that E0 wrote).
• So the only halting pattern is A> 0 0 0 1 (3 steps to the undefined D1). A is entered only from F0, so in practice F> 0 0 0 0 1.
• Validated: 200/200 random contexts halt in exactly 3 steps.

Local rules (exact; scripts/validate.py, 200 random instances each with random left/right context words)

LS     L 1^(a+1) 0 1^b <E R   ->  L 1^a <E 0 1^(b+1) R    b+2 steps
WALL   L 0 0 <E R             ->  L 0 0 F> R              3 steps (also L = 0^inf)
RS3    L F> 0111^n R          ->  L 1011^n F> R           6n steps
RSodd  L F> 0 1^(2k+1) R      ->  L 1 01^k 1 F> R         4k+2 steps
RSeven L F> 0 1^(2k) 0 1 R    ->  L 1 01^k 1 <E 0 R       4k+3 steps
HALT   L A> 0 0 0 1 R         ->  halt                    3 steps

(01^k = (01)^k.) Reading in runs of 1s between single 0s: - the left sweep moves every 0 one cell left (it needs every run >= 1; a 00 or the left end turns it); - the right sweep moves every 0 one cell right through odd runs: run 1 merges with the next run, run 3 just shifts, run 5 splits into 1 + 3. So a bounce leaves a pure 0111 field unchanged and toggles a defect 11111 <-> 10111; - an even run (0, 2, 4) makes A read a 0, and the head turns left there: even runs are internal walls.

Observed dynamics

• Conveyor: between events every odd defect reappears 4 cells further left after 2 bounces (203/203 defects at 2.86e6; 17,137/19,471 at 9.84e7 including wall passages and left-end events).
• Right end: emits the periodic stream of runs 1 3 1 5 5 (20 cells) and grows by about 4 cells per 3 bounces during growth phases. Rulefit's (1^5 011 111010^2)^b counter is this stream.
• Left end: absorbs arriving defects; the left edge moves out by about 2 cells per absorbed pair. The leftmost run stays 1. Rulefit's 1011^a field with a -3 per visit is the pure field in front of the arriving history (bounded rules: A0(3n+3,-n+19) -> A1(3n+1,-n+19) -> A0(3n,-n+20), 28/28 sims, only for 3n+3 <= 60).
• Walls: after left-end events, internal walls (even runs) appear near the left and move right about 3-4 cells per bounce (sweep logs: work/sweeps_1e8.txt). Several can be queued; the head sees only the leftmost. While a wall stands the tape right of it freezes and the right edge does not grow. A growth phase starts when no wall is left.
• Phases to 1e8 (1e6 bins): growth 0-8e6, 12-14e6, 22-24e6, 30-32e6, 38-40e6, 56-58e6, 77-79e6, 81-99e6; walls otherwise. No law found.
• Long run (scripts/longrun.c, work/longrun_2e10_summary.txt): no halt to 2e10. Span 6,398 at 1e8, 83,076 at 1e10, 129,249 at 2e10 (about t^0.55). 0-3 walls at any snapshot; odd defects 1,063 at 2.5e8, 22,869 at 2e10.
• At 2e10 the tape in run-length form is a chain of periodic regions: (1 3 1 5 5)^3142, (5 1 3 1 5)^2043 at the right; a 45-run block repeated 125 times; older regions on the left that repeat long blocks too. This looks hierarchical (each wall phase rewrites an older region), but I have no exact rule for it.
• Four-zero runs: created by the head inside a sweep (C1 or F after C1), 20 events by step 1.3e6, e.g. F at offset 2 of a 0000 run (near miss of the halting pattern). Tape censuses (internal 7-letter words every 1e5 steps to 1e8) never contain 0000; 000 appears (first at 3.6e6).

Siblings (canon over all starts)

• 248 1RB1RA_0LC0RA_1LF0LD_1LE0RC_1LB1LD_1RB--- = start E (mirrored). At 1e8: same 0111 field with 1/5 defects, emitter 1 5 5 1 3 at its left end.
• 582 1RB0RE_1LC---_0RA0LD_1LC1LD_1RF0LA_1RC1RE = start C. At 1e8: same field, emitter 5 1 3 1 5 at its right end.
• Starts D and F: eqv-1590 members, linked to 248 by upstream Eqv_v2.v (equivalence only). Start B: on no list.

Template and cryptid check

• Template: none within 5 transitions; none of our 31 kills has this shape (they are counters / Bell eats counter / sync bouncer). Upstream's closed-tape-language verifier (CTLv1.v, solve_cert with CPS_LRU / NG / RWL_mod) is the natural formal route if a certificate exists.
• Cryptid: no pseudo-random arithmetic identified. The open part is the wall-phase timing driven by the run-length history, which may act like a chaotic 1D CA. Not flagged as a cryptid candidate; confidence low.

Next goal (2 h)

Certificate lane first: a bounded CTL62 parameter sweep (CPS_LRU, NG, RWL_mod; native search before any coqc) on the three list starts, because halting needs F> 0000 1 and four-zero runs only appear next to the head. If nothing is found, build the exact run-length model (conveyor + RSeven wall motion + left-end absorption + right emitter) and test whether the wall phases follow a law.

Files

• scripts/validate.py (+ trace.py): local rules, 200 random instances each.
• scripts/sweeps.c, dumpL.c, longrun.c, z3.c: sweep logs, per-bounce tape dumps, 2e10 run, zero-run detector.
• work/: rulefit.txt/json, track_direct_1e8.txt, sweeps_1e8.txt, longrun_2e10_summary.txt, extra pictures.

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

Goal: look for a CTL certificate first. If none turns up, build the run-length model and settle the cryptid question.

Result: cryptid candidate, confidence med. No CTL certificate was found. The wall dynamics are now an exact particle picture, and the halting route is known. The machine halts if two exact-timing coincidences occur, each between a wall birth at the left end and a wall arriving far to the right. Nothing in the data rules these coincidences out. Non-halting would need a hidden timing lock, and no regular (CTL-style) language can express one.

CTL search (scripts/ctl/)

• Driver: the extracted busycoq CTL62 decider ctlx. Upstream CTL.v at cdaf693 is byte-identical to vendor's, so the extraction still applies. Sweep files: sweep.py, params_A.txt (NG, NG with history, CPS_LRU) and params_B.txt (RWL_mod, block sizes 1-24). Runs were sequential, under nice 10 and ulimit -v 6 GB, with a 60 s cap.
• Outcome: 235 runs (about 65 min), 0 true: 181 false and 54 hit the 60 s cap.
• NG plain, n = 2-20: 19 false.
• NG with history, n in {2,3,5,6,7,11,13,15}: 140 false, 42 timeouts.
• RWL_mod, block sizes 4 and 8, mod 1-4, len1 1-8: 22 false, 12 timeouts.
• Nothing went to coqc. The remaining 964 settings (rest of NG-history, all CPS_LRU, other RWL block sizes) are not run; sweep.py resumes where it stopped.
• Why CTL should fail anyway: see the halting route below. Excluding a halt means excluding timing coincidences between distant events, and a bounded-window language cannot see those.

Local languages do not close

• k-gram languages of the tape at left-end bounces (cell k = 8-20, from the real run to 1e8): random members leave the language within one bounce, and some halt after leaving it. For k = 20, 6 of 1,745 halted (randtest.c).
• Run-level n-gram saturation (tokens 1/2/3/4/5/7/9, ., :): for n = 6, 8 and 10 the closure reaches an interior 000 in 3-20 rounds. For n = 12 and 16 it keeps growing without converging, picking up runs of 8, 9 and 12 (saturate.py).

Particle picture (head is stateless between runs)

• A bounce runs from one left-end E turn to the next. F always reaches a separator 0 in state F, and E always moves over 1s, so the head carries no state from run to run. One bounce therefore applies a fixed local transducer to the run sequence, from the left end up to the first even run, where F turns (RSeven). Everything to the right of the leftmost even run is frozen.
• Defects are odd runs (1, 5, rarely 7 or 9). Each is a 2-cell phase slip of the 0111 field, and they drift 2 cells left per bounce (observe).
• Walls are even runs (2, 4) and 00. Each is a 1-cell parity flip of the zero positions.
• Only the leftmost wall moves. A lone 2 in a pure field moves exactly one run (4 cells) right per bounce: 324/324 (scripts/stage1/chain_checks.py).
• Everything beyond it stays put. In the real run to 1e8, the tape more than 8 cells right of the leftmost even run was unchanged over the bounce in 86,698 of 86,704 bounces (frozen.c). The 6 exceptions are a wall of run length 8, which RSeven rewrites in place over more than 8 cells.
• Annihilation. A moving wall that reaches a frozen wall annihilates with it into odd runs. Typical case: 3.2.2.3 -> 3.3.1.3, 414 of about 1,000 annihilations to 1e8.
• Birth. Walls are born from defects that reach the left edge. In 1,306 of the 2,019 births to 1e8, the leading run goes from 1 to 2 (1.3.3.3.3.3 -> 2.3.3.3.3.3). Births happen on 2.2 % of bounces to 1e8, and that share falls later (see the estimate).
• Right end. The emitter cycles through 3 states: .3.1.5.5.1.3:1, .5.1.3.1.4.1.1 and .5.5.1.3.1.5.5. A wall that reaches it in any state, form or offset is absorbed safely: 216/216.
• The walls form a stack. Old frozen walls persist for 1e5 bounces or more (e.g. at -3171 and -1299 near 2e9). Growth and wall phases alternate irregularly: 398 of each to 2e9, and a wall phase that started at 1.87e9 was still open at 2e9 after 60,857 bounces (work/stage1/phases_2e9.txt).

The halting route

Halting needs F> 0 0 0 0 1, which in practice means an interior 000 that a wall then reaches.

The tape never has an interior 000 at left-end bounces. None in 773,707 bounces to 2e9 (pairs.c). To 3e10 (5,248,319 bounces, ones.c → work/stage1/ones_3e10.txt) there is still no interior 000, and a run 1 directly before a 00 (1:) occurred 11 times: 3 in the start-up transient and 8 between 1.24e9 and 2.24e10 (bounces 531,221 to 3,891,278). Every one of the 11 was the leftmost wall structure (no wall to its left).

The chain, with each link checked on synthetic tapes (chain_checks.py):

1. A frozen 1: must exist: a run 1 directly before a 00 wall.
2. A moving wall that reaches a frozen 1: turns it into an interior 000: 36/36 (forms 2, 4 and :; shifts 0-3; contexts 1:1, 1:3, 5.1:1). Control: the same with a run 3 before the 00 never does, 12/12.
3. A moving wall that reaches a frozen 000 halts the machine within a few bounces: 105/105. If F reaches the 000 with no wall in front, it just dissolves it: 4/4, no halt in 200 bounces.

What happens in the real run. Each 1: so far was the leftmost structure, so F dissolved it on the next bounce. Example: 2.2:1 -> 3.1:1 -> 7:3 at steps 1,238,230,449 / 1,238,230,967 / 1,238,231,495. That matches chance: with births on about 1.1 % of bounces at those times, 8 episodes give 0.09 expected coincidences. For a 1: to stay frozen, a wall must be born at exactly that bounce. That wall must then reach the 1: before another birth intercepts it. When it makes the 000, another birth must happen at exactly that bounce, followed by another uninterrupted trip.

A real-tape check of half the chain. Start from the tape at step 1,238,230,449, with one change: the first run 3 becomes 1, i.e. a defect arrives one bounce earlier. Then 1:1 stays frozen, the new wall reaches it, and an interior 000 appears at bounce 52. Without the change there is no 000 in 3,000 bounces (chain_checks.py, real_tape_*).

The full chain on the real tape. Same start, but now with three edits, each of which only changes when a defect reaches the left edge:

• before bounce 0: first run 3 -> 1, so wall W1 is born one bounce earlier;
• after bounce 51: first run 3 -> 1, so wall W2 is born exactly when W1 makes the 000;
• after bounce 86: first run 1 -> 3, which suppresses a natural birth that would otherwise intercept W2.

With these edits the machine halts at bounce 105. With only the first two edits, the natural birth at bounce 86 intercepts W2, and the 000 dissolves later without a halt.

No timing lock is visible. To 1e8, births and annihilations fall in the same bounce 14 times, against 22.7 expected if they were independent. Births 1-5 bounces after an annihilation: 14/20/13/14/24, against about 22 each.

Verdict and estimate

This is a cryptid candidate. Non-halting comes down to whether exact-bounce coincidences between left-end births and distant wall arrivals ever line up. That is pseudo-random timing rather than arithmetic, but the consequence is the same.

A crude estimate, assuming births are independent of everything else:

• Birth rate. Births become rarer over time. As the share of bounces whose leading run turns even (births.c, windows of 500k bounces), the rate falls from 1.55 % (to 1.1e9 steps) to 1.2 % (around 1e10) and 0.54 % (around 2.8e10). That is roughly t^-0.33.
• Per episode. A 1: at run index k completes the chain with probability about p^2 · e^(-2pk), where p is the birth rate and a wall moves one run per bounce. At the 8 real episodes (p ≈ 0.011, k = 11 to 238) this averages about 4e-5. Expected halts so far: 8 × 4e-5 ≈ 3e-4.
• Episode rate. About 1.7e-6 per bounce (8 in 4.7M bounces). Bounces grow like t^0.71: 773,707 at 2e9, 5,248,319 at 3e10.

If the birth rate levels off near 0.5 %, the expected halt is around 1e16 steps. If it keeps falling like t^-0.33, the expected number of halts grows only like a tiny power of t: heuristically it still halts eventually, but astronomically late. Either way, a simulation hunt is unlikely to find the halt. A halt that far out also could not be certified with the runners we have (1e10 or more bounce-level macro steps).

Siblings 248 (start E, mirrored) and 582 (start C) share the table and the route. Censuses to 1e10 (ones.c with start state C or E; work/stage1/ones_start{C,E}_1e10.txt): no interior 000 in either. 1: occurred once for start C and twice for start E (both in the start-up transient), and every one was the leftmost structure.

Files

• scripts/ctl/: the CTL sweep (sweep.py, params_{A,B}.txt) and its results (sweep_{A,B}.jsonl).
• scripts/stage1/chain_checks.py: all chain checks; writes work/stage1/chain_checks.json in about 18 s.
• scripts/stage1/chain_figure.py: draws img/halt_chain_rows.png, the full chain on the real tape (also added to observe.json).
• scripts/stage1/*.c, the real-run scans:
• walls.c: wall positions per bounce;
• pairs.c: close wall pairs and interior 000;
• zctx.c: runs around every 00;
• ones.c: 1: and 000 episodes, any start state;
• births.c: birth rate;
• frozen.c: the frozen-region check;
• also phases.c, rldump.c, kgrams.c, randtest.c.
• scripts/stage1/rlclose.py and saturate.py: the local-language experiments. They read rl_1e8.txt, which is rldump 1e8 1 (145 MB, not kept).
• work/stage1/:
• tape_1238e6.txt: real tapes around the 1:1 episode;
• zctx_2e10.txt: runs around every 00, to 2e10;
• ones_3e10.txt and ones_start{C,E}_1e10.txt: the episode logs;
• phases_2e9.txt: growth and wall phases;
• chain_checks.json.