W6-8 1RB1RC_0LC1RE_1RA0LD_1LB0RD_0RF---_0RA0RF: observe notes (2026-10-14)

740 line 9. Sheet class: Unknown, note "Code. Binary counting + bouncing" (nerdyjoe, 2025-12-28; Results tab row 24, an analysis note with no status). No Discord file mentions it. Claimed in coord/claims.tsv as Wave 6 W6-8.

Checks

• Byte-exact on data/holdouts/BB6_holdouts_740.txt line 9.
• Family: no other 740 line has the same table under renaming, mirror or any start state; no 740 line within 3 transitions. siblings = [].
• busycoq (origin/BB6 cdaf693) Eqv_v2.v modules TM238 and TM536 prove 1LB0RA_0LC1RE_1RD0LA_1RB1RC_0RF---_0RD0RF and 1RB0LD_1RC1RA_0LA1RE_1LC0RD_0RF---_0RB0RF equivalent to this machine. A proof here settles both through those lemmas.
• Halting: E1 is the only missing transition. E is entered only by B on a 1. So the machine halts exactly when (a) a left sweep reads 1 0 1 <C, or (b) a right sweep reads A> 0 1 1.

Tape-level rules

Every rule was validated 300/300 by simulation with random surroundings (work/vmicro.py).

The left sweep writes the same tokens as kill #8's P = 01 and PZ = 010.

Block-level picture

At each right-edge arrival in state A, the tape is

0^inf 1^b0 0^s0 1^b1 0^s1 ... 0^s(n-1) 1^z A> 0^inf      (s_i in {1,2,3}; z may be 0)

One cycle runs from one such arrival to the next. A carry starts at the last block, whose effective length is z-1. It passes every block that is odd and has 0^2 on its left. It stops at the first block that is even, or odd with 0^3 on its left. An odd block with 0^1 on its left halts the machine.

This is a binary counter. The gaps are the digits: 0^2 = 1 and 0^3 = 0, with the least significant digit at the right. The last block z is fuel: it loses 4 every two cycles.

The rules below reproduce all 75,581 cycles between steps 11,118 and 4·10^9 exactly (work/validate.py). Each one was also checked against the TM on 200 random instances: 17 variants, 3,400/3,400 (work/vrules.py).

In the table, the p_i are the passed interior blocks (odd, with 0^2 on their left).

The step count per cycle is 3·(cells from the stopping gap to the edge) + O(number of passes). Summing it reproduces the real step count at 4·10^9 to within 0.01%.

Epochs: Collatz-like refill

Let F be the fuel just after each Z0c refill, and write F = 8a + 6. Then

a(n+1) = ceil(3 a(n) / 2) + 1,  a(0) = 7 at step 17,103

Equivalently, F' = (3F+10)/2 when F ≡ 6 (mod 16), and F' = (3F+18)/2 when F ≡ 14 (mod 16). This holds for all 14 real refills up to 4·10^9 and all 28 refills in the 2·10^7-cycle block run.

F ≡ 6 (mod 8) is invariant. The next bit (the parity of a) chooses between two epoch shapes:

• a even: ToddZ2 Z0a Z0b Z0c
• a odd: ToddZ2 Z0a ToddZ2 Z0a Z0b Z0c

That choice looks pseudo-random.

Does halting depend on the Collatz-like part? Evidence says no

The block map raises Halt / Unknown on any case it does not cover.

• Long run. 2·10^7 cycles with the block map (≈ 2.9·10^14 TM steps by the step formula; tape 4·10^7 cells, 99 blocks): no Halt, no Unknown.
• Fuel fuzz (work/fuzz.py). Every refilled fuel is replaced by a random value with the same residue mod 8: 300×2·10^4 cycles, all fine. Keeping only mod 4, or only parity, hits an uncovered Z0c case every time. The TM sometimes halts there (Z0c with 0^1 before w) and sometimes cycles on (0^2 before w).
• Block fuzz (work/fuzz2.py). Every block ≥ 9 is replaced by a random length with the same residue mod 8, either every 997 cycles (300×2·10^4) or every cycle (400×5·10^4): all fine. With mod 4 instead: all runs fail.

Conclusion: the run seems safe for every refill path. What safety needs looks like the gap pattern plus the block lengths mod 8, not the orbit of a. This is a cryptid check that does not fire, but the invariant is not yet found. 3-gap windows (gap, length mod 8, gap) are not closed (work/local.py), so the invariant needs longer context or an automaton.

Local facts seen in every cycle (work/inv.py style tables):

• A block after 0^1 is always ≡ 3 (mod 8) with 0^3 on its right, or ≡ 6 (mod 8) with 0^2 on its right.
• After 0^1 1^3 0^3 comes an even block followed by 0^3, or an odd block followed by 0^2.

