Busy Beaver Explorer / holdouts / 1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE
What is known about 1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE
1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE
OpenNobody has proved whether this machine halts. Everything below is what is known so far.
Nobody knows whether this six-state, two-symbol Turing machine halts when started on a blank tape: it is one of the holdouts left open by the bbchallenge project. This page lists what has been established about it, sorted by what each result rests on.
Status as of 8 November 2026.
In short
The question is open. Each sweep of the head turns the period-3 background into its complement (010 ↔ 101, 100 ↔ 011, 001 ↔ 110; six shift rules proved in Lean). Read when the head is at the right end in state B, the tape is (100)^x 1011 (010)^a1 11 (010)^a2 11 … (010)^n 01: the last block n loses 2 copies per visit, the inner blocks lose 4, 4, 12, 20, … (one block stays at 100 or 120 for a long time), new blocks appear behind the front counter x, which often doubles or drops by 5 from one visit to the next like a binary counter. When the last block is used up, 120 1101 turns into a new last block of 119. No closed map yet.
Other proofs and outside reports
Community label
In the community's BB(6) tracker the machine's class is Skelet 1-like 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 (F0); 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
Complementing shift rules
C, A and D cross (010)^n, (100)^n, (001)^n to the left and B, E, A cross (110)^n, (101)^n, (011)^n to the right, 3n steps each, for every n.
c_left … a_right, lean/Rules.lean
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 83,871 cells have been visited and 30,719 of them hold a 1.
holdouts/triage.json
No halt in the first 3·1010 steps
A plain C simulator (longrun.c, on tools/c/tm.h) runs 3·1010 steps from blank tape without a halt; at the end the head has visited cells -628,527 to 98 and 334,129 cells hold a 1.
holdouts/1RB---_1RC0RA_1LD0RB_0LE0LC_1RE1LF_0RD0RB/c/longrun.c
No halt in the first 7.58×1018 steps (exact macro run)
A macro simulator (blocks of 6 cells, long runs of equal blocks crossed in one go; exact: every macro step is a run of the machine, counted step for step) ran from blank tape to step 7,587,642,535,440,762,669 without a halt. At this block size it gives the same state, head position and tape as the direct simulator after 2,000,004,784 steps. This is a bounded run and says nothing about later steps.
python3 holdouts/1RB0LB_1RC0LA_1LB0RD_1RE1RD_1RB1RF_1LA---/py/deep.py run 240, verify; holdouts/1RB0LB_1RC0LA_1LB0RD_1RE1RD_1RB1RF_1LA---/data/deep.json
The list at the right-end visits
Read off the direct run to 3·107 steps: the last block goes 54, 52, 50, … (minus 2 per visit); a block of 100 (later 120) sits in front of it for many visits while the blocks before it shrink by 4, 4, 12, 20; the front counter runs 245, 490, 485, 970, 965 (doubling and subtracting 5 in turn) and moves differently when a new block is born
README.md
No halt in the first 1.41×10116 steps (region-memo accelerator)
The region-memo accelerator tools/py/bbtools/regaccel.py ran with blocks of 3 cells, from blank tape for 1200 seconds and reached step 1.41×10116 without a halt. It keeps the tape run-length coded and, for each stretch of tape from the left end, a macro (the run until the head first leaves that stretch) computed by a symbolic run of the machine with the long runs as variables; a macro is used only when the linear inequalities its symbolic run assumed hold, otherwise the stretch is run again by the same recursion. So the run is exact, step count included. Check: 47 configurations of this run (every time the head faced blank tape on the right, up to 2×109 steps) agree cell for cell with a direct run (tools/py/regcheck.py). This is a bounded run and says nothing about later steps.
python3 tools/py/bbtools/regaccel.py 1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE 3 1200; holdouts/regaccel.json
Related holdouts
The same table as 1RB1RD_1RC1RB_1LD0RA_1RA0LE_1LF0LC_---1LE 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 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.463). 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.047).
tools/py/bbtools/triage.py
Deterministic counter, no sign of a halt
The front counter behaves much like a binary counter (double, or subtract 5) and every other count moves by fixed amounts per visit; nothing points to the halting transition (F reading 0) being reached.
README.md
open Open
Does it halt from blank tape?
Not known. The block list is understood one visit at a time; the front counter and the birth of new blocks have not been reduced to a map.
README.md, Further work
Check it yourself
. /etc/profile.d/lean.sh # after scripts/setup-lean.sh
holdouts/1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE/lean/check.sh
gcc -O2 -o triage tools/c/triage.c && ./triage 1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE 1000000000
python3 holdouts/1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE/py/gen_rules.py # rewrites lean/Rules.lean