Busy Beaver Explorer / holdouts / 1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC--- / explained

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

Does this machine ever halt?

1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC---

Decided: it never haltsProved in this repository, checked by Lean and by Coq. The ledger below says what each part rests on.

No. For its first 1.67×1010 steps this machine goes through five ever longer epochs; then it settles into an exact repeating pattern, a bouncer: the head sweeps between the two ends, and every two sweeps one more block of 13 cells appears on the left while a fixed stretch of 222,182 cells is carried along. Lean proves that the pattern repeats for ever and, chunk by chunk, that the run from blank tape gets there.

native_decidenever haltsnonhalting, proved in Lean (kernel + native_decide).
native_decideC k → C k+1One period, for every k: 184k + 3,029,040 steps.
native_decide1.67×1010The step at which the run reaches C 7, checked in eight chunks.
Also proved in CoqA second proof assistant checks the same result: H32641.nonhalt : ~ halts tm c0, stated on busycoq's own definitions of a Turing machine and of halting, in holdouts/1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC---/coq. Coq 8.18 compiles it and Print Assumptions reports no axioms; the build log is next to the files.
Community labelIn the community's BB(6) tracker the machine's class is Unknown. 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 1. F is entered only from D1 (writes 0, moves R): D>1 1. So a halt is the moment this pattern appears, with the head on the cell after >.

statereads 0reads 1
A1 R B0 R C
B1 L A0 L D
C1 R B0 R D
D1 L E0 R F
E0 L B0 R B
F1 R Chalt
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.

Five levels

From six states to one number

"Does this machine halt?" can be asked at five levels of description. Each level keeps less detail than the one above it and counts time in bigger units, and each step down the ladder is a theorem in Lean saying that the answer does not change. The machine itself is level 1. Level 2 cuts the tape into blocks of 16 cells and moves a block at a time; that is how Lean checks the first 16,730,681,219 steps. From there on the tape has a fixed form, C k, and three more levels describe it: the five pieces of a period, the period itself, and finally just the number k, which goes up by one every period, for ever.

One moment, every level

Pick a moment of the bouncer phase. The browser builds the tape C 7 from the 222,182 cells of X in lean/Data.lean, the configuration the run from blank tape reaches at step 16,730,681,219, and runs two simulators from there to the chosen moment: the real machine, one step at a time, and the block simulator of level 2. Each row describes the same instant at one level; the check marks say that the computations agree.

step 0 of the piece
1 · Machine
blocks, left of XXheaddark = 1, pale = 0
2 · Blocks
3 · Piece
4 · Period
5 · The number k
Cell numbers are those of the run from blank tape, where the head of C 7 stands on cell −311. The four periods are about 12 million steps; the browser runs them once and then each moment from the start of its piece.
First look

The shape of the run

Left of the start, the visited part of the tape stopped growing in the second half of the run (bounded so far, or growing so slowly that no record fell in the last half). 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.538).

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 57,599 cells (252 left of the start, 49,179 right), with a density of 1s of 0.36.

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
right957,088,9250 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0^2 1 0 1 0 1
right972,905,8360 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0^2 1 0 1 0 1
right988,616,3390 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0 1 0 1 0 1 0^2 1 0^3 1 0 1 0 1 0^2 1 0 1 0 1

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.

Level 1 to level 2

Blocks of 16 cells

The first 16,730,681,219 steps are checked in Lean by running them. Run one cell at a time this would be slow, so lean/Block.lean cuts the tape into blocks of 16 cells, each kept as a number from 0 to 65,535 (cell i of a block is bit i). A configuration of the block machine, MC, is the list of blocks left of the head, the list from the head on, the state, and whether the head is on the first cell of its block or on the last.

A table tbl has one entry for each state, block and side of entry: 6 · 216 · 2 = 786,432 entries. An entry says what the machine does inside the block until the head leaves it: the new block, the new state, the side it leaves on and the number of steps. It is computed by brun, a run on the block's 16 cells alone, and brun_ok proves that such a run is a run of the machine whatever lies outside the block. The simulator msim makes one table lookup per block crossing; chkF then makes the few steps that are left one at a time and compares the result with a given configuration.

Kernel chkF_ok: if chkF returns true for a start c, a step count t and an end g, then steps t (sem c) = some g.toCfg, a statement about the machine itself. native_decide tblOk: every entry of the table is what mkEntry computes (20 s). Neither needs anyone to trust the table.

One table entry

