Computation

Read the state as a depth vector (window p ↦ exponent). INC is a push by p; the presence zero-test is exact (independence admits p as a new window iff depth(p) = 0); but every growth move and every intervention multiplies N — no operation lowers any depth (the no-decrement law). A counter machine with increment and zero-test but no decrement has decidable halting: counters only rise, each zero-test flips once, and the run is decided on the finite quotient Q × {0,+}^k. Restore the decrement and the same quotient goes unsound — a halts-iff-even Minsky machine splits c₀ = 2 from c₀ = 3 at the same quotient node. The growth monoid is commutative with write-once presence bits — a well-structured transition system — and the three fates are the WSTS classification of runs: converge, lock, terminate.

Scope. Counter-machine decidability is standard WSTS theory (Finkel–Schnoebelen); Minsky universality is textbook. The contribution is the identification, the threshold at the decrement, and the reading of the decrement as the deleted archimedean place.

verifier: explore_growth_machine.py

The tower owns the zero-test natively — channel presence p | N is reduction at the finite place, an intra-window read — and deletes the borrow natively: size, carry, overflow are the archimedean place, the one inter-window coupling the construction removes. So the finite-window family sits exactly one archimedean import — a single borrow — below Turing-complete. The fingerprint is the down-flip: multiply-only worlds cannot transition a tested counter nonzero → zero, so a finite quotient decides; a borrow un-bounds the flip count and defeats the quotient. The damage is graded: a plain decrement alone (VAS) keeps reachability decidable, a forgetful borrow (reset) already loses reachability while keeping termination, and a plain decrement paired with the native zero-test is exactly Minsky-universal. CRT addition is componentwise — no inter-window carry — while positional addition couples digits through the propagating carry: the deleted place is that coupling, and the borrow is it read as an operation.

Scope. Run-verified: the down-flip invariant, the two-ingredient decomposition, the floor decider, the carry-freedom identity. The decidability/undecidability entries are cited theorems by others (Minsky 1967; Kosaraju–Mayr, Leroux–Schmitz VAS reachability; Dufourd–Finkel–Schnoebelen 1998; Finkel–Schnoebelen 2001). The decidability rests on two deletions: this borrow door, and a second door — depth compared across windows — closed by the residue-field truncation; its machine layer is the comparison threshold below.

verifier: explore_archimedean_dial.py

Fatten the growth machine — moves multiply the modulus, depths monotone, still no decrement — and upgrade its tests from presence reads to three-way depth comparisons sign(α·v_p − β·v_q − γ). The purchase is quantized: nothing, then everything. All tests reading one comparison direction v₂ − v₃ (any offsets, presence reads elsewhere) leave the machine bisimilar to a one-counter machine: halting stays decidable. A second independent comparison — across three or more windows; disjoint pairs behave the same — is Minsky-complete: with X = v₂ − v₃, Y = v₃ − v₅, increments and two equality reads run a two-counter Minsky machine step-exactly — every move a multiplication, no depth ever lowered, halting transfers — so the door opens onto full universality, not merely an undecidable question. The borrow synthesis: no ladder is ever lowered, but on the derived counter v₂ − v₃ the move INC₃ is a value-reading down-move — two increments plus a comparison equal one destruction, at zero archimedean import. The mirror: exact-configuration reachability stays decidable (monotone runs to a fixed target are bounded) while halting goes undecidable.

Scope. The bisimulation and the step-exact simulation are run-verified; one-counter decidability and Minsky universality are cited. Depth beyond 1 means local rings, not residue fields — the door re-imports the depth axis the construction truncates. At exactly two places the linear route is closed (the cone lemma) and the nonlinear gadgets — gated rational multiplication, counters in a register's exponents — fail off the lattice by an exact affine debris; whether that two-place cell admits a universal compile is open (a generalized-Collatz family, Kurtz–Simon).

verifier: explore_second_ruler.py

