1RB0LF_0RC1RD_0LD0RA_1RC0RE_1RF---_1LA0LB

Label: H-2 (halting hunt). 740 list line 362. Class: Chaotic Bell Class 2 (sheet). Claimed 2026-10-13 in coord/claims.tsv, together with 433.

Same table, other starts (in 362's own state labels):

A halt needs D to read a 1 and E to read the next cell as 1 (D1 -> 0RE, E1 undefined).

Halting hunt: exact model (2026-10-13)

Result: no halt for 362 up to step 2.1182e62873, and none for 433 up to 10^43681. Both runs are exact: every run count and step number is an exact integer. There is nothing to certify.

That is about 8.7e5 counter phases for 362, at qsim's measured 10^0.073 steps per phase. The deep scout had reached 10^145.8 (362) and 10^135.7 (433).

Cryptid flag. The dynamics are a Collatz-like parity lottery (see below). A nonhalting proof would be a cryptid-class problem, so this table should not go on a nonhalting queue. For the halting hunt it is the lottery the ranking described, and it was run to the horizon.

What the machine does

• After step 7,702 the head never returns to the left end (checked directly to 2e10 steps). The tape grows to the right like a bell, with span about sqrt(steps).
• The tape is a row of segments built from 4-cell words: 1110, 1010, 1011, 0101, 1101 and 0110. A counter run 1110^a (or 1011^a, the same cells shifted by 2) sits next to the active zone at the right end.
• In one counter phase, the head sweeps between the counter and the right end. Each sweep takes one 1110 off the counter (at cell level) and adds cells to its right. In k = 4 blocks the grid realigns every second sweep, so one rule application covers two sweeps and removes 2 words. Here are three rules of the model (E> = state E, reading the block to its right):

1110^(a+2) 1010^(b+2) E> 0^inf -> 1110^a 1010^(b+5) E> 0^inf (132 + 32b steps) 1011^(a+2) 1010^(b+1) E> 0100 0^inf -> 1011^a 1010^(b+4) E> 0100 0^inf (100 + 32b steps) 1010^(a+1) E> 0101^(b+2) -> 1010^(a+2) E> 0101^(b+1) (12 steps, the shift)

Most of the other 77 rules (362's run) are variants of the first two. They differ in the segments between the counter and the right end. - The counter drops by 2 words per rule application. So when it runs out, its parity (with the 4-cell alignment) decides how the next layout is built. - Each phase multiplies the step count by about 10^0.073: qsim needed 3,500 phases to reach 10^254. - We did not look for structure in the sequence of parity outcomes, and none showed up in the runs. This is the Collatz lottery the deep scout reported (1,885 single-use Collatz rules in 180 s).

The model

The scripts and logs are in work/.

• h2model.py is our own exact accelerated simulator. It shares no code with sligocki's.
• It builds a k-block macro machine straight from the table (k = 4 here), keeps a run-length tape, and makes chain moves.
• It has its own prover. When the tape signature near the head repeats with the same loop period, the prover replays that period symbolically, with run counts x_i + m_i (the smallest m_i is found by restarting).
• The replay may use rules proven earlier, when their iteration count is concrete or linear in one variable. Without that nesting the prover found only 1 rule; with it, 80.
• The result is a limited Diff rule. It records only the runs the replay touched (with 0^inf where the replay reached the end), so it applies wherever that local pattern recurs. 80 rules carried 362 through 6,060,051 rule applications.
• Applying a rule t times adds t·diff to the counts. The steps are the exact quadratic sum.
• On a halt, the model writes out the configuration before the halting macro step. reproduce_halt.py reruns the model and runs the TM cell by cell from a configuration up to 1e7 steps before the halt.
• h2q.py drives sligocki's simulator (tools/qsim.build, k = 4, backsymbol, prover, recursive) with bounded memory.
• max_prover_configs is capped at 20,000, and rules are pruned after their single use.
• With the stock settings it grew to 2.3 GB in 7 minutes on this machine: 100,000 stored full-tape signatures.
• Neither change affects exactness. No pruned rule had been used twice.
• xval.py provides two cross-checking tools.
• Fingerprints: state, number of 1s, span, head offset, and two 61-bit polynomial hashes of the whole tape (computed in closed form per run).
• RLSim: a cell-level TM simulator on run-length tapes with huge counts. It bridges gaps of up to 2e5 steps between two exact configurations.

Validation

All mismatch counts are 0.

The ranking's k = 2 cross-check is not possible. With k = 2 (and k = 6) the block grid cuts the 4-cell words in half, h2model finds 1 rule and stalls at 10^11; qsim's k = 2 screen found 0 rules. The k = 8 check replaces it.

The runs

Rate: h2model went from 10^5581 at 60 s to 10^62873 at 4,000 s. Late in the run, log10(steps) grows like sqrt(time): time per phase grows about linearly with the number of runs on the tape. Memory was 0.49 GB at 10^31316 and 0.70 GB at 10^52657.

No run halted. No rule ever had zero decreasing runs (that would have been a nonhalting certificate; none is expected for a lottery).

If it ever halts

• Reproduce: h2model.py writes <out>.prehalt.json, and reproduce_halt.py TM 4 reruns the model and replays the TM cell by cell. Both were tested on tm128, above.
• Certify: RWLAcc62_BigUint solve_halt' (upstream's route for tm128 on this table) only reaches halts within run-length acceleration, about 10^14 for tm128.
• A halt beyond 10^300 would need a certified replay of these limited Diff rules (a C2-552-style certificate runner over the rule log). That does not exist yet.

Next

• More of the same is cheap but slows down: at the end of the 362 run, h2model added about 7 orders of magnitude of steps per second (about 2.6e4 per hour), falling like 1/sqrt(time).
• The odds per phase are unknown and the dynamics have no trend to watch, so further compute is a pure lottery ticket.
• 428 (the optional add-on, Chaotic Bell Class 2) can run on the same model unchanged: python3 -B work/h2model.py TM 4 SECONDS OUT.jsonl.

Files (work/)

• Models: h2model.py, h2q.py, xval.py
• Checks: xcheck_fp.py, gen_fp_windows.py, xcheck.py, validate_rules.py, anchor_tmsim.py, reproduce_halt.py, checksA.sh, checksB.sh
• Logs:
• long runs: m362_k4.jsonl, m433_k4.jsonl, q362_k4.jsonl, q433_k4.jsonl
• windows: qfp362_k4.jsonl, qfp433_k4.jsonl, fpk8_362.jsonl
• cross-checks: xcheck_fp362.txt, xcheck_fp433.txt, xcheck_k8_362.txt, xcheck433.json
• anchors and rules: anchor362.json, anchor433.json, rules362.txt, rules433.txt
• halting path: tm128_k4.jsonl, tm128_reproduce.json