Busy Beaver Explorer / holdouts / 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---
What is known about 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---
1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---
Decided: it haltsProved in this repository, checked by Coq on busycoq's own definitions of a machine and of halting (there is no Lean proof of the whole run). The ledger below says what each part rests on.
This six-state, two-symbol Turing machine, one of the holdouts of the BB(6) search, halts when started on a blank tape. The halt is a Coq theorem on busycoq's definitions: an engine over macro words, every step of it proved sound, runs from the blank tape to a halting configuration, and Coq's kernel checks that run. This page lists what has been established about the machine, sorted by what each result rests on.
Status as of 18 November 2026.
In short
It halts, proved in Coq (theorem halt : halts tm c0 on busycoq's definitions, no axioms). The proof is DeepMind's fast engine of busycoq PR 93, built for the table one transition away, with the four rules that pass through that transition changed and every proof built on them redone. Run from blank tape, the proved engine reaches a halting configuration (F on a 1) after 261,156 of its steps, on a tape of about 22410 cells; no simulator could get there step by step.
What it does. The tape holds a counter (100)^n and a list of runs of 1s of lengths 7, 13, 19, … (6k+1). The run goes in epochs: in each, the number of runs of every length is halved and they move up one length, half the counter becomes new runs of 7, and the new counter is about 5/2 times the old number of runs of 7; so everything grows by 5/4 every two epochs, and the step count by 25/16. These rules hold only up to small corrections (a run more or less, odd runs between the groups), which is why the community calls this a chaotic Bell. The machine halts exactly when state B reads 0 1 1 1 (B0 C1 E1 put F on a 1; the path is proved in Lean). An exact accelerated simulator, validated against direct simulation, finds no halt in 7.9×1014 steps. Its F-event differs from the one of the other three machines (it writes 1 1 1 1 and leaves B, they write 1 0 0 0 and leave A), so its tapes are not theirs, but the structure and the growth law are the same.
Other proofs and outside reports
Proved in Coq
The proof: halt : halts tm c0, stated on busycoq's own definitions of a Turing machine and of halting, in holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/coq. Coq 8.18.0 compiles it and Print Assumptions reports no axioms; the build log is next to the files. It is DeepMind's proof of busycoq pull request 93 (the fast engine over macro words, built for the table one transition away), with the four rules that pass through F0 changed and every lemma built on them redone; the proved engine's run from blank tape, 261,156 engine steps, is one evaluation of about 33 minutes. The generator is tools/coq/t4engine/proof.
Community label
In the community's BB(6) tracker the machine's class is Chaotic Bell Class 1. These are labels read off the run by others, not results.
What each result rests on
kernel Proved in Lean, kernel-checked
The halting configurations
The machine stops exactly when it reads the symbol of a halting transition (F1); the generated statement covers every configuration.
step_none_iff, lean/Blank.lean
No halt in the first 10,000 steps
The list simulator of the shared library, proved to agree with the machine's semantics, runs 10,000 steps from blank tape without a halt, evaluated by Lean's kernel.
blank_runs_kernel, lean/Blank.lean
9 shift rules
For every n, the head crosses n copies of a short word in a fixed number of steps per copy and leaves another word behind (for example the head crossing (100)^n or (1)^n; these are the sweeps over the counter and the runs). Generated and proved by bbtools.symtm, checked by Lean's kernel.
lean/Rules.lean, generated by holdouts/1RB0LB_1RC0LA_1LB0RD_1RE1RD_1RB1RF_1LA---/py/rules.py
The local paths and the halting path
Outside the sweeps, the machine does a handful of local things, each proved for every tape around it: A on a 1 bounces (bounce_on_1, bounce_on_0_0, bounce_on_0_1); B reading 0 1 1 0 gives 1 1 1 1 with B on the right (8 steps: B0 C1 E1 F0 D0 A0 B1 A0) (fevent, the F-event, twice per round trip in the second half of an epoch); and B reading 0 1 1 1 halts: B0 C1 E1 put F on a 1 (fevent_halt). By the table this is the only way to halt: F is entered only by E1, E only by C1, and C by B0 (moving right) or A1 (moving left; then C1 puts E on the 0 that A has just written, and E0 goes on).
lean/Paths.lean, generated by holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/gen_paths.py
The machine halts (Coq, on busycoq's definitions)
halt : halts tm c0, with busycoq's TM, halts and c0 and tm this machine's table. It is DeepMind's proof of busycoq PR 93 for the table one transition away, changed for this one: the four base rules that pass through F0 are restated and proved, and every lemma and engine case built on them is redone (the collision and defect calls, the returns, the immediate defects, the collisions and the fast right sweep, which gets one more guard). The run of the proved engine from blank tape, 261,156 engine steps to a configuration with the head in F on a 1 (a tape of about 22410 cells), is one evaluation checked by Coq's kernel (run_ok). Print Assumptions halt: closed under the global context. Coq 8.18.0, about 33 minutes.
halt, holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/coq/H155900.v (generated by tools/coq/t4engine/proof)
native Proved in Lean with native_decide
No halt in the first 107 steps
The same run, evaluated by compiled code.
blank_runs_native, lean/Blank.lean
trusted Computed, not proved
No halt in the first 109 steps
The C simulator tools/c/triage.c runs 109 steps without a halt; at the end 39,514 cells have been visited and 22,692 of them hold a 1.
holdouts/triage.json
No halt in the first 3×1010 steps
The lead's direct C simulator (tools/c/tmrun.c) runs 3×1010 steps without a halt.
tmrun 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD--- 30000000000
The exact accelerated simulator agrees with direct simulation
bell_wsim.py keeps the tape as repeated words, crosses a repeated word in one move (an exact shift rule found on the fly), and at the left turns looks for a stretch of round trips after which the tape has the same shape with counts changed by constants; it then applies many such stretches at once, with the exact step count. Its tape, state and step count were compared with a plain C simulator at 660 tapes up to 2.08×1010 steps: all equal.
holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/bell_wsim.py, py/bell_validate.py, c/tapeat.c
No halt in the first 7.9×1014 steps
The accelerated simulator runs 7.9×1014 steps from blank tape without reaching the halting transition; the list at each visit of the right end is recorded.
holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/bell_farrun.py, holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/data/far_long.json
The shared orbit
Its F-event differs from the one of the other three machines (it writes 1 1 1 1 and leaves B, they write 1 0 0 0 and leave A), so its tapes are not theirs, but the structure and the growth law are the same. The reason is in the tables: a4 does with E, F what a2 does with C, E on the bounce of A, a3 replaces the step C0 of a2 by three steps with the same result, and all three turn B> 0 1 1 0 into 1 0 0 0 A>. They could part only where B reads 0 1 0 (a2 and a4 differ there: b_010), 0 1 1 1 (a2 and a4 halt, a3 goes on) or 0 0 1 (a3 halts); in 109 steps of a2 and a4, B never reads 0 1 0 and reads 0 0 only at the blank right end.
lean/Paths.lean; data/far_1e14.json of the four machines
Neighbours and other starts
The community tracker calls it “Chaotic Bell with a neighbour that halts”. Indeed: a1 has E1 = 0RF, F0 = 0LD and a2 has E1 = 1RF, F0 = 0LC; the two mixed tables (E1 = 1RF with F0 = 0LD, and E1 = 0RF with F0 = 0LC) both halt at step 1,272 from blank tape. (Direct runs of 3×107 steps of every table that differs in one transition, and of the six start states.)
holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/c/neighbours.c
Related holdouts
The same table as 1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB--- up to renaming and mirroring, started in another state; no common configuration in the first 107 steps of each. The same table as 1RB1RD_1LC0RE_1LD1LC_1RA0LB_0RD0RF_0LC--- up to renaming, started in another state; no common configuration in the first 107 steps of each.
holdouts/related.json, written by holdouts/related.py compute (tools/c/cfgmatch.c, tools/c/lockstep.c)
heuristic Evidence only
Growth shape: exp/sqrt
Left of the start, the visited part of the tape grows like the square root of the step count, the signature of a head sweeping back and forth across the whole tape and adding a cell or a few at the end of each sweep (a bouncer-like shape) (fitted exponent 0.509). Right of the start it grows like the logarithm of the step count: each new cell costs a roughly constant factor more time, the signature of a counter or of a Collatz-like map whose values are written on the tape (fitted exponent 0.11).
tools/py/bbtools/triage.py
The epoch law
Read off the recorded lists, not proved: with n the counter and c7, c13, … the numbers of runs, one epoch gives c7′ ≈ n/2, c6j+7′ ≈ c6j+1/2 (the half, or one or two less) and n′ ≈ (5/2)·c7 (within 10−4 at 1014 steps). Hence the two interleaved geometric series in the table of counts, the factor 5 per +12 in length, growth by 5/4 every two epochs and step counts growing by 25/16. Between the groups sit a few odd runs that change from epoch to epoch without a visible rule; they are the chaotic part, and the halting pattern can only arise there.
data/far_1e14.json
Where B reads 0 1 1
In the first 109 steps of a2 state B reads 0 1 1 20,972 times; in 20,941 of them the cells around are 111101[0]110101, in 29 001101[0]110101, and twice (steps 104 and 1,264) something else; the next cell is always 0. a1 has 20,998 such events with the windows 111100[0]110101 and 001100[0]110101. So after the first 1,300 steps the F-events seen are all of two harmless kinds; whether that holds for ever is the open question.
direct C runs (not kept in the repository)
No halt in the first 1.28×1014 steps of an accelerated run
Observed, not proved: the accelerated simulator rsim.py ran 1.28×1014 steps from blank tape without reaching a halting transition. Its tape, state and head position were equal to those of a plain C simulator at 6 checkpoints, the last at 1.00×1010 steps. Of these steps, the part after the last checkpoint rests on the simulator alone, including 11,073 trip-level jumps: a jump applies many identical round trips at once after seeing the same tape shape recur with constant count changes, which is validated against direct simulation but not proved.
holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/rsim.py, holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/rsim_screen.py, holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/data/rsim_screen.json
open Open
Nothing yet.
Check it yourself
. /etc/profile.d/lean.sh # after scripts/setup-lean.sh
holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/lean/check.sh
gcc -O2 -o triage tools/c/triage.c && ./triage 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD--- 1000000000
python3 holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/gen_paths.py --check
python3 holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/bell_farrun.py 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD--- 1e12 # the accelerated run, about two minutes
sh holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/coq/build.sh /path/to/busycoq # the Coq proof; a checkout of busycoq's BB6 branch; about 33 minutes
sh tools/coq/t4engine/proof/build.sh /path/to/busycoq fast # regenerate H155900.v from PR 93's file (fast: final run admitted)