The delay line

Born-at-zero is not a principle the constructions keep running into; it is a normal form on the whole machine. Write the op word for the sequence of operations a run has executed so far. Then along any run, the content of register i at a window born at time τ with modulus m is E_i(the op word since τ) mod m, where E_i is the free evaluation of that suffix over the integers from the all-zero state. The induction on the op word is short: reduction mod m is a ring homomorphism, so the componentwise operations commute with it; write-constant writes one integer; a grow never touches an old window; and the frontier singleton is 1 − ONES, where ONES is a register write-constant set to 1 and re-set to 1 at every grow, so that the windows born since carry 0 there and complementing marks exactly the new one. Both moves are native, so the singleton introduces no case of its own.

The registers therefore carry no information beyond the op word. A window's whole content is a function of its own modulus and the suffix since its birth; two windows of equal age and modulus are identical forever; and the configuration abstracts to the control state plus the set of pairs (a window's column — its r-tuple of register contents — and its modulus), with every operation broadcast to all pairs and a grow inserting the zero pair. That reset-broadcast structure holds for every program on every supply, with no hypothesis on the growth rate. The window pool is a delay line of the op stream sampled mod the supply, and not writable memory.

What it buys is a reduction. After a run's last grow the whole configuration lives in the finite space of control states times ∏_k(Z/m_k)^r, and the machine reads no input between grows — the supply is consulted only at a grow. So the plain decider is complete for every run with finitely many grows: simulate; answer HALT on halt; answer LOOP at the first repeat of the full configuration, control state and every window's column, with no grow between the two occurrences. That certificate is sound — equal configurations have equal futures, and the repeated segment — the stretch of a run between two repeats, of a whole configuration here and of a single instruction in the certificate below — holds no grow, window counts being monotone and equal at its ends — and by pigeonhole it always lands. Deciding halting on a supply therefore reduces to semi-deciding that a run grows infinitely often: if every forever-growing program admits a finite certificate of growing forever, halting is decidable, since halt, loop and growth certificates searched in parallel leave one always landing — and an undecidable supply must carry forever-growing programs no certificate scheme covers. Completeness makes “grows forever” co-semi-decidable for free, its complement being exactly halt-or-loop. The naive rule refuted below repeats a compressed signature, and that compression is the whole difference: the exact repeat is sound and exponentially patient, the compressed one fast and wrong.

One sharpening the proof forces on the supply law (the recovery chart): a window evolving under the shared op word realizes any fixed integer polynomial recurrence in its age, not only a constant or the age mod its own modulus. Fibonacci runs as a growing-window clock, its zero-set at modulus m the multiples of the rank of apparition α(m) — the least index at which m divides a Fibonacci number — and the global zero-test fires as a period-60 pulse at frozen moduli 2, 3, 4, 5. That is the same 60 the frozen pulse below carries and not the same computation: there the period is the lcm of the frozen moduli 3, 4, 5; here it is the lcm of the ranks of apparition of 2, 3, 4, 5 — that is, of 3, 4, 6, 5. What is new is not the pulse but what carries it: a window content that is neither a program constant nor the age mod its own modulus, which is the repertoire the bandwidth argument had enumerated too narrowly. The capacity arguments are untouched, having only ever used that a fixed window evolves inside (Z/m)^r under the shared word, which is the normal form itself.

Scope. The normal form is proved by induction on the op word; the randomized run — 5,571 window checkpoints across 60 random programs on the sublinear, linear and bounded supplies, zero mismatches — is a cross-check and never the proof. The decider battery is rule tier: HALT, a certified LOOP far inside its pigeonhole bound, and NO-CERTIFICATE at the step cap on a forever-growing program — the residual class, by design — with both positive controls passed before any verdict was read. The widened repertoire follows from the normal form by construction; its Fibonacci witness is observation, run-verified at moduli 2, 3, 4, 5, where the classical characterization of the Fibonacci zero-set by the rank of apparition fixes the pulse's period at lcm(3, 4, 6, 5) = 60. One direction of the reduction is proved — certifiability gives decidability — and the converse is not claimed: “grows forever” is co-semi-decidable, and nothing here makes it semi-decidable. Certifying infinite growth is the residual the supply law leaves open, and it cannot be supply-uniform — one scheme covering every supply — since the supply that plants a halting fact in a tail switch, below, refutes that by construction.

verifier: explore_born_at_zero.py