Long-run shape

• The left end is frozen after step 10,325 (no left record up to 10^9).
• Old digits are reached only exponentially rarely; the active part is at the right end.
• At 4·10^9: 151,420 cells, 55 blocks. The tape grows like sqrt(steps).

Template check

The nearest proved neighbour as experience is kill #8 1RB0LF_0RC---_1RD0RA_1LE0RC_0LA0LE_1LE1LB (sync bouncer counter); I read its .v.

• Different rule sets. #8 runs a C sweep over tokens T0/T1/TZ to the right of the head, uses a return transducer retf, a 15-bit tail and an interval INV. Here digits are gaps between unary blocks that keep changing length.
• What transfers. #8's token words P = [0;1] and PZ = [0;1;0] are exactly what this machine's left sweep writes. The Csweep/retf list-induction pattern fits the encode/decode sweeps.
• Others. Kill #4's .v (binary counter with d0/d1 digits) has no matching rules. No holdout and no kill table is within 5 transitions.

Discord

Not needed now. If Dennis wants to check nerdyjoe's interest first, ready to paste:

Hi @nerdyjoe, are you still working on 1RB1RC_0LC1RE_1RA0LD_1LB0RD_0RF---_0RA0RF (your sheet note "Code. Binary counting + bouncing")? We have exact block rules for it (binary counter in the 00/000 gaps, with fuel refilled about x1.5 each epoch) and are looking for an invariant. Happy to leave it to you if you're on it.

Files

• work/ holds the scripts:
• macro.py: the block map
• validate.py: checks it against the real run
• vrules.py, vmicro.py: TM-level checks
• fuzz.py, fuzz2.py, local.py: robustness tests
• farrun.py, farrun2.py: long runs and step estimate
• counterfig.py: Fig 2
• compact.py: makes the cycle list
• Regenerate the cycle list: tools/sim/tmsim TM --max-steps 4e9 --on-record --dh | python3 work/compact.py > cyc_4e9.txt (20 MB, not kept).
• work/macro_epoch_events_2e7.txt: epoch events of the 2·10^7-cycle run.

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

Goal: a regular invariant over the block rules. Not found yet, but three things changed the picture.

1. The left edge is harmless

The old block map stopped with Unknown when a carry reached block 0. The TM does not halt there. It grows a new top digit:

Passed blocks and the fuel change as usual.

• work/macro2.py is the block map with these rules.
• work/vleft.py checks it against the TM on random configurations: 0 mismatches in 3,000 (147 Lodd, 194 Leven, 104 LoddZ2, 118 LevenZ2 among them).
• work/macro2.py also says Halt only for Z0c with 0^1 before w. Z0c with 0^2 before w is Unknown, because the TM goes on there.

So the counter extends itself at the top. A single huge epoch is safe (work/bigfuel.py: fuel + 8·10^6 from step 11,118, 2·10^6 cycles, no stop).

The frozen left part also survives carries. work/prefixstress.py keeps the real first 17, 20 or 25 blocks at cycle 3·10^6, joins on the last 3-4 blocks with a huge fuel, and runs 3·10^6 cycles. The old digits get rewritten and nothing halts. (One run with 38 blocks halted at once, but only because the join put an odd block right after a 0^1 gap.)

2. Small refills really halt

work/fuzz4.py replaces 30% of refill fuels by the smallest value in their residue class mod 8:

So "fuel mod 8" alone is too coarse. An invariant must also know that the refilled fuel is at least 8. That means size classes for the fuel and the last blocks: exact below a threshold T, residue mod 8 above it.

Real fuels are at least 62, so this costs nothing in the real run.

3. A cleaner picture of the counter

Each block acts as a small transducer. It has a state (gap on its left, parity) and gets two kinds of input from its right neighbour:

• N: +3, which flips the parity. This happens when the right neighbour stops with Todd or Teven1.
• R: the carry arrives.

The steady life of a block, mod 8, is

(3,6) -N-> (3,1) -R-> (2,4) -N-> (2,7) -R-> (3,6)

That is a binary digit: the left neighbour gets N on 0→1 and R on 1→0.

Phase consistency. Call a pair of neighbours consistent when the left block's expected input matches the right block's next output:

• Expected input: N if even, R if odd. For a gap-1 block it is the other way round.
• Next output: R if the gap is 2, N if it is 1 or 3.

Over 10^6 cycles (work/cons.py), every pair right of the 17-block frozen prefix is consistent in 98% of the samples. The rest have one inconsistent pair, or two next to each other.

These defects are waves. A refill launches one, it inserts a new digit at each level it passes, and it dies when it reaches a block that expects R. The blocks that later become fuel are always born near the right end, at depth 2 at most, one epoch earlier (work/depth.py).