Click cells to set a block, choose a state and a side, and the browser runs brun on those 16 cells. Each row is one step inside the block.

The index is idx q b side = (stIdx q · 65536 + b) · 2 + side, as in lean/Block.lean. An entry is empty (none) when the run halts inside the block or is still inside after 4,000 steps (FUEL); the block machine then falls back to single steps.

The two simulators side by side

From blank tape, the browser runs the plain machine and the block simulator for the same number of steps and compares every cell, the head and the state.

The whole run to C 7

Lean cuts the run into eight chunks at the steps T·i/8, T = 16,730,681,219. The configurations at the cuts come from the C simulator py/dumpT.c, which only proposes them: chunk1 … chunk8 each check one chunk with chkF (native_decide, about 3 minutes each), and reach_C7 chains them into steps 16730681219 init = some (C 7). The last chunk ends at finalF, and finalF_ok (kernel) says that finalF is C 7.

The same run fits in a browser. This button runs the block simulator of this page from blank tape through the eight chunks and compares the end with C 7 built from X. It takes some seconds; the page stays usable meanwhile, and the panel at the top of the page then starts from this C 7 instead of the one built from X.

chunkLean theoremends at stepblock crossings so far
Levels 3 to 5: the form

What the tape is made of

From step 16,730,681,219 on, every second time the head comes back to the left end the tape is

C k = 0^inf A> 0 (1010001000100)^k X 0^inf
A10 1000 1000 10010 1000 1000 100…X: 222,182 fixed cellsk blocks of 13 cells: one more after every period

The head, in state A, stands on the leftmost cell. Then come k copies of the block 10 1000 1000 100 (13 cells), then a stretch X of 222,182 cells that is always the same. X is what is left of the earlier epochs: an irregular record of 10s, 100s and 1000s that the sweeps rewrite on the way out and restore on the way back.

Over one period (two sweeps) the left end moves 4 cells left, one block is added, and X ends up 9 cells further right, so the right end grows 9 cells per period. The time per period grows by 184 steps per block, so the tape grows like the square root of the step count, the bouncer signature.

Level 3

One period, piece by piece

Over the blocks the machine is easy to follow symbolically, for any number of them; inside X it is not, but X is a fixed string, so the run there is simply computed. The two kinds of piece meet at the boundary between the blocks and X. Starting from C (n+1):

piecefromtostepsLean
pass 1 (right)A> 0 (1010001000100)^(n+1) X(0101010010001)^(n+1) 1 B> X37n + 38Kernel pass1
excursion 11 B> XE> 0 r11,517,479native_decide w1_ok
pass 2 (left, then right)(0101010010001)^(n+1) E> 0 r1(0101010010001)^(n+1) 0 1 1 B> r192n + 99Kernel pass2
excursion 20 1 1 B> r1E> 0 r21,511,551native_decide w2_ok
pass 3 (left)(0101010010001)^(n+1) E> 0 r2A> 0 1 0 (1000100010010)^(n+1) r255n + 57Kernel pass3

The passes are proved in lean/Pass.lean (generated by py/gen_pass.py with bbtools.symtm.prove) for every n and for any tape R in place of X, one block at a time. Pass 1 is one step and then 37 steps a block, which turn each 1010001000100 into 0101010010001. Pass 2 is 55 steps a block going left in state E, which turn the blocks into 1000100010010; 3 steps at the left end, which write two cells there; then 37 steps a block going right and 4 more: 55(n+1) + 3 + 37(n+1) + 4 = 92n + 99. Pass 3 is the first 55n + 57 steps of the run in pass 2: the same leftward crossing and 2 steps at the left end, where it stops in state A.

The excursions are the run inside X. In each one the head never moves left of the cells written next to X (1, or 0 1 1), so they do not depend on n; how Lean computes them is the next section. Added up, the period takes 184n + 3,029,224 steps.

Follow one period

The browser builds C (n+1) for the n you choose and runs the real machine through one period, piece by piece. At the end of each piece it compares the tape with what the theorem says; during the excursions it also records the leftmost cell the head reaches.

so the period runs from C 3 to C 4
step 0
The upper strip shows the blocks (blue) and the first cells of X (green), from 4 cells left of the start of C (n+1); the bar below it is the whole tape. Cell 0 is the head of C (n+1).
Level 3 to level 4

The excursions, computed once for every n

