Busy Beaver Explorer / holdouts / 1RB0RC_1LA0LD_1RB0RD_1LE0RF_0LB0RB_1RC--- / explained
A 6-state Busy Beaver machine · Status as of 9 November 2026.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.
nonhalting, proved in Lean (kernel + native_decide).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.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 >.
| state | reads 0 | reads 1 |
|---|---|---|
| A | 1 R B | 0 R C |
| B | 1 L A | 0 L D |
| C | 1 R B | 0 R D |
| D | 1 L E | 0 R F |
| E | 0 L B | 0 R B |
| F | 1 R C | halt |
read:write move. Red marks a halting transition. Hover a state or a row to single out its arrows.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.
(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 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.
"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.
step_none_iff
Level 2Blocks of 16 cells
The tape as a row of 16-bit numbers. One unit is one block crossing, a table lookup; 16 steps on average.
Kernelsame run as level 1: chkF_ok
native_decidethe table: tblOk; the 8 chunks to C 7
Level 3Five pieces
From C k on: a pass over all the blocks, or an excursion through the fixed stretch X. One unit is one piece.
Kernelpasses, for every k: pass1–pass3
native_decideexcursions: w1_ok, w2_ok
Level 4Periods C k
The tape at the start of a period. One unit is one period, two sweeps, 184k + 3,029,040 steps.
native_decidefive pieces make one period: period (with close)
Level 5The number k
k becomes k + 1. The run from blank tape arrives at k = 7, and nothing can stop k from growing.
native_decidereach_C7, nonhalt_of_reach, so nonhalting
AsideFive epochs
How the run builds X before step 16,730,681,219. Not used by the proof: Lean checks those steps at level 2.
Heuristicturning points logged by py/lturn.c
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.
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).
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:
| side | step | tape |
|---|---|---|
| right | 957,088,925 | 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 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 |
| right | 972,905,836 | 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 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 |
| right | 988,616,339 | 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 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.
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.
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.
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. 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.
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.
| chunk | Lean theorem | ends at step | block crossings so far |
|---|
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
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.
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):
| piece | from | to | steps | Lean |
|---|---|---|---|---|
| pass 1 (right) | A> 0 (1010001000100)^(n+1) X | (0101010010001)^(n+1) 1 B> X | 37n + 38 | Kernel pass1 |
| excursion 1 | 1 B> X | E> 0 r1 | 1,517,479 | native_decide w1_ok |
| pass 2 (left, then right) | (0101010010001)^(n+1) E> 0 r1 | (0101010010001)^(n+1) 0 1 1 B> r1 | 92n + 99 | Kernel pass2 |
| excursion 2 | 0 1 1 B> r1 | E> 0 r2 | 1,511,551 | native_decide w2_ok |
| pass 3 (left) | (0101010010001)^(n+1) E> 0 r2 | A> 0 1 0 (1000100010010)^(n+1) r2 | 55n + 57 | Kernel 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
#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 on | what | where |
|---|---|---|
| native_decide | the two excursions into X and the closing equality: w1_ok, w2_ok, close (a few seconds) | lean/Period.lean |
| native_decide | the block table: tblOk (20 s) | lean/TblOk.lean |
| native_decide | the eight chunks of the run from blank tape: chunk1 … chunk8, about 2.09×109 steps and about 3 minutes each | lean/Chunk1.lean … lean/Chunk8.lean |
| Kernel | the three passes over the blocks, for every n: pass1, pass2, pass3 | lean/Pass.lean |
| Kernel | runs on a window ignore the tape on their left: wsteps_over, wsteps_over1, wsteps_over3 | lean/Window.lean |
| Kernel | the block simulator is correct: brun_ok, mstep_ok, msim_ok, toF_ok, chkF_ok; the end of the last chunk is C 7: finalF_ok | lean/Block.lean, lean/Final.lean |
| Kernel | the 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.
Status as of 9 November 2026. The same list as the proof-status page, built from the same file.
step_none_iff, lean/Blank.leanThe machine stops exactly when it reads the symbol of a halting transition (F1); the generated statement covers every configuration.
blank_runs_kernel, lean/Blank.leanThe 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_native, lean/Blank.leanThe same run, evaluated by compiled code.
pass1, pass2, pass3, lean/Pass.lean (generated by py/gen_pass.py with bbtools.symtm)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.
wsteps_over, wsteps_over1, wsteps_over3, lean/Window.leanA 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.
w1_ok, w2_ok, close, lean/Period.lean (native_decide)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.
period, not_halts_C, nonhalt_of_reach, lean/Period.leanWith 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.
brun_ok, mstep_ok, msim_ok, chkF_ok, lean/Block.leanThe 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 ....
chunk1 … chunk8, tblOk, reach_C7, lean/Reach.lean, generated by py/gen_reach.pyThe 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).
nonhalting, lean/Reach.leannonhalting : ¬ 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).
py/lturn.cpy/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.
dsweep, blk_cross, lean/Sweep.leanIn 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.
py/lturn.c, py/chart37.pyUp 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.
. /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