The Object
The definition, the blueprint, the first fourteen
rungs — what is born along them, and what they name.
The identity
A channel is a residue window: reduction at one finite place. The
rung Z/pk# reads the first k windows
simultaneously — every element is a unique k-tuple of residues,
arithmetic decomposes window by window, no window sees another's
content:
Each rung is nested in the next,
Z/6 ⊂ Z/30 ⊂ Z/210 ⊂ ⋯, and each is a finite
section of one ambient object: the product of all prime fields.
The CRT encode/decode and per-channel arithmetic the verifier
scripts import is one small shared library,
crt.py.
The limit
object rule
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 Zp ever
forms: the limit is not the profinite completion
Ẑ = ∏p Zp. The
two differ by exactly the radical,
∏p Fp =
Ẑ/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
The deleted place
The construction removes exactly one window: the archimedean
place. Size, sign, comparison, carries, overflow — none is a channel
quantity, and no reading of a proper subset of windows recovers one:
to every strict channel subset, the size of an element is essentially
uniform. Measuring this deletion and its echoes — which functions can
be read through which windows, and at what price — is its own section
(Walls).
One blueprint property quietly re-imports what was deleted: the
error-correction guarantee is a height cut on integer points.
Redundancy is a property of the integers under a bound, never of the
product ring — in the limit there is no archimedean place, no height
cut, and no code.
The first fourteen rungs
The table is recomputed from the definitions at every build:
N = pk# is the modulus, φ counts the
units, and λ is the Carmichael exponent (below). The
error-correcting code comes from the tower split — the first k−3
primes carry data, the last 3 parity, an MDS code of distance 4 from
k = 4 on (more data than parity from k = 7), so the ECC rate
is (k−3)/k. N and φ are shown as magnitudes; the exact
values are in
explore_lambda_tower.py.
The sieve
identity property
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/pk#; each sieve step is the CRT
projection onto one channel; the 2k
inclusion–exclusion terms are the 2k idempotents;
the survivor count is φ(pk#), the
inclusion–exclusion formula itself.
Scope. A complete dictionary — every tower
concept has a sieve counterpart, and the identification is
term-by-term.
verifier:
explore_sieve_connection.py
The genesis ladder
Reading the rungs as a chronology: which capabilities exist at
rung k, and for how long. The
provenance ladder pins each
obstruction down to its minimal carrier; the genesis ladder is its
mirror — each capability pinned up to its birth rung.
The genesis
ladder rule
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 a window, 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
Growth: lambda and transparency
The universal period of the power maps at rung k is the Carmichael
exponent λ(k) = lcm(p1−1, …,
pk−1): every unit satisfies xλ =
1. Along the tower it runs 1, 2, 4, 12, 60, 60, 240, 720, 7920,
55440, … — and the repeats are the interesting part.
The transparency
criterion property
Adding pk jumps λ iff
pk − 1 introduces a prime-power factor not
already present in λ. Otherwise pk is
lambda-transparent: capacity grows (φ, idempotents)
but no new dynamical complexity appears. The criterion:
pk is transparent at rung k iff
(pk − 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
The tower thus alternates between two growth modes:
complexity rungs, where λ jumps and new orbit
periods appear, and capacity rungs, where a transparent prime
adds space on the same dynamical skeleton. How the balance between
the two behaves in the limit — the transparency density — is the
program's central open problem, and lives in the
Growth section.
Designed towers
The primorial path is one trajectory through a lattice: any
squarefree set of primes is a tower ring with the full blueprint —
fields, meadow, idempotents, an MDS code where the split is sized.
The sieve identity is primorial-specific; the blueprint is not. The
Walls section carries the charted specimens, including the
internet-checksum ring Z/(216−1) and its
machine-word family.
The seed-flower
The CRT Euler characteristic of a sub-ring on m primes
{p1, …, pm} is
χ = N(1 − m + Σ 1/pi),
N = ∏pi. For m ≥ 2, −χ =
N(m−1) − Σ N/pi is a positive
integer whose prime factors routinely include tower primes the
sub-ring does not contain: {3, 5} gives −χ =
(3−1)(5−1) − 1 = 7 — the next prime, never met. One congruence
governs every such naming.
The reciprocal
naming criterion criterion
An absent prime s divides
−χ({p1, …, pm}) iff
the inverses taken mod s (divide −χ by N mod s).
Corollaries: 2 is never named by a sub-ring not containing it —
odd inverses are all ≡ 1 mod 2, so the sum is m, never m−1;
−χ is coprime to the sub-ring's own primes
(−χ ≡ −N/p mod p) and always odd, so members
never divide; and naming is governed by prime size alone — the
naming fraction for an absent s converges to 1/s, indifferent to
the tower's dynamical structure. The one structured excess: 3 is
named by 51% of 3-prime sub-rings at k = 8 against a 33% baseline —
the Chebyshev prime-race bias read through the criterion — fading
to 1/3 by Dirichlet equidistribution.
Scope. Proved, and checked at 960/960
(sub-ring, absent prime) pairs; the 1/s baseline computed at
k = 25.
verifiers:
explore_tower_naming.py,
explore_chi_primality.py
The factorization
rule rule
Call a pair {pi, pj} of tower
primes a prediction at rung k when its −χ =
(pi−1)(pj−1) − 1 is itself one
of the first k primes — necessarily absent from the pair. New
predictions at rung k come from exactly two sources: the twin term
{2, pk} → pk − 2, firing when
pk − 2 is prime, plus one prediction per
factorization pk + 1 = ab with a + 1 and
b + 1 smaller tower primes. (A new prediction must involve
pk; as a pair element its target
≥ 2pk − 3 escapes the set unless the partner is
2, and as a target it forces the factorization.) A rung admitting
at least one such factorization is rich — typically a highly
composite pk + 1 (pk = 71:
72 = 2³·3², three new predictions) — and richness requires
pk ≡ 3 (mod 4), both factors of
pk + 1 being even. Censused to 5·10⁷: 599,875 of
3,001,134 rungs are rich (20.0%; 40.0% of the 3-mod-4 class), and
rich rungs outnumber twin rungs 2.51× with the ratio growing — the
factorization term dominates the long-run prediction supply.
Scope. The rule is proved and verified
k = 3..24; the census is exhaustive to p ≤ 5·10⁷; sub-rings on
three or more primes name primes beyond this count (the naming
criterion above governs them).
verifiers:
explore_seed_flower_k8.py,
explore_rich_rungs.py