An excursion is three million steps over a fixed list of cells, so Lean simply runs it. The difficulty is that the tape left of X holds the blocks, whose number n is a variable. lean/Window.lean solves this with a list simulator on a window: wsteps n ⟨l, r, s⟩ runs the machine on the cells l (left of the head, nearest first) and r (from the head on, blank beyond its end), and fails if the head would move left of l. Kernel wsteps_over (with wsteps_over1 and wsteps_over3 for windows of one and three cells): a run on the window that succeeds is a run of the machine with any tape at all further left. So a single evaluation covers every n.

native_decide The three facts of lean/Period.lean that are evaluated:

theorem w1_ok : wsteps 1517479 ⟨[true], X, .B⟩ = some ⟨[], false :: r1t, .E⟩
theorem w2_ok : wsteps 1511551 ⟨[true, true, false], r1t, .B⟩ = some ⟨[], false :: r2t, .E⟩
theorem close : [true, false] ++ r2t = accb ++ X

The first excursion starts with the head on the first cell of X in state B and the 1 written by pass 1 as its whole window on the left; it ends with that window used up, the head back on that cell, now a 0, in state E. The second starts with the three cells 0 1 1 written by pass 2. The last fact says that what the second excursion leaves behind, behind the two cells 1 0 that pass 3 writes in front of it, is one more block 1010001000100 followed by X again. period chains the five pieces with these facts, and rep_rotate moves the new block to the front: 1 0 (1000100010010)^(n+1) = (1010001000100)^(n+1) 1 0. Then C (n+1) reaches C (n+2) in 184n + 3,029,224 steps, for every n.

Evaluate them in the browser

The browser runs the same window simulator on the X of lean/Data.lean and checks the three facts. To see that the check has teeth, flip a cell of X first.

Where the head is during the two excursions, as a cell of the window counted from the first cell of X (up the page) against the step (across), sampled every 2,000 steps. Each excursion runs out to the right end of the tape and back.
Level 5

The number k

At the bottom of the ladder the tape is gone. What is left is one number, k, the count of blocks in front of X, and a clock. The whole proof after step 16,730,681,219 is one rule applied again and again: C k becomes C (k+1), and the clock moves on by 184k + 3,029,040 steps. native_decide runs_C and not_halts_C (lean/Period.lean) turn period into "from any C (m+1) the run goes on for ever", and nonhalt_of_reach into "if the run from blank tape reaches some C (m+1), the machine does not halt". The run reaches C 7 (reach_C7).

Here the rule is applied to the numbers alone: each press adds one block and adds the rule's step count. Nothing else on the tape changes, which is why the machine can never meet the pattern that halts it.

The clock, and the machine against it

Summed, the rule says that C k is reached at step 16,730,681,219 + 3,029,040 (k − 7) + 92 (k(k − 1) − 42) for every k ≥ 7. Type any k. The C simulator py/dumpT.c found C 1397 at step 21,120,462,459 (computed, not part of the proof), as the formula predicts. The button runs the real machine in the browser from C 7 and records each step at which the tape is exactly C k.

The machine run watches every time the head is on the left end of the tape in state A and then compares the whole tape with C k. That happens twice a period: once in the middle of pass 2, where the tape is not C k (pass 3 is the first 55n + 57 steps of pass 2), and once at the end of the period.
Aside: before the bouncer

How it gets there: five epochs

Before the bouncer the leftward sweeps do not always reach the left end. The cell where they turn back (green below) creeps right, about 7 cells per sweep, while the right end (red) gains 4.5 cells per sweep; when the turning point catches up with the right end it runs back to the left end, and the next epoch starts. Five epochs, each about 3.7 times longer than the last, end at sweeps 250, 950, 3,600, 13,350 and 49,300. After the fifth the turning point stays at the left end: the tape is then C 7, and the period above repeats from there on.

-100k0k100k200k300k0k21k42k63k84kbouncer from here■ right end ■ where the leftward sweep turns (sweeps across)

Logged every 200 sweeps by py/lturn.c up to 1011 steps (84,927 sweeps). After sweep 49,300 the step counts of the turns follow a quadratic exactly.

Watch the first epochs

The browser runs the real machine from blank tape and draws, for each sweep, the rightmost cell so far and the cell where the leftward sweep turned. Here a sweep ends when the head makes new rightmost cells after more than 200 steps without one, and its turning point is the leftmost cell the head visited since the previous sweep ended. That rule is this page's own, so its sweep numbers can differ a little from those of py/lturn.c above.

rightmost cell so farwhere the leftward sweep turnedleftmost cell so far
The bottom line