Certifying infinite growth — the residual the normal form's reduction leaves open — has a certificate. A growth certificate is a segment between two returns to the same instruction, holding at least one grow — the weaker of the two repeats, the plain decider's needing the whole configuration back. Such a segment repeats forever exactly when every zero-test inside it reads the same bit at every repetition, so a certifier's job is to force those bits — sufficient for infinite growth and never necessary, a program being free to grow forever along a path that repeats no segment at all. The normal form supplies five forcings, each derived against the one thing this machine does that an invariant argument does not usually have to survive: the pool only GROWS, so a claim about every window is a claim about windows that do not exist yet.

Three read the segment's last write to the register a test reads. If that write is the constant 0, every window born before it carries it in its suffix and every window born after it was born 0 with the register untouched, so the test reads true at any age, modulus and pool. If it is a constant c ≠ 0 and one window already in the pool has m ∤ c, that window never leaves and the write is segment-local, so it reads c mod m ≠ 0 at the same position of every repetition and the test reads false forever. The third spends the supply: the window born at the segment's last grow before the test holds a fixed integer E, its suffix being the segment word and nothing else, so E ≠ 0 with modulus > |E| forces the test false, and on a non-decreasing supply one check certifies every repetition. A bounded supply cannot carry it, and that is a witness rather than an argument: the program built to leave this the only forcing available certifies on ⌈√g⌉ and prints no certificate on the bounded supply. The normal form's scope already demands that no certificate scheme be supply-uniform, and demands it from the supply's side; this is the same specificity turning up on the machine's, in one forcing rather than in a scheme.

What those three leave is one-directional, and that is what looked like a wall. Forcing a test to read false needs a single persisting witness; forcing it to read true needs every window the machine owns, unborn ones included. On a draw of 600 random programs, 109 of them grow-heavy — the run reaching 120 grows inside the step cap, an observation and not a decision that it grows forever — the three left 57 uncovered, and 56 of the 57 failed in the reading-true direction. The 52 they did certify flatter them: 49 of those hold no test at all, a cycle with no branch repeating because it has no branch, which costs the normal form nothing. Coverage actually carried by a forcing was 3 of the 109, and that figure is never read alone: across the sweep's cells it runs 0 to 3, so what the three carry is nil to a handful and not a rate.

Two more forcings close almost all of it. The fourth is free: the tested register written nowhere in the segment. The segment map then fixes its coordinate, every old window reads the same value forever and every young window was born 0 there, so the bit is constant and equals the one the run read — forced in whichever direction that was. Its scan is over the whole segment, since scanning back only from the test mislabels a write sitting past it. The fifth is the three-family instrument, and it comes from sorting the windows at a test the way the normal form already distinguishes them. A window there is OLD (in the pool when the segment started), YOUNG-SAME (born at a grow earlier in the same repetition) or YOUNG-EARLIER (born in a previous one), and there is no fourth family, a window born after the test in its own repetition not yet existing there. The normal form gives each family its content, so forcing a true bit is three questions and not one. OLD is not a question but a forcing: the segment acts on (Z/m)^r, a finite set, so the orbit closes and “reads 0 at this position in every repetition” is decided per distinct pair of modulus and column — and the same finite orbit pays the opposite bit too, one window whose orbit omits 0 forcing the test false forever. YOUNG-SAME is one fixed integer per grow position, and 0 over the integers is what a certificate needs, that window's modulus differing at every repetition. YOUNG-EARLIER is the question about the integers: the content is the segment word's own free integer evaluation, iterated from the integer the window's birth repetition left it holding, and it is decided whenever that action reaches a fixed point or a cycle.

Measured on the same draw, the two convert almost all of the residue. The draw certifies 102 against 52, coverage carried by a forcing goes from 3 to 53, and the residue falls from 57 to 7. Swept across seed and program length, what the free case's true direction and the three-family instrument carry between them settles at 48 to 62% of grow-heavy programs, which is the stable form of the same reading. The 7 are not 7 obstacles. A refusal says only that this instrument could not force that bit on that segment, and nothing about the bit — replay shows 6 of the 7 holding a test that takes both values, so that segment genuinely does not repeat with the same answers and no sound scheme could have forced it — and which segment gets tried is the certifier's own choice, the first repeated instruction holding a grow rather than one the program forces. Retried at later repeats, 6 of the 7 certify. So on this draw the residue is ONE, and its reason is the one the derivation had already named: its integer action neither stabilises nor cycles. The shape there is sharper than the derivation expected — of the 34 integer actions the draw reached, 32 hit a fixed point, 2 neither, and a proper cycle appears in none of them. The action stops moving or never settles, with nothing in between. None of this touches the capacity conjecture one level up: what is bounded here is a SCHEME, and a program can be built to defeat any fixed set of forcings.

