The Tower

The tower reads the integers through one residue window per prime. This page is what you see when you take the windows in the order of the primes: the Eratosthenes sieve. The sieve finds primes by elimination — remove multiples of 2, then 3, then 5, then 7… and the survivors are the primes — and “remove multiples of p” is the same operation as “read the window at p and discard what reads zero.” Each sieve step is a projection onto a prime field; the whole sieve is the ring Z/(2·3·5·…·pk) decomposed by the Chinese Remainder Theorem. Not analogy — identity. The primorial tower is the sequence of these rings: each rung adds one prime, one independent channel, one sieve step. Everything on this page — the rungs, transparency, the growth modes — is the tower as a lens on the primes, with one deliberate detour: the designed towers at the end of the growth modes, where the primes are picked by hand and skipping any costs exactly the lens.

Each sieve step is a channel

At k = 7 — the demo rung throughout this site — N = 510,510 = 2 × 3 × 5 × 7 × 11 × 13 × 17. Every number from 0 to 510,509 maps to a unique 7-tuple of remainders, and every valid 7-tuple maps back to exactly one number. For example, 255,256 decomposes as (0, 1, 1, 1, 1, 1, 1) — even, but with remainder 1 at every odd prime. Type a number and see:

255256 ↦ (0, 1, 1, 1, 1, 1, 1)

Independence

The decomposition gives you independence: a number's remainder mod 2 tells you nothing about its remainder mod 3, or mod 5, or any other channel. Zero mutual information — a theorem, not an approximation. Arithmetic decomposes the same way: adding 1 in the ring is adding 1 in every channel at once, and each channel wraps on its own schedule. Starting from n = 42 = (0, 0, 2, 0, 9, 3, 8), the mod-2 channel wraps every 2 steps, the mod-3 channel every 3 — no channel's wrap ever touches another.

Watch independence in action

Click +1 repeatedly. A channel highlights when it wraps past zero during the step. They wrap at different times; none affects any other. With +10, every channel smaller than 10 wraps at least once — mod 2 wraps five times.

Instead of one problem with 510,510 possibilities, you have 7 problems with at most 17 possibilities each. Total positions across all channels: 2 + 3 + 5 + 7 + 11 + 13 + 17 = 58 — an 8,802× reduction.

The first 14 rungs

Every rung, by construction: all channels are prime fields, arithmetic is bijective, division is total among survivors. MDS error correction (distance 4) from k = 7 onward. This table is recomputed from first principles on every build.

kpkNλTransparent?ECC rate
35304
4721012
5112,31060
61330,03060yes
717510,5102404/7
8199,699,6907205/8
923223,092,8707,9206/9
10296,469,693,23055,4407/10
11312.01 × 101155,440yes8/11
12377.42 × 101255,440yes9/12
13413.04 × 101455,440yes10/13
14431.31 × 101655,440yes11/14

The rungs also carry geometry: each ring's elements live on a k-torus, one circle per channel. Every pair of tower primes draws a torus knot on its 2-torus, and every triple of tower primes carries a Brieskorn homology 3-sphere (computed through k = 9: all 84 triples, Casson invariants from −1 — the Poincaré sphere Σ(2,3,5) — to −308). Channel 2 is the suspension coordinate: a triple containing 2 adds no new signature or Casson data beyond its pair's knot — the same degenerate role channel 2 plays elsewhere in the tower.

Two growth modes

λ is the Carmichael function — the universal period of the power map, the least common multiple of (p−1) over the primes in the ring. Adding a prime either changes λ or doesn't, and that splits growth into two modes:

Complexity. A non-transparent prime brings a new prime-power factor into λ: new orbit periods, new order levels. λ jumps. Examples: 11 (×5), 17 (×4), 23 (×11).

Capacity. A transparent prime adds space without new complexity: φ grows, idempotents double, λ stays put. Example: 13, whose φ(13) = 12 already divides λ = 60.

Transparency criterion (proved): prime p is transparent at rung k iff (p−1) divides λ(k−1).

A λ plateau is a run of rungs sharing one λ value: a jump rung sets it, consecutive transparent primes preserve it. k = 10–14 is a 5-rung plateau at λ = 55,440. Computed out to k = 2000: 77% of primes are transparent, the longest transparent run is 24 consecutive primes (k = 1849–1872), and the non-transparent fraction decays as roughly k−0.17.

Designed towers