It never halts

It never halts.

Started on a blank tape, 1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC--- runs for ever. Lean states it as

theorem nonhalting : ¬ HaltsFromBlank := nonhalt_of_reach (m := 6) reach_C7      -- lean/Reach.lean

where HaltsFromBlank is the machine's own halting from blank tape, defined from its transition table in lean/Machine.lean. In words: the run from blank tape is at C 7 after 16,730,681,219 steps, and from any C k with k ≥ 1 it reaches C (k+1), and so on without end.

Why a halt cannot come

The only halting transition is F reading 1. State F is entered only from D reading 1 (D1 = 0RF), so a halt needs the head in state D on 1 1. In the bouncer phase this never happens: the period is proved for every number of blocks, and the run over X is the same every time. Before it, Lean checks the whole run of 16,730,681,219 steps from blank tape, in eight chunks of about 2×109 steps: the C simulator proposes the configurations at the chunk boundaries, and a block simulator proved correct in Lean (blocks of 16 cells, one table lookup per block crossing) checks each chunk, with native_decide.

What it rests on

#print axioms nonhalting (lean/Axioms.lean) shows the standard axioms and, besides them, the compiled evaluations of native_decide (Lean.ofReduceBool). So the result is native_decide: it trusts Lean's compiler for these fixed computations, and the kernel for everything else.

rests onwhatwhere
native_decidethe two excursions into X and the closing equality: w1_ok, w2_ok, close (a few seconds)lean/Period.lean
native_decidethe block table: tblOk (20 s)lean/TblOk.lean
native_decidethe eight chunks of the run from blank tape: chunk1 … chunk8, about 2.09×109 steps and about 3 minutes eachlean/Chunk1.lean … lean/Chunk8.lean
Kernelthe three passes over the blocks, for every n: pass1, pass2, pass3lean/Pass.lean
Kernelruns on a window ignore the tape on their left: wsteps_over, wsteps_over1, wsteps_over3lean/Window.lean
Kernelthe block simulator is correct: brun_ok, mstep_ok, msim_ok, toF_ok, chkF_ok; the end of the last chunk is C 7: finalF_oklean/Block.lean, lean/Final.lean
Kernelthe proofs that chain these facts: period, runs_C, not_halts_C, nonhalt_of_reach, reach1 … reach8, reach_C7, nonhalting (the theorems themselves rest on the native facts they use)lean/Period.lean, lean/Reach.lean

Not needed for the proof: Kernel step_none_iff (where it can halt) and blank_runs_kernel (no halt in 10,000 steps), native_decide blank_runs_native (107 steps), all in lean/Blank.lean; Kernel dsweep and blk_cross (lean/Sweep.lean), the rightward sweep in state D as a block transducer on the "Q encoding", a building block for the earlier phase; Computed no halt in 1011 steps (py/lturn.c); Heuristic the description of the five epochs before the bouncer.