A borrow grants power only if it is value-reading. Reset — clear a whole window, the general overflow — zeroes a counter reading nothing on the descent, so paired with the native zero-test (no decrement) the machine collapses past decidable to finite-state: (control, zero-pattern) is a bisimulation quotient, halting is finite-graph reachability, decided exactly even for reset oscillators whose naive forward simulation never ends. Restore a plain decrement and the same quotient goes unsound — v → v−1 flips the sign iff v was exactly 1, the read that un-quotients the value. Safe destruction is real and total: a window can be wiped freely without importing one bit of undecidability. The dangerous borrow is the remembering one — the danger is the reading, not the destruction.

Scope. Generalizes to bounded-threshold tests (invariant min(v, T), quotient Q × {0..T}^k). Reset-net undecidability (increment + decrement + reset, no zero-test) is a joint effect, cited (Dufourd–Finkel–Schnoebelen 1998); this corner removes the decrement, which is exactly why it falls to finite-state.

verifier: explore_reset_corner.py

The blueprint's error correction is a height cut — codewords are the elements below a data bound D — and the cut is not dynamics-invariant, so any state-evolution use must re-derive parity per step: base extension, setting a window from the CRT lift of the synced others. That re-derivation, taken as a machine primitive, is a borrow, and it buys full universality. On element registers over a growing squarefree window set, subtraction and the zero-test are already native; what is missing is exactness — a window adjoined mid-run is born offset, and the unsynced zero-test lies in both directions (a false zero at the wrap, a false nonzero from the freeze). Base extension is exactly the missing sync: grow-and-extend before each increment keeps every register's lift equal to its counter, the zero-test reads true integer zero, and a two-counter Minsky machine runs step-exactly — on residue fields, no depth axis. The keystone lemma: base extension is not computable by state-independent ring operations — every such composite is channel-local by CRT, so on a window born with a constant it returns a constant, while lift(x) mod p is not constant in x. A program can still rebuild a lift residue from any window source it can name — bounded-source extension is native; what no fixed program reaches is extension from an unboundedly growing source (the addressing wall: finitely many window names and handle registers against unboundedly many windows). The contrast with dictionary codes (the snap-back guarantee) is operational, not informational: the height-cut syndrome is the aperiodic predicate lift < D, its re-derivation non-ring-computable, while a dictionary syndrome is channel-local and preserved by binding itself — self-checking is free on the decidable side; self-locating is the whole tax.

Scope. The step-exact simulation and the two lies are run-verified; Minsky universality is cited. The keystone lemma is proved for state-independent ring-op composites (any polynomial map, any register count). Whether the door-free machine — growth, ring ops, channel reads, no base extension — is decidable is open.

verifier: explore_ecc_borrow.py

Add an external hand pushing the growth between machine steps — a policy graded by its read set: blind (a fixed schedule), machine-grade (the machine's own read kinds), door-grade (anything determining the true value: depth comparisons, lift reads, or full watching since birth). On the depth face pushes are absolutely inert: depths never decrease, so every depth-face read atom (presence, threshold) flips at most once per run — a program with k atoms receives at most k flag-flips from any hand, omniscient or uncomputable, over its whole run, and the fate map over all hands factors through a finite branch tree; both hand-game questions (does some hand, does every hand, make it halt?) are decidable. The comparison door cannot be smuggled through move-only pushes: the hand can know the comparison stream, it cannot tell it — the read-side twin of the addressing wall. Bandwidth is the read surface's property: the same publishing protocol that dies at flag exhaustion on the depth face runs forever through one element-face mailbox, channel reads being periodic and re-readable. A door-grade hand therefore buys full universality through a door-free machine — the watching hand syncs each grown window by one native add whose parameter carries its knowledge: base extension performed by the intervener. Below the door nothing moves: a blind hand mints no exactness the machine's own repertoire lacks, and a finite-state machine-grade hand composes away into the machine's own control. Pushes program the basin, never the class; the hand's reads are the whole purchase.

Scope. The monotonicity argument is general for the modelled class — finite control, finite-state hands below the door, arbitrary blind schedules; on ratchet-only read surfaces the inertness holds for any hand whatsoever. The deciders, the flag budget, and the step-exact simulation are run-verified; Minsky universality is cited.

verifier: explore_interactive_hand.py