Scope. Soundness is the claim and reach is measured, and they do not wear one badge. Every forcing is derived from the normal form; the runs cross-check it and are not the proof — 102 certified programs replayed to 600 grows apiece, zero unsound, with the replay walking the segment cyclically and checking the instruction and every test's bit at each position. Positions and not instructions: one test can execute twice inside a segment at two positions with two different last writes, so keying the check by the instruction manufactures its own mismatches. Every forcing is reachable and none is decoration, but the evidence differs by kind — the four single forcings and the orbit's false bit each fire alone on a program built for them, while the three-family instrument is shown the only way a conjunction of conditions allows, a program per family on which that family is the one that correctly refuses — for OLD and YOUNG-EARLIER. YOUNG-SAME has none, since a program making it the decider has to go to the bounded supply, where the supply-spending forcing does not exist. Both positive controls passed. The coverage figures are observation on one random population: 109 grow-heavy of 600 at one seed, with seed and program length swept one dial at a time. Two dials are unswept and named rather than claimed — the retry sweep ran 11 repeats deep, and the population is a single draw. The YOUNG-SAME family is needed by the derivation and, on this population, never the decider: its antecedent is shadowed by the supply-spending forcing, which is consulted first.

verifier: explore_growth_certificate.py, explore_forced_one.py

A capped counter riding the frontier still fires its zero-test, at growing gaps — the modulus creeps as the supply grows. Call a zero-test currently false whose next true lies in the future a pending fire. On every sublinear supply a pending fire lands at a computable time: the count advances by exactly one per pass while the modulus is non-decreasing, so the wrap cannot be skipped — at the first pass where the count reaches the modulus, equality holds — and the landing is read off the supply directly. On a linear supply the same fire can hang pending forever: a faithful counter, one whose addressed value is its count rather than a masked stand-in for it, never re-zeros. The o(g)/Ω(g) boundary is the same line a third time — capacity cap and class placement (the supply law), fire landing here.

The naive halting test — declare a loop at the first repeat of a signal's compressed signature, its kind and phase rather than its contents — is phase-blind, and doubly unsound: a plain frozen pulse of period 60 already draws a false loop against a true halt, and a riding signal's growing gaps fool it unboundedly. The sound replacement is a three-verdict decider — HALT with the halt time; LOOP with a certificate, a never-fires proof or one round of self-simulation; or SUPPLY-ARITHMETIC with the question extracted. Signals are classified constant, frozen-periodic, riding, or growing-uniform; the walk predicts every fire from the descriptor and checks itself against the concrete machine at each step; a branch that consults another signal's phase has its question handed over rather than guessed. Zero false verdicts on the full battery, both killers of the naive rule included.

The third verdict is the law's other half. Each landing hands the machine one bit of the supply's fine structure — on a smooth track every wrap lands at the same clock phase; switch the supply's residue class once, late, and the first post-switch wrap trips a detector — so a computable sublinear supply can encode an arbitrary halting fact in a tail switch, and halting over such supplies is undecidable with every capacity cap intact: reading a planted bit builds no counter, and universality does not reopen. Decidability on the sublinear side is therefore rate plus supply tameness: the rate caps the machine's own arithmetic and forces every fire to land; the supply's own arithmetic is the one channel left open.