The race is comfortable. Per epoch there are 2 to 11 insertions. The deepest block a carry reaches stays 24 or fewer blocks from the right end, while the tape grows from 10 to 97 blocks over 27 epochs (work/race.py).

Why plain window languages fail

work/winfix2.py and work/winfix4.py compute the least k-window language that contains the step-11,118 word and is closed under the abstract step. Words are read from the fuel end. The last D blocks keep length mod 8 (winfix4: size classes with T = 12 or 16) and deeper blocks keep parity only. winfix4 includes the left-edge rules.

Every run (k = 2-5, D = 2-3) ends with a halting word. work/winfix4o.py traces the first bad window. It comes from a 4-window that puts a (3, even) block receiving R (an inconsistent pair) right next to a fresh (1, 3). The Teven3 insertion then places a (2, odd) block right of a (1, odd) one.

Windows cannot say "pairs are consistent except inside at most one wave". So the invariant needs an automaton that carries that relation.

Next

Build a right-to-left automaton:

• Tail: a finite set of shapes for the last 2-3 blocks and the fuel, with size classes (fuel ≥ 8 after a refill).
• Body: a chain of (gap, parity) blocks that are phase-consistent except for at most one wave, from a finite catalogue of wave shapes learned from the inconsistent-pair data.
• Left end: the frozen prefix, closed under Lodd/Leven.

Check closure with the product search in winfix4.py, which already has every step case including the left edge.

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

Goal: the invariant. Not found. The mechanism is now much sharper, and the obstacle is now a clear, specific one: a timing question between two travelling defects.

1. Each block is a six-state transducer

The interior rules of work/macro2.py say exactly this. A block's state is its left gap and its parity. It gets N (+3) or R (the carry) from its right neighbour.

A new block of length 3 is D when the gap is 2 and F when the gap is 1. A block's next output is N if its gap is 3 or 1, and R if its gap is 2.

A normal block cycles A → B → C → D → A on the inputs N R N R. It sends N on B → C and R on D → A. So it divides its input stream by two, like a binary digit.

2. Phase defects, and the only halting route

Call a pair of neighbours in phase when the left block expects what the right block will send next.

• A chain that is all in phase never inserts and never halts.
• A gap-1 block sends N twice in a row over its life: once on E → A, and again on A → B → C. So its left neighbour gets one pulse out of phase. This is a phase defect.
• A defect moves left by insertions: A + R inserts D, and C + R inserts F. Most die within a level or two. Real waves live 1, 24, 192 or more than 200 cycles and reach depth 2, 5, 8, 11 or 13 (work/s2_wave.py). Each level is about 3 blocks deeper and 8 times slower.
• Up to two defect clusters right of the frozen prefix coexist (218 of 2·10^6 cycles, work/s2_wave2.py). Particles (defects and gap-1 blocks) right of the prefix are always at least 9 blocks apart (work/s2_particles.py).

In the body, the machine halts only when R reaches an F.

3. The pairing rule that keeps F safe

In the real run, every gap-1 block has one of only four right neighbours (work/s2_p12.py, 10^5 samples):

A gap-3 block only ever sends N. So an F whose right neighbour has gap 3 can never get R.

The pairing breaks only if something is inserted between F and its neighbour. That needs an R to reach the neighbour while it is A. In other words, a later defect must catch the F before F has received its first N.

Refill fuzz (work/s2_p12b.py, 60 runs × 3,000 cycles per row; each refill replaced by 8·m + r):

So the small-refill halts of stage 1 are exactly this: a second defect catches an F.

4. Larger window languages

work/winfix4.py with k = 7 and k = 10 (D = 2, T = 16, seeded with 2·10^5 real cycles) finds no bad word, but it does not close either. It reached 730,000 windows after 67 rounds (k = 7) and 2.2 million after 22 rounds (k = 10), still growing when stopped (logs in the scratchpad, not kept).

5. What an invariant needs

What keeps an F safe is timing. Its right neighbour must send N before any later defect arrives.

A window language glues a defect from one moment next to an F from another, so it cannot see this. The invariant has to relate each F (or live wave) to the next defect on its right, through the digits between them. Those digits decide which one moves first. This is a comparison of two counter values: regular in principle, but not local.

Cryptid question

The answer is still no, and the reason is now sharper. Safety does not depend on the refill orbit a → ceil(3a/2) + 1, only on refills of at least 24 + r, and every real refill is at least 62. What it needs is the defect-timing property above, which is a property of the counter alone.

Next (if funded)

• Write the six-state chain as a right-to-left automaton. Its state is: the phase relation to the right neighbour, whether a gap-1 block is pending, and the digits from it to the nearest defect, cut off at the depth where the defect provably arrives late.
• Check closure with a product search like winfix4.py, using the six-state alphabet in the body and size classes only in the last 2-3 blocks.