Computation

A growth move is governed by a demand law — the admissibility condition a state imposes on what may be multiplied into it — and a machine asks such a law for two independent things: a gate, which moves may be made, and a probe, one bit about an offered move. The verdict turns on those two rather than on the arithmetic — and on which of them the machine needs: one handed its moves needs only the probe, one restricted to what its own law admits needs the gate to carry the moves as well.

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. That is the verdict under a probe reading window presence, and presence is one repertoire among several.

The no-decrement law is a theorem about depths, and the depths are not the only counters a state carries. A counter derived from the state falls under a push — truncated subtraction, the primitive lossy counter machines are built from — so a probe that answers whether such a counter has hit zero holds both Minsky ingredients at once, on moves that still only multiply. A machine driven by a hand — moves injected, the law consulted only as a probe — is then universal on the same growth world, and needs nothing further. One that makes only admissible moves needs its law to host that repertoire too, which is a condition on the gate and not on the reading, and two demand laws meet it, one blind and one sighted. The obstruction was never that there is no decrement: it is that reading one is not in every probe repertoire.

Scope. Counter-machine decidability is standard WSTS theory (Finkel–Schnoebelen); Minsky universality is textbook. The contribution is the identification, the threshold at the decrement, the reading of the decrement as the deleted archimedean place, and the relativity: which law is asked decides the verdict. The universality direction is Minsky's theorem applied to an instruction set verified step for step against a reference interpreter on three programs, not an exhaustive claim over programs. The growth monoid is commutative with write-once presence bits — a well-structured transition system — and on the presence reading the three fates — mortality, every run stopping; breadth, every prime seated at exponent 1; depth, one prime's exponent running away (Growth) — are the EXTREMES of the set of limits that system can reach, not a classification of its runs: a limit has two coordinates, its support and its depth, and mortality is the one corner pinning both minimal, while breadth and depth each pin one coordinate and leave the other free. Mortality holds under every driving policy, breadth and depth are greedy, and a freely driven run can hold two of the three at once or none of them.

verifier: explore_growth_machine.py, explore_slack_machine.py, explore_demand_reading.py

The bit at stake is the guard: whether the state's derived counter at a prime l has fallen to zero, which is the zero-test half of universality. On reading: the support-blind laws — independence, new-idempotents (each move must mint idempotents the state lacks, widening its prime support), semisimplicity — are functions of prime support and squarefreeness alone, so states agreeing on those are indistinguishable to every probe they offer, and the guard is exactly what they cannot see: N = 855 and 2565 share support {3, 5, 19} and squarefreeness, and disagree on it. The sighted laws read exactly one number, the transparency headroom V(N) = W(λ(N))/N — where λ(N) is the state's period, the exponent of its unit group, and W(L) the largest modulus whose period divides L — whose divisors are the moves that leave λ fixed, the transparent ones (the headroom ledger); the dynamics law takes admissible to mean raises λ, so its probe answers the guard exactly, and before the push. The two readings are incomparable both ways — 10 and 11 share the headroom 24, hence share their whole transparent set, so the sighted probe agrees on every move there is. On hosting, independently of all that: independence and semisimplicity host no decrement (a seated counter falls only under a move sharing its prime, and such a move is never coprime to the state), transparency hosts no increment and has a finite reachable set besides (its closed form, below), and new-idempotents hosts both. Each of the three hosts the other instruction — the increment is a fresh prime coprime to the state, which independence and semisimplicity both admit, and the transparent push is the decrement itself — so a law in the hosts one column is missing one of the pair, never hosting neither.

One objection looks fatal: under the dynamics law a transparent push is inadmissible, and the transparent push is the decrement. It dissolves, because a move is a multiplication by any m. Pad it: m = l·q with q a fresh prime satisfying q ≢ 1 mod every counter prime and (q−1) ∤ λ(N). The counter at l falls by exactly one, no sibling counter moves, and λ moves in both branches of the guard.