Nothing in the construction requires taking the primes in order. Any squarefree set of primes is a tower ring with the full blueprint — prime-field channels, bijective arithmetic, total division, one idempotent per subset, error correction where the set is large enough. The primorial path is one trajectory through the lattice of possible sets, and the prime lens is what that trajectory buys: a set that skips primes is a partial sieve, and the sieve results on this page do not transfer to it. The blueprint does. Choosing the set turns λ and the per-channel hardware cost into design knobs — and a family of such rings is already deployed in the wild:

The internet checksum. RFC 1071's checksum — the one IP, TCP, and UDP use — adds 16-bit words with end-around carry: a carry out of the top bit is added back at the bottom. That fold is reduction mod 216−1 (proved, exhaustive over all single-add sums), and 65,535 = 3 × 5 × 17 × 257 — four Fermat primes, a squarefree all-field set. The final bit-complement is negation in the same ring, so the whole algorithm — sum, fold, complement — runs inside a designed tower, and the checksum splits by construction into four parallel field checksums, one per prime. Incremental update (RFC 1624) — recomputing the checksum when one field of the packet changes — is the ring identity HC′ = HC + m − m′ (m the field's old value, m′ the new) and splits per channel the same way (verified).

The machine word. One size up, the same shape fills a 32-bit word exactly: 232−1 = 3 × 5 × 17 × 257 × 65,537 — all five known Fermat primes. Reduction is one end-around carry per addition on any 32-bit datapath (proved for single adds), and multiplication of units becomes addition of their channel logarithms: every channel's unit count is a power of two, so the log additions are plain masked adds — five in parallel, widths 1, 2, 4, 8, 16, a 31-bit index word.

The fold makes reduction free only where add-with-carry is the native operation — a datapath fact, not a language one. Measured in Python, the plain % beats the fold per addition, and accumulating first then reducing once beats both.

One family, four sizes. These two rings are members of a ladder: 28−1 = 3 × 5 × 17, then 65,535, then 232−1, then 264−1 = 3 × 5 × 17 × 257 × 641 × 65,537 × 6,700,417 — seven prime channels filling a 64-bit word (641 × 6,700,417 is Euler's factorization of 232+1, the first Fermat number that is not prime). Fletcher's checksums live on the first three members: Fletcher-16, -32, and -64 each keep two running sums — a plain sum and a position-weighted one — in one's-complement arithmetic, which is arithmetic mod 255, 65,535, and 232−1 respectively; both sums split per channel by construction, so each prime runs its own smaller Fletcher (verified; the real-world variants that reduce mod 2w instead leave the ring). Adler-32 makes the opposite design choice: the same two running sums, but mod 65,521 — the largest prime below 216, kept prime for error-detection reach (RFC 1950) — one big field in place of Fletcher-32's four small ones. And the 64-bit member closes a loop: with seven channels it is the first of the family large enough for the 4+3 data/parity split, and its four data channels multiply to exactly 65,535 — the internet checksum's ring is the data space of the 64-bit tower: a 16-bit-word payload — one's-complement, its two zero patterns one value — riding a 64-bit word with distance-4 error correction (verified exhaustively over channel subsets).

The k = 7 rung up close

Z/510,510 ≅ Z/2 × Z/3 × Z/5 × Z/7 × Z/11 × Z/13 × Z/17

The demo rung is k = 7 because it is the first rung with the full 4+3 data/parity split (distance-4 MDS error correction, rate 4/7) while staying small enough to verify exhaustively: 510,510 elements, 92,160 of them units.

NameValueCRT tupleMeaning
00(0, 0, 0, 0, 0, 0, 0)All channels zero
11(1, 1, 1, 1, 1, 1, 1)Multiplicative identity
−1510,509(1, 2, 4, 6, 10, 12, 16)Each channel shows p−1
Ω255,256(0, 1, 1, 1, 1, 1, 1)Idempotent: 1 everywhere except mod 2
φ92,160 units
λ240 = 24 · 3 · 5
Idempotents128 (one per subset of 7 primes)

A curiosity: the first 7 primes describe themselves

Iterate c(n) = 2n+1 from the seeds 1 and 2; each chain stops at a composite:

From 1: 1 → 3 → 7 → 15 (stop: 15 = 3×5)
From 2: 2 → 5 → 11 → 23 → 47 → 95 (stop: 95 = 5×19)

That yields five of the primes ≤ 17: {2, 3, 5, 7, 11}. Two more rules close the set: 13 = 2²+3² and 17 = 2+3+5+7. Written additively (3 = 2+1, 5 = 2+3, 7 = 2+5, 11 = 1+2+3+5), the seed is forced: a seed prime > 2 is odd, so seed+1 is even and ≥ 4 — composite. Only 2 works. What is proved is that the first 7 primes admit this closed description — the rules were found after the fact; the rung itself needs no construction, being the first 7 primes by definition.