The Object

The inverse limit of the tower along its rungs is the full product of the prime fields, one free residue per prime:

Every exponent stays 1, so no Z_p ever forms: the limit is not the profinite completion Ẑ = ∏_p Z_p. The two differ by exactly the radical, ∏_p F_p = Ẑ/J(Ẑ): the tower's limit is the semisimple quotient.

Scope. The transition maps are channel-forgetting projections (checked exhaustively for k ≤ 5, sampled at k = 6, 7); the identification of the limit is algebraic.

verifier: explore_limit_object.py

Along the primorial trajectory the tower is the algebraic form of the sieve of Eratosthenes — identity, not analogy: sieving by p is reading the window at p and discarding the zero fiber. The survivors of the k-prime sieve are exactly the units of Z/p_k#; each sieve step is the CRT projection onto one channel; the 2^k inclusion–exclusion terms are the 2^k idempotents; the survivor count is φ(p_k#), the inclusion–exclusion formula itself.

Scope. A term-by-term dictionary — units, idempotents, φ, λ, the error-correcting split — with each computable row verified in the script.

verifier: explore_sieve_connection.py

Let n be a non-unit, S the set of ring primes dividing it — the channels where n reads 0 — and take the coupling class of n to be every element with exactly that null set. For a signed generator step ±g: if g ∈ S no member of the class escapes at all, since g divides both the element and the step. If g ∉ S, exactly (g−1)·∏(p−2) of the class's ∏(p−1) members land on a unit, both products running over the primes outside S and the first also skipping g — an escape probability

The factor at p = 2 forces a parity dichotomy: an odd non-unit escapes only via ±2, every odd step landing even — the 2-boost — while an even one escapes via any odd g ∉ S and never via ±2. Every nonzero class has positive escape probability and the class {0} alone has none. The law is class-level, not per-element — individual stuck non-units exist, 122 of them in Z/2310, among them 119 with both ±2 neighbours non-units.

Run the same product with no channel dead at all — a survivor stepping by 2 rather than a non-survivor escaping — and it is a known density: ∏_3≤p≤pk(p−2)/(p−1) is exactly the conditional twin-survivor density of the k-prime sieve, the chance that n + 2 survives given that n does — 22,275/92,160 = 0.2417 at k = 7 — with Mertens asymptotic 2C₂e^−γ/ln p_k for C₂ the twin prime constant (ratio 0.9999 by k = 10⁵). The twin-survivor density is a built-in channel statistic.

Scope. Proved for all k within a class — CRT runs the non-null residues over every nonzero tuple exactly once — and verified exhaustively for k ≤ 7.

verifier: explore_unit_escape.py

Channels only accumulate along the trajectory, so a capability's temporal fate is its quantifier shape over channels. An ∃-shaped capability (some channel carries the defining property) is monotone: born at the rung of the least qualifying prime, immortal. A ∀-shaped one is anti-monotone: dead at the rung of the least failing prime, forever — 2 and 3 are permanent vetoes. A conjunction of the two is born and mortal (the Fano-plane structure, born at rung 5, dead at rung 6, is the chart's one specimen); walls are ∃-shaped over substructure, so walls never heal. The chart saturates: every mortal row is dead by rung 6, and the last qualitative birth — an ECC rate above 1/2 — lands at rung 7. Past it, births are parametric and Linnik-priced: an order-m element exists at rung k iff m | λ(k), so its birthday is set by least primes in arithmetic progressions — order 23 arrives at rung 15 while order 19 waits until rung 43, and m ≤ 200 already needs the prime 3547 (rung 497).

The i specimen: √−1 — the archimedean form of i — dies at rung 2 under 3's veto, while i as rotation (an order-4 element) is born at rung 3, immortal. The tower keeps the turn and discards the square root.

Scope. The fate rule and the birthday formula are proved; accumulation is the only ingredient, so a designed tower chooses its own vetoes (skip 3 and √−1 lives on every rung whose odd primes are ≡ 1 mod 4). The chart is computed per rung with each row's direction verified; the birthday formula is swept exact for m ≤ 200.

verifier: explore_genesis_ladder.py

Adding p_k jumps λ iff p_k − 1 introduces a prime-power factor not already present in λ. Otherwise p_k is lambda-transparent: capacity grows (φ, idempotents) but no new dynamical complexity appears. The criterion: p_k is transparent at rung k iff (p_k − 1) | λ(k−1).

Scope. All k, by construction. Computed landscape k = 1..50; the first transparent prime is 13 at k = 6, where φ(13) = 12 divides λ(5) = 60.

verifier: explore_lambda_tower.py

No rung's p_k − 1 ever contributes two never-before-seen prime factors to λ: each rung introduces at most one new prime, so the introductions are injective and the entry order is well defined. Verified exhaustively through k = 3,001,134 — every prime p ≤ 5·10⁷.

The margin is not thin. In every one of the 414,894 introductions the new prime is the largest factor of p − 1, and near misses — a co-factor of p − 1 that entered outside the first 10% of the rungs below k — die out at k = 43, nine events in total, the last at p = 191. A collision needs a prime p ≡ 1 (mod 2q₁q₂) for two new primes q₁, q₂ at once, each of them having dodged roughly the other's size over ln(q₁q₂) earlier chances to enter.

Scope. Exhaustive to p ≤ 5·10⁷; a proof for all k is open, so always injective stays a conjecture. Under a Cramér/Dirichlet model the expected number of collisions beyond the checked horizon is about 10⁻⁸⁰³¹ — a heuristic, not evidence of the kind the rule above rests on. The serial ledger below certifies injectivity itself much further, for every p ≤ 10¹⁶.

verifier: explore_linnik_injectivity.py

Every jump of λ introduces exactly one new prime power, never two — at k ≤ 2000 the 468 jumps split into 438 that bring a new prime and 30 that only raise the exponent of one already present, none both. What the law is: write L(m) for the least prime ≡ 1 (mod m), Linnik's function above read at prime-power moduli. Adding the prime p raises the exponent of q in λ iff p = L(q^j) for some j ≥ 1 — iff p is a record, the first prime a progression 1 mod q^j ever sees. The record sets {L(q^j) : j ≥ 1} are classical objects — in base 2 the record is 2^j + 1 exactly when that number is prime, the Fermat primes — and the law claims nothing about any one of them: it says they are pairwise disjoint across bases. A violation would be a single prime standing as the least in two prime-power progressions with distinct bases; both moduli then divide p − 1, and being coprime so does their product, so the smaller is ≤ √(p − 1): every violating prime up to 10¹⁶ is the record of some modulus below 10⁸. Scanning them all, then testing each record prime against every prime-power divisor of its p − 1 — so the larger witness is caught without being scanned — decides every prime up to 10¹⁶, and finds no violation: 5,762,848 record primes, zero collisions. The closest call anywhere is 7 = L(3) against L(2) = 3, a ratio of 7/3; above p = 600 no ratio is below 34.6.

Scope. The record characterization is proved (a criterion); disjointness — hence the law — is verified for every prime p ≤ 10¹⁶. Beyond that it is a conjecture with a convergent price: a rival modulus m at a record prime p requires every prime below p to have missed a progression of density 1/φ(m) — chance about exp(−π(p)/φ(m)), summable over the records with its mass at the small primes already enumerated. So the law should hold for every p while sitting past the same wall as the ordering above: a proof needs least-prime control at every modulus and scale at once.

verifier: explore_double_birth.py