Which cell buys universality then depends on what the machine may do. Hand-driven — moves injected irrespective of admissibility, the law consulted only as a probe — universality is exactly sightedness, the whole sighted row: transparency drives all three programs step for step while making 104 moves it rejects itself, its admissible set never consulted. Law-autonomous — every move made is admissible — it is sighted and hosting, the single corner, with new-idempotents supplying moves it cannot read and transparency reading a bit it cannot act on. Hosting is the price of autonomy. The exact form is about a single move: a move admissible in both branches carries no bit, a move carrying the bit is inadmissible in one branch, so a machine wanting both uses two — which is what the padded decrement does.

Scope. Minsky universality is textbook; what is run here is the classification and the instruction set. Hosting is exhaustive at the tested scope (0 of 2342 coprime moves lowered a seated counter, 0 of 721 counter-raising moves left λ frozen); the padded decrement is verified over 18 decrements at 2, 3 and 4 counters, each walk crossing both branches; the autonomous machine runs three programs against a reference interpreter with 0 inadmissible moves, which is probe scale and not a claim over programs. Reading incomparability is proved in both directions rather than measured. The square does not reclassify the three fates: a hosting law makes the FREE-POLICY fate question undecidable over its own admissible set, which is a different question from the greedy and thermal (softened-argmin) settings the three fates are stated in, and mortality holds under every policy either way.

verifier: explore_demand_reading.py

Under the transparency law the states reachable from a seed s are exactly the multiples of s dividing W(λ(s)): a transparent move leaves λ fixed, so W(λ), the wall, is the same at every state of the run, and the moves out of any state N on it are the divisors of V(N) = W(λ(s))/N — which is why every multiple of s dividing the wall is reached, in one move, and nothing else ever is. The set has one terminus, the wall itself, the only state with headroom 1; every maximal run of transparent moves ends there, whatever chooses the moves, so the primes the run's limit carries are read off W(λ(s)) with no step taken. And the longest run has exactly Ω(V(s)) moves — Ω counting prime factors with multiplicity — since each move multiplies by a divisor of the headroom at least 2, and the run that takes one prime at a time attains the count. Mortality — that every run under the law stops, under every policy — is therefore a statement about a finite set the seed determines, and the poset reading on the selection ladder (the grave as the region's unique maximum) is the same set seen as an order. Which state a run stops at, and how many moves it can take, are functions of the seed as well; only the route is the policy's.

Scope. Proved from the divisor identity for transparent moves, which the verifier checks in both directions below 400 before anything is read. The exhaustion at ten seeds from 2 to 36 — reachable sets of 1 to 20 states, 57 states in all, none hitting the search cap — finds one terminal state at every seed, a longest chain of exactly Ω(V(s)) moves at 10 of 10, and the terminus's primes equal to those of W(λ(s)) at 10 of 10. The seed 2 has headroom 1 and no move at all. The seeds are small by design; the claim is a closed form and the exhaustion is its check, not its range.

verifier: explore_clock_vacuity.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. On the depth face, where every move multiplies N and no depth ever falls, the deletion is decisive: that face sits exactly one archimedean import — a single borrow — below Turing-complete. The fingerprint is the down-flip: where the tested counters are the depths themselves, a multiply-only world cannot transition one 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 (a vector addition system, VAS) keeps reachability decidable, adding a forgetful borrow (reset) beside the decrement loses reachability while keeping termination — the damage is joint: reset paired with the native zero-test and no decrement collapses to finite-state — 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 and its predicate layer is the ruler ladder.

verifier: explore_archimedean_dial.py