Which supplies are tame is itself classified, and the variable is the inverse supply M(d) — the last count served while the modulus reads d or below — not the rate. A wrap at modulus d sits in the stretch of counts (M(d−1), M(d)] shifted by where the frontier started, walked in steps of d, and the offset — the distance from that stretch's top down to its last wrap — obeys o(d) = (o(d−1) + M(d) − M(d−1)) mod d at every populated stretch, an empty one carrying it over without the mod. Four cells. At M = d^c the recurrence compresses with a parity: odd c makes the added step M(d) − M(d−1) ≡ +1 mod d, so the offset freezes — d minus a constant the starting point sets — and the wrap times are exactly polynomial, no geometric content at all; even c makes it −1 mod d, and the checked even powers print the ⌈√g⌉ supply's own marks — the modulus values used once rather than twice — 3·2ⁿ with the seed included, at the same starting point, while at M = ⌊d²/2⌋ the offset counts down one value in two and the marks are exactly 3ⁿ + 1, the first at 10: the geometric ratio is a fingerprint of M, never a universal constant. Slow supplies — those repeating some value coprime to L at least L times — are tame by the coverage lemma: that value's stretch walks across every residue class mod L, so reachability is decided from a finite prefix. Its contrapositive, the starvation lemma, places the planted-bit supply above: keeping any class empty forces every such value out of the supply — the smooth track, every value in one class, is maximal starvation — and a value-starved supply stays untame at any rate, its phase legible one bit per wrap. Between ⌈√g⌉ and g the cell is open, and it is exactly that wide: below ⌈√g⌉ — M = ⌊d^c⌋ at c above 2 — every stretch is walked, and walked more often the further out, so the coverage lemma decides the question with a bound read off M alone (checked at c = 5/2, 7/3 and 9/4 for every L ≤ 60); inside the cell no stretch is walked twice past an explicit modulus, and the repair a reader would reach for has been tried. The extracted question needs only coverage: "is some wrap ≡ a mod L" asks whether ONE class is hit at all, and every class hit settles it at every a — arithmetic where equidistribution is analytic. And nothing is missing: at the four non-integer c = 4/3, 3/2, 5/3 and 7/4 inside the cell, every class of every L ≤ 60 is hit, the last at wrap 363, 410, 365 and 450. But coverage here is a waiting time. What a decider reads is the wrap at which the last class first appears counting from the START of the run — the only place it can count from — and that sits at 0.63 to 1.46 times the coupon-collector value, the mean rolls needed to see all L faces of a die. The same GAPS shuffled — the same multiset of gaps, so the same residues among them, and only their order destroyed — pay the same law: the shape is not the arithmetic's. What a proof would need is named: a wrap's residue is its stretch's top less its offset, the distance down from that top, and the offset is a fresh digit of the walk's position at a resolution that grows without bound — measured uniform to within 0.003, and no counting argument makes such a digit take every value; a wrap's stretch continued without that digit's jitter is a quadratic and misses just under half the classes at every odd prime.

Scope. The landing dichotomy is derived and run-verified — landings on ⌈√g⌉ and ⌈log₂ g⌉ supplies within the derived bound, the linear hang exhibited over 4000 passes. The decider's verdicts are exact on the signal fragment named above, bisimulation-checked per call, battery-verified. The supply-oracle refutation is by construction. The canonical ⌈√g⌉ supply is TAME, and provably so rather than conjecturally: its wrap times are closed-form. Writing s(v) for the largest 3·2ⁿ at most v, every wrap sits at v² − 2s(v) − 1 or v² − v − 2s(v−1) − 1. The proof is an offset counting down one per modulus value and resetting at zero, so above the first few values the marks are exactly the powers-of-two multiples of 3 — the sequence's whole non-polynomial content — and structurally so, that offset never reading where the frontier started: every starting point gives a seed and then exact doublings. Two things follow, and they divide on that line. Because 2s(v) vanishes modulo 6, the wraps are v² − 1 and v² − v − 1 there, so no wrap is ever congruent to 4 mod 6 and a program halting on one loops forever — but that exclusion belongs to this starting point rather than to the supply, being the only one of eight measured that excludes a class. What survives any starting point is that the residues occurring modulo any L are settled by a finite check, verified against enumeration for every L ≤ 60. In the classification, the coverage and starvation lemmas are proved, as is the added step's parity at every power; the freeze and the marks are run-verified at the checked cases (c = 3 and 5; c = 2, 4, 6, 8; the scaled line) at the starting point run, with the recurrence checked against the concrete machine on every supply named and the coverage bound never exceeded across 61 supply–modulus pairs. Two things remain open: the conjecture that every sublinear program's signals reduce to the four kinds, on the bandwidth principle — the normal form above widens what a uniform window may hold, to any fixed integer recurrence in the age, which is a repertoire claim and leaves this four-way split of signals standing — and the classification's own open cell, the band between ⌈√g⌉ and g, which is a coverage theorem: a computable B with every class mod L hit by wrap B(L) is the same statement as every class being hit, the first appearance then being computable by enumeration, so the coupon-collector value's fit is not what is asked. The bound above the cell is rule tier, checked at three powers; the cell's width — one wrap per stretch past an explicit modulus — is derived; the offset's uniformity is observation over 10⁵ wraps at one power, as is the census over the four supplies inside, and so is the first-appearance reading the refuted repair rests on — seven moduli, against the shuffled control.

verifier: explore_pending_fires.py, explore_wrap_word.py, explore_supply_tameness.py, explore_super_critical.py, explore_first_hit_bound.py