The chunk files depend only on lean/Bound.lean and lean/Final.lean, so they can be checked in parallel; lean/check.sh runs them one after another, about 25 minutes in all. The box near the top of the page says where a second, independent proof in Coq lives (coq/ in this machine's folder); there the long computations run under vm_compute inside Coq's kernel.

The panels of this page re-run the computations behind the native facts in your browser, with code written for the page: the block simulator through the eight chunks, the two window runs and the closing equality. That is a third, independent evaluation, not a proof: it trusts the browser's JavaScript.

What is known

Every result, by what it rests on

Status as of 9 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 (F1); 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.

Kernel
pass1, pass2, pass3, lean/Pass.lean (generated by py/gen_pass.py with bbtools.symtm)
The three symbolic passes over the blocks

With R any tape: 0^inf A> 0 (1010001000100)^(n+1) R reaches 0^inf (0101010010001)^(n+1) 1 B> R in 37n+38 steps; 0^inf (0101010010001)^(n+1) E> 0 R reaches 0^inf (0101010010001)^(n+1) 0 1 1 B> R in 92n+99 steps, passing after its first 55n+57 steps through 0^inf A> 0 1 0 (1000100010010)^(n+1) R at the left end (pass3). For every n and R.

Kernel
wsteps_over, wsteps_over1, wsteps_over3, lean/Window.lean
Runs on a window never look further left

A run on a finite window of cells that never moves left of the window (wsteps, a list simulator that fails when the head would leave the window) is a run of the machine with any tape at all on the left.

native_decide
w1_ok, w2_ok, close, lean/Period.lean (native_decide)
The two excursions into X

Entering the fixed stretch X (222,182 cells, lean/Data.lean) from the blocks, the head comes back out after 1,517,479 steps in state E onto a 0, leaving a stretch r1; entering r1 the next time, it comes back after 1,511,551 steps, leaving a stretch that, with the two cells the last pass writes in front of it, is one more block followed by X again.

native_decide
period, not_halts_C, nonhalt_of_reach, lean/Period.lean
One period of the bouncer, for every number of blocks

With C k = 0^inf A> 0 (1010001000100)^k X 0^inf: C (n+1) reaches C (n+2) in exactly 184n + 3,029,224 steps, for every n. So from any C (m+1) the machine runs for ever, and if the run from blank tape reaches some C (m+1), the machine does not halt.

Kernel
brun_ok, mstep_ok, msim_ok, chkF_ok, lean/Block.lean
A block simulator, proved correct

The tape cut into blocks of 16 cells, and a table that says, for each state, block and side of entry, what the machine does in the block until the head leaves it. Each table entry is computed by a run on the block's cells that is proved to be a run of the machine whatever lies outside (brun_ok); the simulator msim looks up one entry per block crossing, and chkF_ok turns a successful check of a run of exactly t steps (macro steps, then single steps) into steps t ... = some ....

native_decide
chunk1 … chunk8, tblOk, reach_C7, lean/Reach.lean, generated by py/gen_reach.py
The run from blank tape reaches C 7 at step 16,730,681,219

The run is cut into eight chunks of about 2.09×109 steps at configurations dumped by the C simulator (lean/Bound.lean); each chunk is checked by the block simulator with native_decide (about 3 minutes each, lean/Chunk1.lean … lean/Chunk8.lean), the table by tblOk (20 s). The C simulator only proposes the boundaries; Lean checks every step between them. Chained: steps 16730681219 init = some (C 7).

native_decide
nonhalting, lean/Reach.lean
The machine never halts from blank tape

nonhalting : ¬ HaltsFromBlank, from reach_C7 and nonhalt_of_reach. It rests on Lean's kernel and on compiled evaluation for the native_decide facts (the two excursions into X, the closing equality, the block table and the eight chunks).

Computed
py/lturn.c
No halt in 1011 steps

py/lturn.c runs 1011 steps without a halt and logs every 50th left turn; from sweep 49,300 on (step 1.68×1010) the left turn is the left end and the step counts of the turns follow a quadratic exactly (third differences 0): left end −2 cells per sweep, right end +4.5. At 1011 steps the tape spans cells −71,625 to 382,423.

Kernel
dsweep, blk_cross, lean/Sweep.lean
The rightward sweep over the Q encoding is a block transducer

In state D, moving right, the head crosses each of the blocks 1000, 100100, 1001000, 10010100, 100101000 in state D without looking past it, so it crosses any word made of them block by block. A building block for the earlier phase; the period proof above does not use it.

Heuristic
py/lturn.c, py/chart37.py
Before the bouncer: a turning point that runs out and back in epochs

Up to step 1.67×1010 the leftward sweeps do not all reach the left end: the cell where they turn moves right, about 7 cells per sweep, until it meets the right end (sweeps 150, 650, 2,550, 9,500, 35,550, right end at 774, 3,024, 11,648, 42,923, 160,189 cells), then runs back to the left end (sweeps 250, 950, 3,600, 13,350, 49,300). Each epoch is about 3.7 times longer than the one before. After the fifth return the configuration is C 7 and the bouncer above takes over.

Check it yourself

Commands

. /etc/profile.d/lean.sh      # after scripts/setup-lean.sh
holdouts/1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC---/lean/check.sh
python3 holdouts/1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC---/py/gen_pass.py      # rewrites lean/Pass.lean
gcc -O2 -o dumpT holdouts/1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC---/py/dumpT.c && ./dumpT 1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC--- 16730681219 | python3 holdouts/1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC---/py/gen_data.py      # rewrites lean/Data.lean
./dumpT 1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC--- $(python3 holdouts/1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC---/py/gen_reach.py --bounds) | python3 holdouts/1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC---/py/gen_reach.py      # rewrites lean/Bound.lean, Chunk*.lean, Reach.lean
gcc -O2 -o lturn holdouts/1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC---/py/lturn.c && ./lturn 1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC--- 100000000000 40 50 100000000 > lturn.txt