Busy Beaver Explorer / holdouts / 1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB---
What is known about 1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB---
1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB---
Decided by an outside Rocq proof: it haltsA Rocq proof in busycoq pull request 102 (open, not yet reviewed by the maintainer) was compiled here, on busycoq's own definitions, with no axioms beyond Coq's own. It is their proof, not one written in this repository; the ledger below says what this repository checked on its own.
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. This page lists what has been established about it, sorted by what each result rests on.
Status as of 19 November 2026.
In short
Decided by an outside Rocq proof: it halts. Busycoq pull request 102 (valu42, 2026-11-18) proves this in Rocq, and we compiled it here with Coq 8.20.1 on busycoq's BB6 branch: it uses no axioms (Print Assumptions), and its transition table is this machine. It reuses this repository's Coq port of DeepMind's PR 93 engine (built for 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---), started from a renamed state, and runs it to the halt. It is their proof, on busycoq's definitions of a machine and of halting, and busycoq's maintainer has not yet reviewed it. Everything else on this page is what this repository found on its own, which by itself leaves the question open.
It halts, proved in Coq (theorem halt : halts tm c0 on busycoq's definitions, no axioms). With its states renamed, its table is 1RB1RA_1LC0RD_1LD1LB_1RA0LE_0LB0LF_0RA--- started in state D, one transition away from the table DeepMind proved halting in busycoq PR 93. DeepMind's fast engine, changed for that transition as for 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD--- (the same table started in B), reaches a halting configuration from state D after 688,228 engine steps, on a tape of about 26326 cells.
What it does. Before the halt the run is a cascade of halving runs: each round turns a run of n equal blocks into about n/2 blocks one level up. In the first 109 steps D read a 0 about 21,000 times, always one cell short of a halt. That description comes from simulation; the halt does not depend on it.
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/1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB---/coq. Coq 8.18.0 compiles it and Print Assumptions reports no axioms; the build log is next to the files. The proof of 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD--- (DeepMind's busycoq pull request 93 engine changed for T4) with the table, the state map, the start (D) and the final run (run_pow 20) changed; the proved engine's run from blank tape, 688,228 engine steps, is one evaluation of about 12 hours. The generator is tools/coq/t4engine/proof/mkD.py.
An outside Rocq proof, compiled here: it halts
busycoq pull request 102 (valu42, 2026-11-18) contains a Rocq proof that this machine halts (verify/M_1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RBHHH.v). The pull request is open: not merged and not reviewed by the maintainer. We compiled the file on busycoq's BB6 branch (commit 33209bc) with Coq 8.20.1 on 19 November 2026, in 49618 s: the theorem halt : halts tm c0 is stated on busycoq's own definitions of a machine and of halting, Print Assumptions reports no axioms, and the file's transition table is this machine. It is their proof, not one written in this repository. The verdict on this page rests on this 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
The sweeps' shift rules
Moving right, A (with 1 0 behind it) and C (with 1 behind it) turn each pair 11 into 01, 6 steps a pair: a run of 2n ones becomes (01)n. Moving left, C (facing a 0) and D (facing a 1) turn each 01 back into 11, 2 steps a pair. B runs over 1s. Each holds for every n and every surrounding tape.
b_run, a_halve, c_halve, c_double, d_double, lean/Rules.lean
The shape of a halt
From 1 1 1 D> 0 the machine reaches F on a 1 in 3 steps and halts on the next. Conversely (by reading the table, not formalized) F is entered only from E on a 1, E only from A on a 1, and A has a 1 to its left only when it came from D on a 0, so every halt comes this way.
halt_shape, halt_after_shape, lean/Rules.lean
It halts: DeepMind's engine, changed for this table, proved in Coq
The engine of busycoq PR 93, with the four rules that pass through F0 changed and every lemma built on them redone (the proof of 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---, retargeted to this table and start D), reaches a halting configuration from blank tape after 688,228 engine steps, on a tape of about 26326 cells. Coq 8.18.0 checks the run in one evaluation (about 12 hours); Print Assumptions halt: closed under the global context.
halt, coq/H67137.v; generator tools/coq/t4engine/proof/mkD.py
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 37,754 cells have been visited and 23,316 of them hold a 1.
holdouts/triage.json
Near misses: D reads a 0 next to exactly two 1s
In the first 109 steps D reads a 0 20,887 times with 1 1 0 to its left (one 1 short of a halt) and 147 times at the blank left end; never with three 1s.
c/halt_nbhd.c (./halt_nbhd M 1000000000 D 0)
No closed tape language from short windows
bbtools.ctl with windows of K = 3, 4, 5, 6 cells finds a closed set, but every one allows a halt (72 to 145 halting abstract configurations); n-gram CPS (widths 3 to 7, with history and LRU) also fails.
tools/py/bbtools/ctl.py; tools/c/ngramcps.c (run for the G02 group, not stored here)
The four rules where it departs from DeepMind's halting sibling
The four changed macro rules are proved in Lean for 1RB1RD_1LC0RE_1LD1LC_1RA0LB_0RD0RF_0LC---, the same table started in state C; they are statements about the table, so they hold here after the renaming of states, which is not itself checked in Lean.
holdouts/1RB1RD_1LC0RE_1LD1LC_1RA0LB_0RD0RF_0LC---/lean/T4Rules.lean
Related holdouts
The same table as 1RB1RD_1LC0RE_1LD1LC_1RA0LB_0RD0RF_0LC--- up to renaming and mirroring, started in another state; no common configuration in the first 107 steps of each. The same table as 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD--- up to renaming and mirroring, 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 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.069). Right of the start it 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.504).
tools/py/bbtools/triage.py
Rounds and the halving law
Sample the run when the head is in A at the left end of the tape (rounds; consecutive samples about 1.25 times further apart). At every sample the tape is a list of blocks 1k 00, almost all with k = 6j+1 and grouped in long runs of equal blocks, lowest level at the right. Between consecutive rounds a run of n blocks of level j becomes a run of ⌊n/2⌋−1 to ⌈n/2⌉+1 blocks of level j+1 (checked for every run of at least 10 blocks after the first 3·106 steps, to 1.7·109), and a new run of level-0 blocks 100 appears, alternately about 0.65 and 1.9 times the previous one. A few odd blocks (k = 5, 11, 17, ...) sit between the runs.
c/samples.c, py/rounds.py
Within a round: an expanding bouncer
After the left-end sample the head runs right to a point well inside the tape and then zig-zags in a window whose left edge creeps left and right edge creeps right (by a few cells per bounce, using the halving and doubling rules above), until the window reaches the left end: the next sample. This is where the square-root growth on the right comes from.
head-position trace of one round (286,681,948 to 356,669,437)
No halt in the first 1.90×1014 steps of an accelerated run
Observed, not proved: the accelerated simulator rsim.py ran 1.90×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 6,642 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/1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB---/lean/check.sh
gcc -O2 -o triage tools/c/triage.c && ./triage 1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB--- 1000000000
gcc -O2 -o samples holdouts/1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB---/c/samples.c && ./samples 1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB--- 2000000000 A L 0 100000 > left.txt && python3 holdouts/1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB---/py/rounds.py left.txt
sh holdouts/1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB---/coq/build.sh /path/to/busycoq # the Coq proof; a checkout of busycoq's BB6 branch; about 12 hours