BB(6) hunt
Machines / #15

1RB1RF_1LC1RE_---0LD_1LE0LD_1RA0RF_0RE0LB

#15Claimed elsewhereBell eats counterbbchallenge ↗Explorer

Upstream result

Claimed elsewhere

The blank-start machine never halts: BECv10.v.TM33 ↗. Recorded commit time: 2026-10-13T13:42:06Z. First public push time is not established.

Absent from the current 663 holdout list. Earlier local observations remain below.

space-time diagram, first 10,000 steps from blank
The first 10,000 steps from a blank tape. Time runs down; white is 1.
About this picture

The standard picture (bbchallenge.org's Default view): each row is the whole tape at one step, time runs downward, and the head's path draws the pattern.

bbchallenge-defaultStart blankRows steps 0 → 10,000, top to bottomWindow cells −200..199, left to rightColors 1 0 or unvisited

Overview

In one sentence

Left pair (110)^a 0 (011)^n trades 1 block/trip; right binary counter +1 per 2 trips; reset at n<=2 grows L

Upstream
The blank-start machine never halts: BECv10.v.TM33 ↗. Recorded commit time: 2026-10-13T13:42:06Z. First public push time is not established.
Status
Externally Solveddeepen2 · updated 2026-10-10Parked · Deepen 2: re-alignment transient solved exactly (PROC rule, 11,500/11,500), and the phase-level closed-form orbit (exact against the trip-level orbit at 4,871/4,871 resets to 2.4e7 trips) runs to L = 6.9e7 with no race lost. The 3 open questions are optional.
idle since Oct 10 06:29 · status.json 2026-10-10
Class
Bell eats counterours: Bell eats counter (sheet) · ours adds: unary left pair + binary right counter; reset absorbs counter digits · med confidence
On the list
not on BB6_holdouts_663.txt (line 486 of the previous list) · historical 740 line 486
#15eqv ×1sim 1e15

Mechanism

How it works: 3 notes
  • Tape = 0^inf (110)^a 0 (011)^n, then a binary counter Q at the right end (3-cell digits, LSB nearest the head).
  • One trip = zig-zag from the right end to the a|n boundary and back: a+1, n-1. Q gets +1 every 2nd trip.
  • At n = 1 or 2: reset (two full sweeps), a restarts at 2 and L = a+n grows. Trips ignore Q; the reset ignores a.

Figures for Checkpoint A

Fig 1 · One row per trip, across one resetQ1

One row per trip. Black dots mark the a|n boundary; the counter sits at the right edge.

One row per trip, across one reset
bbchallenge-defaultStart mid-run: step 152,677Rows every entry into state B moving rightWindow cells -46..240, 1 px = 0.5 cellsColors 1 0 or unvisited head (last move right/left)
Rows: one per trip, plus 1-4 extra rows a few steps apart while the counter carries; 196 rows over steps 152,677..192,677; the reset falls between rows 162 and 163 (steps 181,068 and 181,780) · Window: each cell 2x2 px · Colors: the black diagonal dots are the 0 between (110)^a and (011)^n
Fig 2 · Zoom on the reset, every 2 stepsQ2

Every 2 steps around the reset: compare the sweeps at the top with those below them.

Zoom on the reset, every 2 steps
bbchallenge-defaultStart mid-run: step 180,953Rows every 2 stepsWindow cells -46..230, 1 px = 0.5 cellsColors 1 0 or unvisited head (last move right/left)
Rows: steps 180,953..182,653 (851 rows, 2 px each; no head drawn on row 0). The head moves at most 2 cells between rows, so each sweep is a clean diagonal · Window: each cell 2x2 px
Fig 3 · One row per trip, to 1 million stepsQ3viewer ↗

One row per trip to 1M steps; each long diagonal is one phase. Compare the phases with each other.

One row per trip, to 1 million steps
bbchallenge-defaultStart blankRows every entry into state B moving rightWindow cells -72..430, 1 px = 1 cellColors 1 0 or unvisited head (last move right/left)
Rows: one per trip, plus extra rows a few steps apart while the counter carries (2,299 of 4,871 gaps are under 20 steps); 4,872 rows to step 1,000,000
More figures (2)Fig 4–5: Blaze view, 10 million steps · bbchallenge Default view, first 10,000 steps
Fig 4 · Blaze view, 10 million stepsviewer ↗

Smooth, slow growth (span ~ t^0.35) with no chaotic patches.

Blaze view, 10 million steps
bbchallenge-blazeStart blankRows Blaze time blocks of 16,384 stepsWindow cells -138..958, 1 px = 1.37 cellsColors 0 1 1 only part of the time (or in part of the cells) of that pixel's block
Rows: (each averaged), 611 blocks to step 1e7, stretched to 500 px (1 px = about 20,000 steps) · Window: Blaze image: 1 column per cell, 1,097 columns stretched to 800 px · Colors: no head
Fig 5 · bbchallenge Default view, first 10,000 stepsviewer ↗

For orientation: early zig-zag trips as bbchallenge.org shows them.

bbchallenge Default view, first 10,000 steps
bbchallenge-defaultStart blankRows every step 0..9,999Window cells -200..199, 1 px = 1 cellColors 1 0 or unvisited head (last move right/left)
Rows: squeezed into 500 px by the site's bilinear filter: px row y blends steps 20y+9 and 20y+10, so it is effectively one sample every 20 steps
Rules (4/4 validated)exact tape rewrites the proof will formalize, each re-checked by simulation
rulefrom ⟶ tocasesstepschecked
T: trip pair (clean counter)
0∞ (110)2c 0 (011)n+3 <C 1010010 D(c) 0∞
⟶ 0∞ (110)2c+2 0 (011)n+1 <C 1010010 D(c+1) 0∞
c>=1, n>=0; D(c) = c LSB-first, digit 1=001, 0=000; fails for n+3<3 (reset)16n + 6*nu(c) + 62, nu = trailing 1-bits of c (exact fit)✓131/131
T': trip pair, any natural counter word
0∞ (110)a 0 (011)n+3 <C Q 0∞
⟶ 0∞ (110)a+2 0 (011)n+1 <C inc(Q) 0∞
Q, inc(Q) = 15 consecutive natural pairs at 3e8/6e8/9e8; a, n random16n + K(Q)✓60/60
R: reset (clean counter)
0∞ (110)2c 0 (011)n <C 1010010 D(c) 0∞, n in {1,2}
⟶ 0∞ (110)2 0 (011)2c+n+dL-2 <C Q' 0∞
dL=1 if n=2; n=1: dL=4 (c even), 5 (c=3 mod 4), 6+nu(c>>2) (c=1 mod 4)about 16L (not fitted)✓48/48
R': reset ignores a
0∞ (110)a 0 (011)n <C Q 0∞, natural (n,Q) at a reset, a replaced
⟶ 0∞ (110)2 0 (011)a+n+dL-2 <C Q' 0∞, same dL and Q' for every a
natural resets after 3e8 and 6e8 (both n=2); 6 values of a each (incl. 0, 2, 4, large)—✓12/12
Compressed historythe tape as 0∞ (110)a 0 (011)n 1 W B> 0∞ at 37 moments: where the rules are read off
0∞ (110)a 0 (011)n 1 W B> 0∞
stepanL=a+nW (x=110, y=111, |=00)
152,67718283x3
154,00638083xxyx
156,57177683xxyyx
161,320156883xxy3x
169,285315283xxy4x
179,074632083xxy5x
183,20638689xyxx
652,38115117132xyxxyxyx3
1,548,8777168175x7yx5yx3
3,362,8561234235x10|yxy3xy3x
5,981,62315268283x15yxxyxyxx
10,190,50315338353x9y3x3
15,458,2157402409x9yyx4
23,255,2313464467xyx4|xxy6x
31,983,1993523526xyxx
44,015,79331530561x10yx7yx3yxyxx
57,048,6847621628x4yx9yxx
72,950,78131664695x5y3xxyxx
94,407,75663692755x5yx5y4x3
115,883,9027790797x3yx16yxx|xy5x
144,738,51531850881x6yx4yxyyx4
174,956,9653956959xyx5
213,616,166319891,020xy4xx
254,305,5552558061,061xxyyxyxxyxyx3yyx3
300,757,874631,0641,127yxxyxxyx3yyxx
348,426,178151,1581,173x12yx7yyxx
401,395,498311,2121,243xyx4yxxyxyxx
466,240,457151,3031,318xxyyxyxx
531,172,100151,3591,374x5yx4yx3yxx
610,675,498311,4171,448x4yxxyxyx4yxx
690,166,3711271,3801,507x8y6x3
784,529,510311,5401,571xxyx14yyxyx3
877,484,799311,5881,619x10yx17yx3yyx5
991,186,6241271,5901,717x3yyx3y4x4
992,752,4692551,4621,717x3yyx3y4x3yx
995,490,9465111,2061,717x3yyx3y4x3yyx
999,395,0391,0236941,717x3yyx3y4x3y3x
alast 1,023
1,02311.5e51e9log xstep 152677: a = 1step 154006: a = 3step 156571: a = 7step 161320: a = 15step 169285: a = 31step 179074: a = 63step 183206: a = 3step 652381: a = 15step 1548877: a = 7step 3362856: a = 1step 5981623: a = 15step 10190503: a = 15step 15458215: a = 7step 23255231: a = 3step 31983199: a = 3step 44015793: a = 31step 57048684: a = 7step 72950781: a = 31step 94407756: a = 63step 115883902: a = 7step 144738515: a = 31step 174956965: a = 3step 213616166: a = 31step 254305555: a = 255step 300757874: a = 63step 348426178: a = 15step 401395498: a = 31step 466240457: a = 15step 531172100: a = 15step 610675498: a = 31step 690166371: a = 127step 784529510: a = 31step 877484799: a = 31step 991186624: a = 127step 992752469: a = 255step 995490946: a = 511step 999395039: a = 1023
nlast 694
1,590201.5e51e9log xstep 152677: n = 82step 154006: n = 80step 156571: n = 76step 161320: n = 68step 169285: n = 52step 179074: n = 20step 183206: n = 86step 652381: n = 117step 1548877: n = 168step 3362856: n = 234step 5981623: n = 268step 10190503: n = 338step 15458215: n = 402step 23255231: n = 464step 31983199: n = 523step 44015793: n = 530step 57048684: n = 621step 72950781: n = 664step 94407756: n = 692step 115883902: n = 790step 144738515: n = 850step 174956965: n = 956step 213616166: n = 989step 254305555: n = 806step 300757874: n = 1064step 348426178: n = 1158step 401395498: n = 1212step 466240457: n = 1303step 531172100: n = 1359step 610675498: n = 1417step 690166371: n = 1380step 784529510: n = 1540step 877484799: n = 1588step 991186624: n = 1590step 992752469: n = 1462step 995490946: n = 1206step 999395039: n = 694
L=a+nlast 1,717
1,717831.5e51e9log xstep 152677: L=a+n = 83step 154006: L=a+n = 83step 156571: L=a+n = 83step 161320: L=a+n = 83step 169285: L=a+n = 83step 179074: L=a+n = 83step 183206: L=a+n = 89step 652381: L=a+n = 132step 1548877: L=a+n = 175step 3362856: L=a+n = 235step 5981623: L=a+n = 283step 10190503: L=a+n = 353step 15458215: L=a+n = 409step 23255231: L=a+n = 467step 31983199: L=a+n = 526step 44015793: L=a+n = 561step 57048684: L=a+n = 628step 72950781: L=a+n = 695step 94407756: L=a+n = 755step 115883902: L=a+n = 797step 144738515: L=a+n = 881step 174956965: L=a+n = 959step 213616166: L=a+n = 1020step 254305555: L=a+n = 1061step 300757874: L=a+n = 1127step 348426178: L=a+n = 1173step 401395498: L=a+n = 1243step 466240457: L=a+n = 1318step 531172100: L=a+n = 1374step 610675498: L=a+n = 1448step 690166371: L=a+n = 1507step 784529510: L=a+n = 1571step 877484799: L=a+n = 1619step 991186624: L=a+n = 1717step 992752469: L=a+n = 1717step 995490946: L=a+n = 1717step 999395039: L=a+n = 1717
W (x=110, y=111, |=00)last x3yyx3y4x3y3x
not plottable
Template comparisonIndBECv1.v Others: partly applies · the nearest solved proof, what carries over, and the transitions that differ
01
A1RB1RF
B1LC1RE
C---0LD
D1LE0LD
E1RA0RF
F0RE0LB

differs from the template

file
IndBECv1.v:576
module
Others (nonhalt7)
machine
1LB1LF_1RC1LB_---0RD_1RE0RD_1LA0LF_0LE0RB (11 transitions apart)
diff
1 transition up to mirror: B1 = 1RE (ours) vs 1RB (template)
note
Its config_BEC ex-rule (r 1 B> 1^n 0 l -> r <D 0^(n+1) 1 l) holds 24/24 on it, 2/24 on ours (n=0 only). Method fits (binary inc), certificate doesn't; BECv7 TM1 shape also fits.
Proof strategy & riskshow the formal proof will go · 3 risks to watch

Rules on G(a,n,Q): T by ind over trips with a binary-inc side lemma on Q (3-cell digits); reset lemmas split on n in {1,2} and Q's low digits; nonhalt via progress_nonhalt_cond with 'Q in a regular language'. Cheap first try: IndBECv1 solve_hlin_nonhalt on the mirrored TM with config_BEC/config_BEC_Pos, block 3, d1=[1;0;0]; fallback BECv7 TM1 Longitudinal/tail style.

  • ▲Q carries a growing low-digit stack (13 to 27 blocks by 1e9); need a closed regular language for it
  • ▲Reset branches on Q's low digits: natural dL=1 if L even (98/98), 2-25 if L odd; all branches must be safe
  • ▲Template certificate does not transfer; decider may need new ex-rule params or fail
Stats & provenance109 steps simulated · 5,210 cells · the status in full · files
simulated
109 steps
tape
5,210 cells · 2,940 nonzeros
growth
L=a+n: 83 at 1.8e5, 1717 at 1e9 (~t^0.35); ~276 phases by 1e9
status now
Deepen 2: re-alignment transient solved exactly (PROC rule, 11,500/11,500), and the phase-level closed-form orbit (exact against the trip-level orbit at 4,871/4,871 resets to 2.4e7 trips) runs to L = 6.9e7 with no race lost. Non-halting reduces to an arithmetic race: the invariant W <= bitlen(L)-1 wins it but breaks after rare overflow phases near L ~ 2^k, and the aftermath depends on history-built widths and bits (pseudo-random). Closest race missed by 0.9998 bits at L' = 2^22 - 692. Stop or continue? (Route: overflow-aftermath lemma, see notes.md Deepen pass 2.) (status.json, 2026-10-10)
observer's note
Mechanism found and core rules validated; not a cryptid: values grow polynomially and every probed reset branch is safe
files
observe.json · notes.md · status.json

Proof & checks

No proof work yet.

Files

machines/<tm>/: 6 entries · raw notes, status, scripts, images

namesizechanged
notes.md ↓19 KB2026-10-10 06:29
status.json ↓718 B2026-10-10 06:28
observe.json ↓12 KB2026-10-10 04:41
deepen.json ↓7.8 KB2026-10-10 06:29
img/14 items2026-10-10 01:54
scripts/15 items2026-10-10 06:25
status.json in full
{
 "tm": "1RB1RF_1LC1RE_---0LD_1LE0LD_1RA0RF_0RE0LB",
 "status": "CRYPTID_CANDIDATE",
 "stage": "deepen2",
 "updated": "2026-10-10",
 "reason": "Deepen 2: re-alignment transient solved exactly (PROC rule, 11,500/11,500), and the phase-level closed-form orbit (exact against the trip-level orbit at 4,871/4,871 resets to 2.4e7 trips) runs to L = 6.9e7 with no race lost. Non-halting reduces to an arithmetic race: the invariant W <= bitlen(L)-1 wins it but breaks after rare overflow phases near L ~ 2^k, and the aftermath depends on history-built widths and bits (pseudo-random). Closest race missed by 0.9998 bits at L' = 2^22 - 692. Stop or continue? (Route: overflow-aftermath lemma, see notes.md Deepen pass 2.)"
}