Busy Beaver Explorer / holdouts / 1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE / explained

A 6-state Busy Beaver machine · Status as of 8 November 2026.

Does this machine ever halt?

1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE

OpenNobody has proved whether this machine halts. Everything below is what is known so far.

Nobody knows. Each sweep of the head flips the repeating pattern of the tape into its complement; underneath, a list of blocks shrinks at fixed rates while a counter at the front doubles and feeds new blocks into the list.

Kernel6 rulesThe complementing sweeps, proved for every length.
Computed−2 per visitThe last block of the list at each right-end visit.
Computed3·1010 stepsNo halt in the C simulator.
Community labelIn 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.
Kernel proved in Lean, checked by the kernel only
native_decide proved in Lean, one evaluation trusts the compiler
Computed C or Python in the repository, tested but not proved
Heuristic evidence and estimates
Open not known
The machine

6 states, two symbols, 1 halting transition

Each entry says what to write, which way to move and which state to enter. The machine starts in A on a blank tape (all 0s).

The machine stops when it is in F reading 0. F is entered only from E0 (writes 1, moves R): E>0 0. So a halt is the moment this pattern appears, with the head on the cell after >.

statereads 0reads 1
A1 R B0 L C
B1 L C0 R E
C1 L D1 L B
D1 L A1 L D
E1 R F0 R A
Fhalt1 R E
One circle per state. A solid arrow is taken on reading 0, a dashed one on reading 1; its label is read:write move. Red marks a halting transition. Hover a state or a row to single out its arrows.
Follows the simulator below. The orange state is the current one and the thick arrow is the transition about to fire. The bars count how often each transition has fired since step 0, so the rare ones stand out.
Watch it run

The tape from blank, step by step

This is the real machine, simulated in your browser. Step it, play it, or jump to a step count. Below the cells is the whole visited tape in the notation of the notes: 1^5 is five 1s, and C>0 is the head in state C on a 0.

Jump to:
step 0state Acells visited 1ones 0
Cells around the head (dark = 1, dashed = never visited).
The same tape, grouped into repeated words: (10)7 is the word 10 seven times in a row, and the orange tag is the head. The grouping is found afresh at every step by looking for the longest repeat of a word of up to 8 cells, so it shows the counts a machine keeps on its tape without anyone having to decode them first; it is a display, not a result.
The run at a glance

Space-time diagram and records

The diagram stacks the tape at many moments. Sampling at each new cell shows the shape of the run as the visited region grows; sampling evenly in time shows where the head spends its time. The records list every step at which the head reaches a cell no earlier step reached, with the side, the width so far and the whole tape: the first place to look for a repeating macro structure. Click a row of the diagram to send the simulator above to that step.

Emergent behaviour

Complementing sweeps over a list

defect picture of 1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE
Defect picture of the first 3·107 steps (time runs down, rows at equal step spacing); white where the tape repeats with period 3, dark at the boundaries between blocks.

The background has period 3, and every pass of the head turns it into its complement: 010 becomes 101 going left and back again going right. Read at the moments the head is at the right end in state B, the tape is a list:

stepfront xblocks (010)^a, separated by 11last
7,715,67477467 1077 352 113 12042
8,075,963202447 1065 348 109 12040
8,571,490245163 427 1053 344 105 12038
9,278,929490123 407 1041 340 101 12036

The last block shrinks by 2 per visit, the block of 120 waits, the blocks before it shrink by 4 or 12 or more, and the front counter often doubles or drops by 5, pushing a new block into the list from time to time. How the front counter and the new blocks are tied together is the next thing to work out.

First look

The shape of the run

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).

2^42^82^122^162^202^242^282^02^42^82^122^16■ left of start ■ right of start (steps across, cells up)

After 109 steps the tape spans 83,871 cells (62,156 left of the start, 67 right), with a density of 1s of 0.366.

The tape (run-length coded, 1^5 is five 1s, C>0 the head in state C on a 0) at some of the last moments the head reached a new cell, cut to 400 characters:

sidesteptape
left954,422,648C>0 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2
left970,147,139C>0 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2
left985,891,449C>0 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2 0 1^2
right526,094,3411 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0
right801,946,0381 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0^2 1 0

These are measurements of one bounded run, sorted by tools/py/bbtools/triage.py; the macro structure behind them is the next thing to find.

Side by side

This run next to a related machine

The two machines run for the same number of steps and are drawn the same way, a row each time the head reaches a new cell. Where the relation involves a mirror image, the second diagram is flipped left to right so that the two can be compared directly. Look for where the pictures agree and where they part: the text under each relation in the section on related machines says which of it is proved and which is only observed.

1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE (this machine)

What is known

Every result, by what it rests on

Status as of 8 November 2026. The same list as the proof-status page, built from the same file.

Kernel
step_none_iff, lean/Blank.lean
The halting configurations

The machine stops exactly when it reads the symbol of a halting transition (F0); the generated statement covers every configuration.

Kernel
blank_runs_kernel, 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.

native_decide
blank_runs_native, lean/Blank.lean
No halt in the first 107 steps

The same run, evaluated by compiled code.

Computed
holdouts/triage.json
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.

Heuristic
tools/py/bbtools/triage.py
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).

Kernel
c_left … a_right, lean/Rules.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.

Computed
holdouts/1RB---_1RC0RA_1LD0RB_0LE0LC_1RE1LF_0RD0RB/c/longrun.c
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.

Computed
python3 holdouts/1RB0LB_1RC0LA_1LB0RD_1RE1RD_1RB1RF_1LA---/py/deep.py run 240, verify; holdouts/1RB0LB_1RC0LA_1LB0RD_1RE1RD_1RB1RF_1LA---/data/deep.json
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.

Computed
README.md
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

Computed
python3 tools/py/bbtools/regaccel.py 1RB0LC_1LC0RE_1LD1LB_1LA1LD_1RF0RA_---1RE 3 1200; holdouts/regaccel.json
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.

Heuristic
README.md
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.

Open
README.md, Further work
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.

Computed
holdouts/related.json, written by holdouts/related.py compute (tools/c/cfgmatch.c, tools/c/lockstep.c)
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.

Check it yourself

Commands

. /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