Busy Beaver Explorer / holdouts / 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD--- / explained
A 6-state Busy Beaver machine · Status as of 18 November 2026.1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---
Decided: it haltsProved in this repository, checked by Coq on busycoq's own definitions of a machine and of halting (there is no Lean proof of the whole run). The ledger below says what each part rests on.
It halts. The head sweeps over a counter and a list of runs of 1s; in every epoch each group of runs is halved and moved up one length, and the counter is rebuilt, so that everything grows by 5/4 every two epochs. Far beyond any direct simulation, state B reads 0 1 1 1 and the machine stops: a Coq proof made here from DeepMind's engine for a neighbouring table shows it.
halt : halts tm c0, stated on busycoq's own definitions of a Turing machine and of halting, in holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/coq. Coq 8.18.0 compiles it and Print Assumptions reports no axioms; the build log is next to the files. It is DeepMind's proof of busycoq pull request 93 (the fast engine over macro words, built for the table one transition away), with the four rules that pass through F0 changed and every lemma built on them redone; the proved engine's run from blank tape, 261,156 engine steps, is one evaluation of about 33 minutes. The generator is tools/coq/t4engine/proof.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 E1 (writes 0, moves R): E>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 L C |
| B | 1 R C | 1 R A |
| C | 1 L D | 0 R E |
| D | 1 L A | 1 L D |
| E | 0 R A | 0 R F |
| F | 0 L D | 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.
The proof is this repository's own, submitted to busycoq as pull request 108. It is DeepMind's proof of busycoq pull request 93 (by Alex Havrilla) changed for this table. Coq 8.18.0 compiles it here in about 33 minutes, with no axioms (Print Assumptions halt prints “Closed under the global context”). Like DeepMind's proof, it does not find a formula for the run. It builds a fast simulator, the engine, proves in Coq that every step of the engine is a true statement about the machine, and then lets the engine run the machine from the blank tape until it halts.
A copy of the table. The proof first reflects the tape, so that left and right swap, and renames the states: this machine's A, B, C, D become B, C, D, A. That gives the table 1RB1RA_1LC0RD_1LD1LB_1RA0LE_0LB0LF_0RA--- started in state B. Coq checks transition by transition that the two runs are the same up to this change, so a halt of one is a halt of the other. From here on, directions and state names are those of that table. Call this table T4. Started in C it is 1RB1RD_1LC0RE_1LD1LC_1RA0LB_0RD0RF_0LC---, and started in D it is 1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB---, which is still open.
One transition changed. T4 differs from T3, the table DeepMind's proof was written for (busycoq pull request 93, for 1RB1RD_1LC0RE_1LD1LC_1RA0LB_0RD0RF_0RD---), only in F0: 0RA instead of 0LB. Only four of the engine's rules pass through F0. In T3 they end in CfgJ, with a +1 still to be delivered to the digit on the left. In T4 they end in CfgL with 11 more on the right, and since 11 followed by D n is D (n+1), the +1 lands on the digit to the right instead. This repository restated and reproved those four rules and every lemma and engine case built on them (124 changed lines); the rest of DeepMind's proof is unchanged.
Digits and three moments. Write wn for the word w written n times. The proof's main word is the digit D n = 1 (11)n 00: a run of 2n+1 ones followed by two blanks. Call n its level. The counter (100)n of the sections below is a row of n digits D 0 (reflected), and its runs of 7, 13, 19, … ones are the digits D 3, D 6, D 9. Most of the tape is a long sequence of digits, mostly in rows of equal ones, the highest levels towards the left and the lowest at the right end. Near the left end, where the head turns, lie a few other kinds of word, among them blocks (10)b and (111)k. The proof watches the head at three kinds of moment: CfgR, state A at the word 0100, heading right over the digits; CfgL, state B heading left with a 1 just behind it; and CfgJ, state C heading left with 100 just behind it and a +1 to deliver.
Macro rules. About twenty rules say how the machine gets from one such moment to the next, for every level and every surrounding tape. Heading right, the head turns each digit D n it crosses into S n = 1 (01)n+1, a word of the same length. Heading left in CfgL it turns S n back into D n; in CfgJ it turns it into D (n+1), which is how a +1 is delivered. At the blank end of the tape the head writes two new digits D 0 and turns back. On the left, each 111 of a block (111)k is used up by one turn, so the block is a timer that allows k more round trips. And a round trip that finds two digits D 0 side by side merges them: 10 D0 D0 becomes D3 10. Rows of higher digits are merged in pairs in the same way, through a longer detour over the left part.
A counter. Together these rules make the digits a counter. Its places are the levels 0, 3, 6, …, and the number of digits in a row is the value at that place. Each pass halves a row and carries it one place up, while fresh digits D 0 keep arriving at the right end. This is binary counting with rows instead of bits, so a row of n digits lasts about log2 n passes. The halving is not exact: a row with an odd count leaves a digit over, and the proof has rules for these leftovers (it calls them defects). Where the leftovers end up depends on the parities of huge counts, and no formula for them is known. That is why the community calls such a machine a chaotic Bell.
The engine. The engine is a program written in Coq. It stores the tape compactly: the left part as a list of words with repeat counts, the digits as a list of pairs (level, how many in a row), all numbers in binary. In one engine step it looks at the tape near the head, picks the rule that applies, often a whole batch of them (k round trips at once, with k found by a division), and writes down the result. Where no rule fits, it makes single machine steps. One theorem, proved for every possible compact tape, says that each engine step is correct: the machine really goes from the tape before to the tape after, and when the engine reports a halt, the machine really halts.
How it stops. In this machine's own terms it halts only when state B reads a 0 with three 1s to its right: B0, C1 and E1 then put F on a 1. Nothing in the proof predicts when the leftovers will set this up; the engine simply runs until they do. Coq's virtual machine (vm_compute) evaluates the engine from the blank tape with a budget of 219 = 524,288 steps, and it stops after 261,156 of them, when the tape holds about 22410 cells. So the computer checks one long but finite computation. What holds for all sizes (the rules, the batches, the correctness of every engine step) is proved by symbolic reasoning in Coq.
After a sweep to the right the tape is a counter (100)^n followed by runs of 1s separated by 00; almost all runs have a length 6k+1 and they are sorted into groups: all the 7s, then the 13s, the 19s and so on, with a few odd runs between the groups. After a sweep to the left the same list is written differently: the counter is (011)^n and a run of length v is an alternating stretch 0101…0 of v cells, with 11 between stretches.
The head goes back and forth over all of it. Its right turning point (the front) moves slowly to the right through the list; behind it the runs are regrouped two by two into units that contain a timer, a run of 1s that loses 3 cells on every round trip and so tells the front when to move on. A unit made of runs of length 6j+1 holds the front for about 3(j−1) round trips (one trip for the 7s), and leaves one run of length 6j+7: the group is halved and moved up one length.
| step (a2) | n | 7 | 13 | 19 | 25 | 31 | 37 | 43 | 49 | 55 | 61 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 5.37×1013 | 267,238 | 439,036 | 53,432 | 87,820 | 10,676 | 17,566 | 2,135 | 3,511 | 426 | 702 | 85 |
| 6.82×1013 | 1,097,580 | 133,620 | 219,517 | 26,715 | 43,910 | 5,337 | 8,782 | 1,067 | 1,755 | 213 | 351 |
| 8.39×1013 | 333,950 | 548,791 | 66,808 | 109,758 | 13,357 | 21,955 | 2,668 | 4,390 | 533 | 877 | 106 |
The table shows the counter n and the number of runs of each length at three successive visits of the right end. Follow a column one step down and one step right: it is halved (439,036 → 219,517 → 109,758). The new 7s are half the old counter (267,238 → 133,620), and the new counter is 5/2 of the old 7s (439,036 → 1,097,580). So two rows down everything is 5/4 as large, and the counts fall by a factor 5 for every 12 added to the length.
Phase 1. The head turns at the left end of the tape; every round trip adds 2 to the counter and moves the front. When the front reaches the right end of the tape, one sweep to the left regroups the whole list.
Phase 2. Now the head turns at the right end of the counter: every round trip takes 2 from the counter and makes one new run of 7. In each of these trips state B reads 0 1 1 0 twice (the F-event): B reading 0 1 1 0 gives 1 1 1 1 with B on the right (8 steps: B0 C1 E1 F0 D0 A0 B1 A0). When the counter is used up, phase 1 starts again.
Its F-event differs from the one of the other three machines (it writes 1 1 1 1 and leaves B, they write 1 0 0 0 and leave A), so its tapes are not theirs, but the structure and the growth law are the same.
The halving is not exact: a group sometimes loses a run, and the odd runs between the groups change from epoch to epoch with no visible rule. That is the chaotic part. Because no pattern repeats, the simulator of this family finds its shortcuts on the fly: it notices that a stretch of round trips repeats with the counts changing by constants and applies many of them at once.
This machine's table, mirrored and with its states renamed, is 1RB1RA_1LC0RD_1LD1LB_1RA0LE_0LB0LF_0RA--- started in state B; 1RB1RD_1LC0RE_1LD1LC_1RA0LB_0RD0RF_0LC--- (state C), 1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB--- (state D) are the same table started in the other two states. It differs in the single transition F0 from the table of 1RB1RD_1LC0RE_1LD1LC_1RA0LB_0RD0RF_0RD---, which DeepMind proved halts (busycoq PR 93) with a fast engine: an evaluator over run-length tapes of macro words whose every step is proved sound in Coq. All of that engine's rules hold for this table except four, the ones that pass through F0. In those, where DeepMind's machine ends in the configuration <C 100, this one ends in <B 1 with 11 more on the right; on the digit words D n = 1 (11)^n 00 of the engine, this moves a carry from the digit on the left to the digit on the right.
We changed the engine at every place that uses one of the four rules (tools/coq/t4engine), extracted it from Coq to OCaml and ran it from blank tape; it agrees with direct simulation through 3×1010 machine steps. After 261,156 engine steps, on a tape of about 22410 cells, it stops with the head in state F on a 1: the machine halts. We then redid PR 93's soundness proofs for the four changed rules and everything built on them, so the run is a Coq theorem: halt : halts tm c0 on busycoq's definitions, with no axioms (holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/coq; Coq 8.18.0 checks it in about 33 minutes). The machine's own step count is not computed.
It halts exactly when state B reads 0 1 1 1: B0 C1 E1 put F on a 1 (F1 is the missing transition). Lean checks this path; that there is no other follows from the table: F is entered only by E1, E only by C1, and C by B0 (moving right) or A1 (moving left; then C1 puts E on the 0 that A has just written, and E0 goes on).
In the run this has not happened in 7.9×1014 steps. The community tracker calls it “Chaotic Bell with a neighbour that halts”. Indeed: a1 has E1 = 0RF, F0 = 0LD and a2 has E1 = 1RF, F0 = 0LC; the two mixed tables (E1 = 1RF with F0 = 0LD, and E1 = 0RF with F0 = 0LC) both halt at step 1,272 from blank tape.
It does happen. The run of the proved engine reaches B reading 0 1 1 1 after 261,156 engine steps, when the tape holds about 22410 cells (see DeepMind's engine above).
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.509). 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.11).
After 109 steps the tape spans 39,514 cells (28,110 left of the start, 537 right), with a density of 1s of 0.574.
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 |
|---|---|---|
| left | 936,350,739 | C>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 |
| left | 952,021,149 | C>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 |
| left | 967,694,071 | C>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 |
| right | 626,518,014 | 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^2 1 0 |
| right | 768,714,928 | 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^2 1 0 |
| right | 979,083,615 | 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^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.
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.
Status as of 18 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.
holdouts/triage.jsonThe C simulator tools/c/triage.c runs 109 steps without a halt; at the end 39,514 cells have been visited and 22,692 of them hold a 1.
tools/py/bbtools/triage.pyLeft 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.509). 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.11).
lean/Rules.lean, generated by holdouts/1RB0LB_1RC0LA_1LB0RD_1RE1RD_1RB1RF_1LA---/py/rules.pyFor every n, the head crosses n copies of a short word in a fixed number of steps per copy and leaves another word behind (for example the head crossing (100)^n or (1)^n; these are the sweeps over the counter and the runs). Generated and proved by bbtools.symtm, checked by Lean's kernel.
tmrun 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD--- 30000000000The lead's direct C simulator (tools/c/tmrun.c) runs 3×1010 steps without a halt.
lean/Paths.lean, generated by holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/gen_paths.pyOutside the sweeps, the machine does a handful of local things, each proved for every tape around it: A on a 1 bounces (bounce_on_1, bounce_on_0_0, bounce_on_0_1); B reading 0 1 1 0 gives 1 1 1 1 with B on the right (8 steps: B0 C1 E1 F0 D0 A0 B1 A0) (fevent, the F-event, twice per round trip in the second half of an epoch); and B reading 0 1 1 1 halts: B0 C1 E1 put F on a 1 (fevent_halt). By the table this is the only way to halt: F is entered only by E1, E only by C1, and C by B0 (moving right) or A1 (moving left; then C1 puts E on the 0 that A has just written, and E0 goes on).
holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/bell_wsim.py, py/bell_validate.py, c/tapeat.cbell_wsim.py keeps the tape as repeated words, crosses a repeated word in one move (an exact shift rule found on the fly), and at the left turns looks for a stretch of round trips after which the tape has the same shape with counts changed by constants; it then applies many such stretches at once, with the exact step count. Its tape, state and step count were compared with a plain C simulator at 660 tapes up to 2.08×1010 steps: all equal.
holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/bell_farrun.py, holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/data/far_long.jsonThe accelerated simulator runs 7.9×1014 steps from blank tape without reaching the halting transition; the list at each visit of the right end is recorded.
lean/Paths.lean; data/far_1e14.json of the four machinesIts F-event differs from the one of the other three machines (it writes 1 1 1 1 and leaves B, they write 1 0 0 0 and leave A), so its tapes are not theirs, but the structure and the growth law are the same. The reason is in the tables: a4 does with E, F what a2 does with C, E on the bounce of A, a3 replaces the step C0 of a2 by three steps with the same result, and all three turn B> 0 1 1 0 into 1 0 0 0 A>. They could part only where B reads 0 1 0 (a2 and a4 differ there: b_010), 0 1 1 1 (a2 and a4 halt, a3 goes on) or 0 0 1 (a3 halts); in 109 steps of a2 and a4, B never reads 0 1 0 and reads 0 0 only at the blank right end.
holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/c/neighbours.cThe community tracker calls it “Chaotic Bell with a neighbour that halts”. Indeed: a1 has E1 = 0RF, F0 = 0LD and a2 has E1 = 1RF, F0 = 0LC; the two mixed tables (E1 = 1RF with F0 = 0LD, and E1 = 0RF with F0 = 0LC) both halt at step 1,272 from blank tape. (Direct runs of 3×107 steps of every table that differs in one transition, and of the six start states.)
data/far_1e14.jsonRead off the recorded lists, not proved: with n the counter and c7, c13, … the numbers of runs, one epoch gives c7′ ≈ n/2, c6j+7′ ≈ c6j+1/2 (the half, or one or two less) and n′ ≈ (5/2)·c7 (within 10−4 at 1014 steps). Hence the two interleaved geometric series in the table of counts, the factor 5 per +12 in length, growth by 5/4 every two epochs and step counts growing by 25/16. Between the groups sit a few odd runs that change from epoch to epoch without a visible rule; they are the chaotic part, and the halting pattern can only arise there.
In the first 109 steps of a2 state B reads 0 1 1 20,972 times; in 20,941 of them the cells around are 111101[0]110101, in 29 001101[0]110101, and twice (steps 104 and 1,264) something else; the next cell is always 0. a1 has 20,998 such events with the windows 111100[0]110101 and 001100[0]110101. So after the first 1,300 steps the F-events seen are all of two harmless kinds; whether that holds for ever is the open question.
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.jsonObserved, not proved: the accelerated simulator rsim.py ran 1.28×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 11,073 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.
halt, holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/coq/H155900.v (generated by tools/coq/t4engine/proof)halt : halts tm c0, with busycoq's TM, halts and c0 and tm this machine's table. It is DeepMind's proof of busycoq PR 93 for the table one transition away, changed for this one: the four base rules that pass through F0 are restated and proved, and every lemma and engine case built on them is redone (the collision and defect calls, the returns, the immediate defects, the collisions and the fast right sweep, which gets one more guard). The run of the proved engine from blank tape, 261,156 engine steps to a configuration with the head in F on a 1 (a tape of about 22410 cells), is one evaluation checked by Coq's kernel (run_ok). Print Assumptions halt: closed under the global context. Coq 8.18.0, about 33 minutes.
holdouts/related.json, written by holdouts/related.py compute (tools/c/cfgmatch.c, tools/c/lockstep.c)The same table as 1RB0LE_1RC1RB_1LD0RA_1LA1LC_0LC0LF_0RB--- up to renaming and mirroring, started in another state; no common configuration in the first 107 steps of each. The same table as 1RB1RD_1LC0RE_1LD1LC_1RA0LB_0RD0RF_0LC--- up to renaming, started in another state; no common configuration in the first 107 steps of each.
. /etc/profile.d/lean.sh # after scripts/setup-lean.sh
holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/lean/check.sh
gcc -O2 -o triage tools/c/triage.c && ./triage 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD--- 1000000000
python3 holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/gen_paths.py --check
python3 holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA1RF_0LC---/py/bell_farrun.py 1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD--- 1e12 # the accelerated run, about two minutes
sh holdouts/1RB0LC_1RC1RA_1LD0RE_1LA1LD_0RA0RF_0LD---/coq/build.sh /path/to/busycoq # the Coq proof; a checkout of busycoq's BB6 branch; about 33 minutes
sh tools/coq/t4engine/proof/build.sh /path/to/busycoq fast # regenerate H155900.v from PR 93's file (fast: final run admitted)