Every native predicate — unit (sieve survivor), quadratic residue, idempotent support, ECC syndrome, the seed-flower invariant −χ (the product of the state's shifted primes, minus one), transparency — is a function of the residue tuple n ↦ (n mod p₁, …, n mod p_k) and nothing else, so the whole native predicate repertoire is one class: Boolean combinations of residue-mod-p tests = unions of residue classes modulo a squarefree modulus = the purely periodic subsets of Z with squarefree period. Presburger — what remains of arithmetic when × is deleted — is that class plus thresholds plus prime-power depth (local rings Z/p^j where the tower keeps residue fields F_p). So the tower sits inside Presburger via two further deletions, and they are its own two: the archimedean axis (the threshold {n ≥ t} is Presburger and has no period at all, witness n = t−1) and the depth axis ({n ≡ 1 mod 4} has least period 4, not squarefree, and splits the atom {1,7} of ⟨mod 2, mod 3⟩, so no residue-field window reads it). The equality one would conjecture — finite-window family = the Presburger-decidable fragment — therefore fails, and fails in one direction: the containment holds and is strict, twice over. What sits inside is the squarefree-modular order-free part, and the two things it drops are exactly its two deleted places.

Scope. Run-verified: the periodicity and finite-state facts, and the two escaping witnesses. Presburger decidability and semilinearity and ⟨N,+,×⟩ undecidability are cited, not run. The class is the static one — the growth dynamics lift it to a decidable well-structured system, and the archimedean borrow is the ceiling above that.

verifier: explore_expressiveness_perimeter.py

A map's Landauer floor is its entropy drop under a uniform input, zero exactly when the map is a bijection. The native ring arithmetic is a reversible core: CRT encode and decode, add-a-constant, multiply-by-a-unit are permutations of Z/N factoring channelwise into per-field bijections — zero erasure, carry-free. Erasure enters at the many-to-one operations, and for the additive homomorphisms it is channel-local and exactly priced: multiply-by-a-non-unit erases log₂ gcd(m,N), the idempotent projection e_S erases Σ_i∉S log₂ p_i. The window read is the erasing atom; the arithmetic loses nothing.

That invites reading the archimedean borrow as Landauer erasure, and the reading is an analogy, precisely located. Two distinct non-injectivities are in play: Landauer's is the one-step state map being many-to-one, dynamics destroying information; the witness gap is the history→endpoint map being many-to-one, a commutative accumulator never recording order. The growth machine has per-step erasure zero — every move is a translation of the depth vector, injective — and a route entropy of log₂(k!) all the same: the route is not erased, it is never encoded. At the dial the two run opposite. Reset is maximally erasing and computationally safe; the guarded decrement erases nothing, being a bijection, and is the borrow that unlocks universality. The deleted place hosts two independent knobs — the carry (forward; its absence is the carry-free reversible arithmetic) and the borrow (backward, a value-reading down-move; without one, no universality) — reaped by one deletion, but not one trade seen twice.

Scope. Run-verified: the entropy drops, kernel sizes, per-step injectivity, route counts, and the erasure ordering. Landauer's principle, Bennett's reversible universal machines, and the Minsky and reset facts are cited; thermodynamic dissipation is not measured, only the logical invertibility its floor is proportional to.

verifier: explore_erasure_ledger.py

A Turing system's characteristic artifact is the universal self-interpreter, paid for with undecidable program equivalence (Rice); the sibling's is the reverse — canonical forms and decidable equivalence, paid for with no self-reference, a total language being unable to contain its own interpreter. Three canonical forms come by construction. The element form is the CRT tuple, unique, equality componentwise in O(k). The expression form is the concrete sibling of Rice: two polynomial expressions over Z/N are equal as functions iff they agree per channel in F_p[x]/(x^p − x), so the canonical form is the tuple of per-field reduced polynomials and function-equivalence is decidable where the Turing analogue is not — x⁵ and x are different polynomials and the same function on Z/30, canonically "x" in every field. The predicate form is the perimeter's class read as a language: squarefree-periodic, hence regular, canonical form (least period, accepting residue set) — the Myhill–Nerode minimal automaton, on which three spellings of unit(Z/30) collapse to one. All three deciders are total. Self-certification is the same dividend at the value level: a result carries its own witness, the ECC syndrome, valid iff the syndrome is zero, checked in O(parity) with no re-compute and no trust in the producer.

Scope. Run-verified: the three canonical forms, the x⁵ = x witness, the three-way predicate collision with inequivalent controls, the deciders' totality and soundness, and the ECC self-certification. Rice, the self-interpreter impossibility for total languages, and Myhill–Nerode minimality are cited. The forms are algebra, not runtime, and stand on the universal element face too — Rice constrains questions about what a program computes, never the ring's own normal forms. Canonical forms and decidable equivalence are themselves a commodity, owned by regular languages, Datalog, and the deliberately Turing-incomplete proof assistants; particular here is the normal form being the CRT tuple itself — O(k), reversible, ECC-carrying, wired in rather than computed by a decision procedure. No rival pays to simulate it: the tuple is the Residue Number System's own defining representation, and in the add/multiply-dominated domains where it wins, the incumbent already runs on it.

verifier: explore_decidable_equivalence.py

Add a set to ⟨N, +⟩ and the damage is quantized, not gradual. Call a set k-automatic if a finite-state machine reading base-k digits decides membership, and write V_k for the base-k depth ladder, the map sending n to the largest power of k dividing it. The rungs: the periodic floor, what every base agrees on, is decidable (Cobham 1969). One base's tick marks — k^N, the factorials, any sparse set — stay decidable and tame (Semenov 1979/83). One base's full ladder, V_k and all k-automatic sets, is still decidable (Büchi 1960) — and nothing sits between those two rungs: a non-periodic k-automatic set either defines every k-automatic set or was already definable from the tick marks alone. Then the floor drops. Two independent bases' tick marks — ⟨N, +, 2^N, 3^N⟩ — give a theory already undecidable, yet × is not definable there: a no-man's-land between Presburger and full arithmetic, both halves settled only in 2022. Two independent bases with full ladders returns multiplication whole.

What makes the ladder one statement rather than a list is that every door is a magnitude ruler getting read. Any non-Presburger set mints a ruler — an expanding, unboundedly-gapped set is definable from it — but one ruler never opens the door, and the two classical obstructions say so from opposite sides: a set is compatible with a base exactly when every probe derived from it is bounded or outruns the set (squares fail precisely because their gap probe 2x+1 is neither), and a set that is automatic in two independent bases cannot be expanding at all — no set is a ruler in two bases at once. The door opens when two independent rulers are compared, and the mechanism is measurement precision. Two bases are multiplicatively independent when neither is a rational power of the other, and then their joint ladder {2^a3^b} densifies without bound: the largest ratio between neighbouring members inside a decade falls to 1.039 by 10¹⁸, with the record-setting gaps landing exactly at the continued-fraction convergents of log₂3 — the best rational approximations to it. A dependent pair's joint ladder stays locked at ratio 2 forever. Multiplicative independence is unbounded measurement precision. And the re-import comes in two grades, the knife edge splitting once more: overhearing — coupling two scales enough to interpret undecidable questions — is strictly weaker than rebuilding multiplication. Undecidability ≠ ×.

Scope. Every decidable/undecidable entry on the ladder is a cited theorem by others (Cobham 1969; Büchi 1960; Semenov 1979/83; Villemaire 1992; Bès 1997; Hieronymi–Schulz 2022; Schulz 2022; and the 2025 dichotomy between the two one-base rungs); the run verifies the mechanisms — the densification, the gap probes, the compatibility criterion — so the tier is a rule over its own measurements riding a cited chart. The base-independence contact is Cobham–Semenov, which also underwrites the readability chart being per-base. One direction is open: that every route to undecidability over ⟨N, +⟩ must re-import two independent rulers holds inside the charted classes and is not proved in general. The counterexample shape is named — a door that is undecidable without minting a comparable second ruler — and no specimen is known.

verifier: explore_ruler_ladder.py

The same door appears in the tower's own dress, and what it reads is exactly what the construction deletes. Kummer's theorem — already at work in the binomial parities — says the number of times p divides the binomial coefficient C(x+y, x) counts the carries when x and y are added in base p. So the Pascal triangle mod n is a carry detector at every prime window p | n — and the structure that gives is decided by how many such windows there are. Take the triangle mod n as a bare relation B_n and ask what ⟨N, =, B_n⟩ can say — equality and the triangle, with addition not assumed. With one prime window (n = p^j) that theory stays decidable. With two, + and × are both definable in it: the whole of arithmetic, recovered from a divisibility pattern and equality. The first modulus with two prime windows is 6 = 2·3: the tower's own k = 2 rung, the first primorial that is not a prime power. It is the two-ruler door printed on Z/6, and the tie closes on the deletion — the tower's componentwise, carry-free addition is precisely the removal of what the Pascal triangle mod 6 reads.

Scope. Kummer's theorem is classical and is run-verified here at p = 2 and 3; the one-window and two-window definability results are cited (Korec 1993, 1995; Bès 1997). That the first two-window modulus coincides with the tower's second rung is an observation about which number it is, not a claim that the coincidence does work.

verifier: explore_ruler_ladder.py