BB(6) hunt
Machines / #10

1RB0RF_1RC1RF_1LD1RA_---0LE_1LA0LE_0RA0LC

#10Claimed elsewhereBell eats counterbbchallenge ↗Explorer

Upstream result

Claimed elsewhere

The blank-start machine never halts: BECv10.v.TM34 ↗. 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

Mirrored FractalBEC bounce+counter; C1 makes the eat partial: N grows +1/+3/+4+r per epoch, leftovers ride along

Upstream
The blank-start machine never halts: BECv10.v.TM34 ↗. Recorded commit time: 2026-10-13T13:42:06Z. First public push time is not established.
Status
Externally Solvedinformal proof · updated 2026-10-10Parked · Funded stage lemma_x (Dennis 2026-10-10) ended at its pre-agreed exit: the excursion entries do not close into a finite list of safe types, so #10 is flagged CRYPTID_CANDIDATE. The 2 open questions are optional.
idle since Oct 10 13:18 · status.json 2026-10-10
Informal proof
proof.mdconditional; see Proof for what is still open
Class
Bell eats counterours: Bell eats counter (sheet) · ours adds: partial eat (leftover digits ride in next counter) · med confidence
On the list
not on BB6_holdouts_663.txt (line 611 of the previous list) · historical 740 line 611
#10eqv ×1sim 1e15
Your calls on file 3
funded
option: lemma_x · date: 2026-10-10
next
Cryptid protocol: AntiHydra-style Rocq rule reduction of the rule layer (proof.md 1-4, 2.5) at low priority, as for the other cryptid candidates. The twin 1RB0RE_1RC1RE_1LD1RA_1LA0LD_0RA0LF_1LD--- shares the verdict.
2026-10-10 · lemma_x
Fund one more stage on Lemma X (classify the excursion entries exactly), on the condition that if the entry types do not close into a finite list within the stage, #10 gets flagged CRYPTID_CANDIDATE? (Dennis: go with all recommendations (2026-10-10))

Mechanism

How it works: 3 notes
  • Mirror of FractalBEC tm10: blocks (110)^a 0 (011)^b on the left, a binary counter on the right; each bounce adds 1.
  • C1 differs: when b runs out the bell eats the counter only partly, so N grows by 1, 3 or 4+r per epoch, never doubles.
  • Uneaten digits stay as inert 1s inside the next counter (residue); carries pass straight through them.

Figures for Checkpoint A

Fig 1 · Ours (left) vs the FractalBEC template (right)Q1

Both panels: one row per entry into C moving right. Compare the down-right diagonals: how many, how long.

Ours (left) vs the FractalBEC template (right)
bbchallenge-defaultStart blankRows both machines from the blank tapeWindow cells -337..0, 1 px = 1 cellColors 1 0 or never visited head (just moved right) padding
Rows: steps 0..300,000; one row per entry into state C moving right: ours 2,161 rows, template 1,497 (dark grey below it = no more rows). Not evenly spaced in time, and row k is a different step in each panel · Window: counted from the right edge (each panel pins its own rightmost visited cell to its last column): ours = absolute cells -50..287 at step 300,000; the template panel is 779 cells wide (absolute -16..762); 24 px dark-grey gap between the panels · Colors: left = ours, right = FractalBEC tm10 mirrored (1RB0RF_1RC1RF_1LD1RB_---0LE_1LA0LE_0RA0LC, only C1 differs); Each down-right diagonal = one epoch (the 0-marker crossing the blocks): ours has 25 epochs by step 300,000, each a little longer than the last; the template has 8, each ~4x longer
Fig 2 · Right-edge zoom: counter digits and residueQ2viewer ↗

The counter at the right edge. Watch the isolated 1s between its digits while carries pass.

Right-edge zoom: counter digits and residue
bbchallenge-defaultStart blankRows one per entry into state C moving rightWindow cells -89..0, 1 px = 1/3 cellColors 1 0 or never visited head (just moved right)
Rows: steps 0..23,000 (422 rows; 1 row = 3 px tall); not evenly spaced in time · Window: (1 cell = 3x3 px), counted from the right edge (each row's rightmost visited cell is 0, pinned to the last column; it is absolute cell 112 at step 23,000)
More figures (3)Fig 3–5: Left/right records to 100M steps · bbchallenge default view, first 10,000 steps · Blaze, 10 million steps
Fig 3 · Left/right records to 100M stepsviewer ↗

The right edge gains 2,083 cells, the left only 276.

Left/right records to 100M steps
bbchallenge-defaultStart blankRows the start, then one per new leftmost or rightmost cellWindow cells -276..2,083, 1 px = 1 cellColors 1 0 or never visited head on a new right/left cell
Rows: (2,360 rows, steps 0..100,000,000); not evenly spaced in time
Fig 4 · bbchallenge default view, first 10,000 stepsviewer ↗

The site's view: a bouncer growing mostly to the right.

bbchallenge default view, first 10,000 steps
bbchallenge-defaultStart blankRows every step: steps 0..9,999 squeezed into 500 px rows as on bbchallenge.orgWindow cells -200..199, 1 px = 1 cellColors 1 0 or never visited head after a right/left move
Rows: each px row blends steps 20y+9 and 20y+10, so 1 px row = 20 steps · Colors: red/green: pale colours = blended by the squeeze
Fig 5 · Blaze, 10 million stepsviewer ↗

One smooth bell, no chaotic edge.

Blaze, 10 million steps
bbchallenge-blazeStart blankRows time blocks of 16,384 stepsWindow cells -138..946, 1 px = ~1.4 cellsColors 0 1
Rows: averaged (611 blocks, steps 0..10,000,000), stretched to 500 px: 1 px ~ 20,000 steps · Window: Blaze averages 1 cell per column; its 1,085 columns are stretched to 800 px · Colors: in-between shades = both mixed inside the pixel's block (averaged); no head
Rules (5/5 validated)exact tape rewrites the proof will formalize, each re-checked by simulation
rulefrom ⟶ tocasesstepschecked
R1c bounce, clean counter
0∞ (110)a 0 (011)b+1 C> enc(a) 0∞
⟶ 0∞ (110)a+1 0 (011)b C> enc(a+1) 0∞
a>=1, b>=1. enc(v) = v0 010 (00 v1)(00 v2)...(00 vk), LSB first, trailing 0s trimmed; covers top-digit overflow at a=2^k-18b+8, plus 6t+8 if t>0 (t = trailing 1-bits of a)✓127/127
R1g bounce, any counter word
0∞ (110)a 0 (011)b+1 C> X 0∞
⟶ 0∞ (110)a+1 0 (011)b C> X' 0∞
b>=1; X = counter words with residue sampled from epochs N=37 and N=331; X' depends on X only (a,b inert; tested a<=3000, b<=1500)—✓160/160
E0 epoch end, N even (clean start)
0∞ 110 0 (011)N-1 C> 101 0∞
⟶ 0∞ 110 0 (011)N C> 110 enc3(N/2) 0∞
N even, N>=2. enc3(m) = (00 m0)(00 m1)... LSB first. N' = N+1. ~4N^2 steps—✓60/60
E1 epoch end, N = 3 mod 4 (clean start)
0∞ 110 0 (011)N-1 C> 101 0∞
⟶ 0∞ 110 0 (011)N+2 C> F((N+1)/4) 0∞
N = 3 mod 4. F(v) = 1 0 v0 (00 v1)(00 v2)..., F(0) = 1. N' = N+3—✓40/40
E2 epoch end, N = 1 mod 4 (clean start)
0∞ 110 0 (011)N-1 C> 101 0∞
⟶ 0∞ 110 0 (011)N+3+r C> F(N >> (3+r)) 0∞
N = 1 mod 4; r = run of 1-bits of N starting at bit 2 (r=0..7 tested). N' = N+4+r. N up to 14077—✓50/50
Compressed historythe tape as 0∞ <E (010)n T 0∞ at 37 moments: where the rules are read off
0∞ <E (010)n T 0∞
stepn (left record; next epoch has N = n+1 blocks)dn (to next left record)T (residue word)
5021
27231
103511
30165101,001
671111101
1,409126110,000,001,001
2,547183101,000,001
4,311211110,001,000,001
6,6372231.1·1020
9,2632511.1·1016
12,49526101.1·1022
16,755368110,001,000,001
22,985446101
31,741503101
68,6635711.1·1019
142,521831101
325,1611124101,001
633,5491391101,000,000,001
1,700,85718111.1·1053
3,550,43124271.1·1026
6,445,689298131.01·1023
10,785,35135511.1·1038
16,752,94541491.01·1035
35,427,99553311.1·1053
64,344,18965241.1·1059
106,333,873778131.1·1053
164,740,06192511.01·1017
242,559,0511,04841.1·1038
341,501,5351,17251.1·1044
463,868,3971,29491.1·1065
615,487,0431,446231.1·1068
704,637,8871,52461.1·1047
802,671,7791,60481.1·1038
910,235,9791,68061.1·1032
967,799,2751,70651.1·1059
979,514,9131,71111.1·1065
991,319,5991,712?1.1·1083
n (left record; next epoch has N = n+1 blocks)last 1,712
1,712059.9e8log xstep 5: n (left record; next epoch has N = n+1 blocks) = 0step 27: n (left record; next epoch has N = n+1 blocks) = 2step 103: n (left record; next epoch has N = n+1 blocks) = 5step 301: n (left record; next epoch has N = n+1 blocks) = 6step 671: n (left record; next epoch has N = n+1 blocks) = 11step 1409: n (left record; next epoch has N = n+1 blocks) = 12step 2547: n (left record; next epoch has N = n+1 blocks) = 18step 4311: n (left record; next epoch has N = n+1 blocks) = 21step 6637: n (left record; next epoch has N = n+1 blocks) = 22step 9263: n (left record; next epoch has N = n+1 blocks) = 25step 12495: n (left record; next epoch has N = n+1 blocks) = 26step 16755: n (left record; next epoch has N = n+1 blocks) = 36step 22985: n (left record; next epoch has N = n+1 blocks) = 44step 31741: n (left record; next epoch has N = n+1 blocks) = 50step 68663: n (left record; next epoch has N = n+1 blocks) = 57step 142521: n (left record; next epoch has N = n+1 blocks) = 83step 325161: n (left record; next epoch has N = n+1 blocks) = 112step 633549: n (left record; next epoch has N = n+1 blocks) = 139step 1700857: n (left record; next epoch has N = n+1 blocks) = 181step 3550431: n (left record; next epoch has N = n+1 blocks) = 242step 6445689: n (left record; next epoch has N = n+1 blocks) = 298step 10785351: n (left record; next epoch has N = n+1 blocks) = 355step 16752945: n (left record; next epoch has N = n+1 blocks) = 414step 35427995: n (left record; next epoch has N = n+1 blocks) = 533step 64344189: n (left record; next epoch has N = n+1 blocks) = 652step 106333873: n (left record; next epoch has N = n+1 blocks) = 778step 164740061: n (left record; next epoch has N = n+1 blocks) = 925step 242559051: n (left record; next epoch has N = n+1 blocks) = 1048step 341501535: n (left record; next epoch has N = n+1 blocks) = 1172step 463868397: n (left record; next epoch has N = n+1 blocks) = 1294step 615487043: n (left record; next epoch has N = n+1 blocks) = 1446step 704637887: n (left record; next epoch has N = n+1 blocks) = 1524step 802671779: n (left record; next epoch has N = n+1 blocks) = 1604step 910235979: n (left record; next epoch has N = n+1 blocks) = 1680step 967799275: n (left record; next epoch has N = n+1 blocks) = 1706step 979514913: n (left record; next epoch has N = n+1 blocks) = 1711step 991319599: n (left record; next epoch has N = n+1 blocks) = 1712
dn (to next left record)last ?
23159.8e8log xstep 5: dn (to next left record) = 2step 27: dn (to next left record) = 3step 103: dn (to next left record) = 1step 301: dn (to next left record) = 5step 671: dn (to next left record) = 1step 1409: dn (to next left record) = 6step 2547: dn (to next left record) = 3step 4311: dn (to next left record) = 1step 6637: dn (to next left record) = 3step 9263: dn (to next left record) = 1step 12495: dn (to next left record) = 10step 16755: dn (to next left record) = 8step 22985: dn (to next left record) = 6step 31741: dn (to next left record) = 3step 68663: dn (to next left record) = 1step 142521: dn (to next left record) = 1step 325161: dn (to next left record) = 4step 633549: dn (to next left record) = 1step 1700857: dn (to next left record) = 1step 3550431: dn (to next left record) = 7step 6445689: dn (to next left record) = 13step 10785351: dn (to next left record) = 1step 16752945: dn (to next left record) = 9step 35427995: dn (to next left record) = 1step 64344189: dn (to next left record) = 4step 106333873: dn (to next left record) = 13step 164740061: dn (to next left record) = 1step 242559051: dn (to next left record) = 4step 341501535: dn (to next left record) = 5step 463868397: dn (to next left record) = 9step 615487043: dn (to next left record) = 23step 704637887: dn (to next left record) = 6step 802671779: dn (to next left record) = 8step 910235979: dn (to next left record) = 6step 967799275: dn (to next left record) = 5step 979514913: dn (to next left record) = 1
T (residue word)last 1.1·1083
1.1e83159.9e8log-logstep 5: T (residue word) = 1step 27: T (residue word) = 1step 103: T (residue word) = 1step 301: T (residue word) = 101001step 671: T (residue word) = 101step 1409: T (residue word) = 110000001001step 2547: T (residue word) = 101000001step 4311: T (residue word) = 110001000001step 6637: T (residue word) = 110001010010001000001step 9263: T (residue word) = 11001000000100101step 12495: T (residue word) = 11001000100000101000101step 16755: T (residue word) = 110001000001step 22985: T (residue word) = 101step 31741: T (residue word) = 101step 68663: T (residue word) = 11001000000100100101step 142521: T (residue word) = 101step 325161: T (residue word) = 101001step 633549: T (residue word) = 101000000001step 1700857: T (residue word) = 1.1e53step 3550431: T (residue word) = 110010001000010001001001001step 6445689: T (residue word) = 101010000010001000000001step 10785351: T (residue word) = 110010010010000001000010010001001000001step 16752945: T (residue word) = 101010010010010010001001000000001001step 35427995: T (residue word) = 1.1e53step 64344189: T (residue word) = 1.1e59step 106333873: T (residue word) = 1.1e53step 164740061: T (residue word) = 101000001010001001step 242559051: T (residue word) = 110010000000001010001000000000000000001step 341501535: T (residue word) = 1.1e44step 463868397: T (residue word) = 1.1e65step 615487043: T (residue word) = 1.1e68step 704637887: T (residue word) = 1.1e47step 802671779: T (residue word) = 110000010010001000000000001000000001001step 910235979: T (residue word) = 110000010010000001000001000001001step 967799275: T (residue word) = 1.1e59step 979514913: T (residue word) = 1.1e65step 991319599: T (residue word) = 1.1e83
Template comparisonFractalBEC.v Section: partly applies · the nearest solved proof, what carries over, and the transitions that differ
01
A1RB0RF
B1RC1RF
C1LD1RA
D---0LE
E1LA0LE
F0RA0LC

differs from the template

file
FractalBEC.v
module
Section FractalBEC, instance nonhalt10 (line 269)
machine
1LB0LF_1LC1LF_1RD1LB_---0RE_1RA0RE_0LA0RC (11 transitions apart)
diff
mirror of tm10 = 1RB0RF_1RC1RF_1LD1RB_---0LE_1LA0LE_0RA0LC; only C1 differs: 1RB -> 1RA
note
On ours RInc 4/4 and Ov 8/8 hold; LInc fails for every odd counter (8/16, C reads LSB 1 -> 1RA) and config i -> i+1 fails 5/6. Bounce shape carries over; counter encoding and doubling epoch map do not.
Proof strategy & riskshow the formal proof will go · 3 risks to watch

BECv7/FractalBEC shape: prove R1 (shift rule + counter increment over a residue-tolerant digit word, Inductive like BECv7) with ind; then an epoch lemma K(1,N-1,X) -->+ K(1,N'-1,X') with N'>N; nonhalt via multistep_nonhalt + progress_nonhalt_cond, invariant 'X in residue language'. E0-E2 alone do not close: real orbit almost never has a clean counter.

  • ▲General epoch map with residue not found yet: dN depends on residue (N=21: clean +5, with residue +10).
  • ▲Residue language may be big: 6-factors stable (23) but 8-factors still new at epoch 178; zero runs up to 20.
  • ▲Probably 15-30 KB of Rocq (counter-with-separators encoding); twin holdout 1RB0RE_1RC1RE_1LD1RA_1LA0LD_0RA0LF_1LD--- shares the trajectory.
Stats & provenance109 steps simulated · 5,243 cells · the status in full · files
simulated
109 steps
tape
5,243 cells · 2,610 nonzeros
growth
span ~t^0.34 (1085 / 2360 / 5243 cells at 1e7 / 1e8 / 1e9); 278 epochs to 1e9, N +~6/epoch, epoch ~4N^2 steps
status now
Funded stage lemma_x (Dennis 2026-10-10) ended at its pre-agreed exit: the excursion entries do not close into a finite list of safe types, so #10 is flagged CRYPTID_CANDIDATE. Proved this stage (scripts/fs_lemmax.py, seeds 1-2, all PASS): no excursion starts at an even eat (Lemma A); an odd entry has P' <= 1.25*2^B1 (Lemma B); after a slack>=0 eat the slack fails only via a super-cascade (odd, P=2^B1), P>=2^(B1+1), or an even cascade with B(n)<B1 (R2); the even cascade is safe for any residue (EC). Fatal for a finite case analysis: the family sigma0(B)=(3*2^(B-2)-7,[3,0^(B-6),10,0,2]) satisfies everything Lemma X may assume (slack 2, no excursion; entry shape P0=15*2^(B-4)) yet reaches a super-cascade at epoch 2 and a non-normalized eat at epoch 4 for every B>=8 (exact to B=300; TM-confirmed at B=8: non-normalized eat at n=194). So safety depends on the orbit's exact residue counts solving equations like P=2^B: pseudo-random arithmetic along one orbit (ground rule 6). Heuristic for non-halting stays strong: 0 non-normalized eats in >2e9 natural eats and to 1e10 main-orbit epochs; natural entries are cascades (1,769) and w=1 near-cascades (11), never w>=2; the TM even recovers from the family's non-normalized eats (B=8,9,10). Not a kill. (status.json, 2026-10-10)
observer's note
Mechanism found and bounce + clean-epoch rules validated; not Collatz-like (branches on low bits of a linearly growing N). Open: residue dynamics.
files
observe.json · notes.md · proof.md · status.json

Proof & checks

○ Checkpoint B: no note from Dennis found

  • notes.md L67: - Checkpoint questions are now yes/no questions about the figures. Moved off the card (strategy calls, not figure reading; settle them in proof.md / Checkpoint B):
  • proof.md L468: ## Checkpoint B (Dennis)

Files

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

namesizechanged
notes.md ↓26 KB2026-10-10 13:18
proof.md ↓41 KB2026-10-10 13:18
status.json ↓1.7 KB2026-10-10 13:17
observe.json ↓13 KB2026-10-10 04:41
deepen.json ↓6.3 KB2026-10-10 13:17
data/3 items2026-10-10 00:26
decisions/1 item2026-10-10 13:17
img/10 items2026-10-10 00:25
scripts/27 items2026-10-10 13:16
check_proof.py ↓34 KB2026-10-10 07:54
qsim.jsonl ↓6.7 KB2026-10-10 00:08
rulefit.json ↓59 KB2026-10-10 00:18
rulefit.txt ↓4.3 KB2026-10-10 00:18
sim_1e9.jsonl ↓149 B2026-10-10 00:07
sim_1e9.time ↓42 B2026-10-10 00:07
status.json in full
{
 "tm": "1RB0RF_1RC1RF_1LD1RA_---0LE_1LA0LE_0RA0LC",
 "status": "CRYPTID_CANDIDATE",
 "stage": "informal_proof",
 "updated": "2026-10-10",
 "cryptid_flag": true,
 "reason": "Funded stage lemma_x (Dennis 2026-10-10) ended at its pre-agreed exit: the excursion entries do not close into a finite list of safe types, so #10 is flagged CRYPTID_CANDIDATE. Proved this stage (scripts/fs_lemmax.py, seeds 1-2, all PASS): no excursion starts at an even eat (Lemma A); an odd entry has P' <= 1.25*2^B1 (Lemma B); after a slack>=0 eat the slack fails only via a super-cascade (odd, P=2^B1), P>=2^(B1+1), or an even cascade with B(n)<B1 (R2); the even cascade is safe for any residue (EC). Fatal for a finite case analysis: the family sigma0(B)=(3*2^(B-2)-7,[3,0^(B-6),10,0,2]) satisfies everything Lemma X may assume (slack 2, no excursion; entry shape P0=15*2^(B-4)) yet reaches a super-cascade at epoch 2 and a non-normalized eat at epoch 4 for every B>=8 (exact to B=300; TM-confirmed at B=8: non-normalized eat at n=194). So safety depends on the orbit's exact residue counts solving equations like P=2^B: pseudo-random arithmetic along one orbit (ground rule 6). Heuristic for non-halting stays strong: 0 non-normalized eats in >2e9 natural eats and to 1e10 main-orbit epochs; natural entries are cascades (1,769) and w=1 near-cascades (11), never w>=2; the TM even recovers from the family's non-normalized eats (B=8,9,10). Not a kill.",
 "funded": {
  "option": "lemma_x",
  "date": "2026-10-10"
 },
 "next": "Cryptid protocol: AntiHydra-style Rocq rule reduction of the rule layer (proof.md 1-4, 2.5) at low priority, as for the other cryptid candidates. The twin 1RB0RE_1RC1RE_1LD1RA_1LA0LD_0RA0LF_1LD--- shares the verdict."
}