Number systems

Per-channel discrete logs compose with CRT into U(Z/N) ≅ ∏_p Z/(p−1), under which multiplication is channel-wise addition, powering is index scaling, multiplicative order is a per-channel gcd read, e-th-root existence and count are per-channel divisibility, and quadratic residuosity is the index parity bit; λ is the additive exponent of ∏_p Z/(p−1). Non-units extend canonically: x^λ+1 = x for all x, so the multiplicative monoid is a commutative Clifford monoid — the Boolean support lattice carrying the sub-rings' unit groups as grades. In the full log coordinate x ↔ (supp x, indices on supp) — supp x being the channels where x is nonzero — the meadow inverse is index negation: the pseudo-inverse x′ with x·x′·x = x and 0′ = 0, defined on the whole ring at once, which is what makes division total on a squarefree rung. “log 0 = −∞” is realized as grade drop.

Scope. The per-field facts are standard (Zech logarithms, discrete-log number systems); what is stated here is their tower-wide composition. Bijection exhaustive at Z/510510, full log coordinate exhaustive at Z/210.

verifier: explore_index_transform.py

The hard operation in index coordinates is addition, and its wall has a different shape than the archimedean wall — the size wall, so called because it is the obstruction that deleting size leaves. The index map recodes each channel independently, so the locality criterion is blind to it: addition stays channel-local — its value mod p a function of the input mod p alone — costing one unary Zech table Z(n) = ind(1 + gⁿ) per channel, g the channel’s chosen primitive root and ind its discrete log. The wall lives within the channel: Z is incompatible with every nontrivial proper quotient of Z/(p−1) — every p ≥ 5, every divisor 2 ≤ q ≤ (p−1)/2, composite q included — hence not polynomial. A structure obstruction (the table resists compression) where the size wall is an information obstruction (no per-channel table of any size exists). The proof is a linear-fraction count: compatibility mod q demands (1 + ωx)/(1 + x) stay in the index-q subgroup, and for fixed ω ≠ 1 that is linear in x — too few x comply, and every other x yields a violating pair.

Scope. Proved, with no dependence on the choice of primitive root; mechanical check over 263 (p, q) pairs, 5 ≤ p < 200, all divisors.

verifier: explore_index_transform.py

The coordinate systems in which + is channel-local are exactly the coprime factorizations of N (at Z/30: 4 decompositions, the nontrivial partitions of {2, 3, 5}) — a coordinate system counted up to relabeling within each channel, channel-local bijections composing and inverting channel-locally, which is why the index coordinate is the CRT factorization again rather than a fifth entry. Demanding × as well changes nothing — addition alone pins the divisor lattice, so the archimedean wall is unavoidable in every +-local coordinate. Multiplication alone is floppy: U(30) has 4 direct decompositions, 3 crossing tower channels. And no coordinate hosts (+ local, × additive) over the whole ring. The index coordinate comes closest — on the units the pair holds, + channel-local through the Zech tables while × is channel-wise index addition — and the zero/idempotent grading is exactly what stops it extending: off the units multiplication intersects supports, a grade drop no additive coordinate absorbs. None hosts (+, ×, size) together: (+, ×) → CRT, (×, powering) → index, (+, size) → positional, all three → nowhere.

Scope. Exhaustive at k = 3 plus standard ingredients.

verifier: explore_index_transform.py

Powering is not a ring operation to begin with: x^y is ill-defined on residue pairs (348 of 870 witness pairs at Z/30), and is well-defined only as Z/N × Z/λ(N) → Z/N, and there only for exponents ≥ 1 — the floor is not decoration: x^a+λ = x^a holds for every x at a ≥ 1, and at a = 0 it survives on the units alone. So the hyperoperation ladder leaves the ring at its third step: each further exponent level lives one ring down. Existence of the coordinate then comes in three strengths. A single super-log exists iff the index ring has a primitive root — a generator of its unit group, additive cyclicity being automatic (Gauss: m ∈ {1, 2, 4, q^k, 2q^k} for q an odd prime, which is why 16 is not on the list) — inside Z/510510 channels 13 and 17 already fail, and the passing primes thin toward density zero (0.100 → 0.071 → 0.055 at 10⁴, 10⁵, 10⁶). One through a second CRT split exists iff 8 ∤ p−1: the only non-cyclic prime-power unit group is U(2^k), k ≥ 3, so odd places never block and the obstruction is entirely 2-adic (density 3/4; in Z/510510 only p = 17 fails). And the 2-adic patch U(2^k) = ⟨−1⟩ × ⟨5⟩ always exists but is group-only — Z/2^k is local, its only idempotents 0 and 1, so no ring split carries it.

Scope. Type obstruction exhaustive at Z/30 and Z/210, sampled at Z/510510; the a = 0 remark is immediate from the construction. The existence strengths are classical ingredients (Gauss; the unit-group classification) composed here, with the densities a census to 10⁶ — the split strength observed at 0.7509 against the Dirichlet value 3/4.

verifier: explore_super_log.py

Even where the coordinate is patchable, it would run out of object. Iterating λ gives a strictly descending chain — 510510 → 240 → 4 → 2 → 1, height 4 — and each exponent level of a tetration lives one ring further down it, so for any base x ≥ 2 the power tower x^{^^}h mod N is constant once h reaches that height. A super-logarithm mod N would therefore take a handful of values. Below that ceiling the construction does recur, and exactly on the skip towers: when p−1 is squarefree the index ring is itself a tower ring of the same shape — squarefree, so every channel is again a field — but built on a prime set that skips primes rather than starting at 2 (Z/6 and Z/10 are the index rings of 7 and 11), and the whole blueprint — field channels, Clifford monoid, the full log coordinate — recurs verbatim; off the squarefree locus nilpotents appear, elements with a zero power, and the graded extension dies (2 ∈ Z/4, 6 ∈ Z/12). The density of channels that recur is Artin's constant, 0.3740.

Scope. Stabilization validated against exact integer power towers to 7⁽⁷⁷⁾, a 2.3-Mbit integer, every sampled tower settling by depth 4 at Z/510510; the squarefree characterization validated m ≤ 300; recurrence density a census against Mirsky's theorem (0.3745 observed).

verifier: explore_super_log.py

For greedy numeration on a scale 1 = U₀ < U₁ < U₂ < ⋯, the weighted low prefix (digits 0..j−1) equals n mod U_j for all n and j iff the scale is a divisibility chain (U_j | U_i for i ≥ j). Greedy itself buys order on every scale, chain or not: most-significant-digit-first lexicographic order is numeric order. So the archimedean reading comes with greedy, the residue reading comes with the chain, and positional base b — and any divisibility-chain mixed radix — is exactly the coincidence of the two readings: one digit string legible through both windows. That is what a base buys. Zeckendorf keeps only the greedy half — prefixes are not residues, while addition still cascades like carries; its scan-read repair is classical (Frougny: Pisot-scale normalization is a finite transducer).

Scope. Both directions proved; swept exhaustively over all 9139 scales (1, a, b, c) with a < b < c ≤ 40 and all 3876 length-5 scales up to 20 — the property holds exactly at the chains.

verifier: explore_numeration_windows.py

Addition in base b is scan-read but never window-read — a carry can be launched from a position that dodges any fixed window; multiplication is walled classically (with recognizable multiplication, Büchi–Bruyère's decidable theory would decide arithmetic; primes are automaton-recognizable in no base — Minsky–Papert, Hartmanis–Shank). The exponent-vector row walls addition by witness: for any fixed finite set of primes, a CRT-built family y exists whose valuation at every one of them stays zero while the 2-adic valuation v₂(1 + y) grows without bound — no fixed window computes any coordinate of a sum. The factorial/primorial row is the mixed radix on a divisibility chain through every prime: the factorial chain eventually window-reads every m | n, the primorial chain exactly the squarefree m. Every row buys a reading and pays — a walled query, or on that last row the unbounded alphabet: every number system is a choice of which wall to pay.

Scope. Rules with witnesses per cell; classical contacts as cited (plus Cobham–Semenov for the cross-base rigidity that makes the chart per-base, Rényi for the non-chain greedy family). The boldface synthesis is an observation over this census, not a theorem. One grid sits outside the chart's carriers — the continued-fraction window, whose cell mesh is not a function of digit depth (Reading).

verifier: explore_numeration_windows.py

The n = 4 member is Z/(2¹⁶ − 1) = Z/(3·5·17·257). RFC 1071's end-around-carry addition is reduction mod 2¹⁶ − 1 and its final complement is ring negation, so every IP/TCP/UDP packet checksum runs whole in this ring and splits by construction into four parallel field checksums, with collapse to the support idempotent in 8 squarings. RFC 1624's incremental update is the ring identity HC′ = HC + m − m′ and splits — each channel updates from m mod p, m′ mod p alone; the boundary bug RFC 1624 exists to fix (an update yielding −0 where from-scratch gives +0) lives entirely in the two representatives of the ring's zero class.

Scope. The fold law is exhaustive at this member and the incremental split is verified at n = 4, 5 and 6. RFC 1071's appendix derives the fold as a digit-sum remainder.

verifier: explore_checksum_ring.py

At n = 5, Z/(2³² − 1) = Z/(3·5·17·257·65537): all five known Fermat primes filling one 32-bit word exactly. The fold reduces at width 32 — one end-around carry per add, native to any 32-bit datapath — and the index coordinate stacks: every unit-group factor is cyclic of 2-power order, so unit multiplication is five parallel masked index adds (widths 1/2/4/8/16 — a 31-bit index word), and λ = 2¹⁶ collapses any x to its support idempotent in 16 squarings. Fletcher-16/32/64 are the family's checksums: two running sums in 1's-complement arithmetic mod 255/65535/2³²−1 — the members n = 3/4/5 — both splitting per channel, each channel running its own Fletcher. At n = 6 the family leaves the all-Fermat spine (F₅ = 641·6700417, Euler): the uint64 tower Z/(2⁶⁴ − 1), seven channels in one 64-bit word. Survives verbatim: the fold, squarefree all-field, the incremental split. Weakens: the index stack — the two F₅ channels need true mod-(p−1) adds, a 64-bit index word against log₂ φ ≈ 63.0. Dies: the cheap collapse — the family's first non-2-power λ, 33 squarings + 13 multiplies against the spine's 16 + 0. And the ECC payload is the checksum ring: under the tower split — the smallest channels carrying data, the largest carrying parity — the data product is 3·5·17·257 = 65535, so the n = 4 member nests as the data space of n = 6: a 16-bit-word payload riding a 64-bit word at minimum distance d = 4, MDS, one extra payload value dropping d to 3.

Scope. Rules verified per member (fold law exhaustive; incremental split at n = 4, 5, 6; ECC drop exhaustive over subsets). The family's fixed poverty: 3 | 2^w − 1 at exactly the even widths, so every member carries channel 3. Beyond n = 6 the blueprint rides an open question — whether every Fermat number is squarefree; a repeated prime factor in any later F_m would break the all-field channels there. What does not ride it: the exact comparator's cost law (the walls page — the packed key beats reconstruction iff Σ 1/p < 1 over the channels) clears at every member, Σ 1/p < 0.6 at each and the limit sum under 0.5986, because an unfactored F_k needs no factoring: Lucas puts each of its prime factors at 1 mod 2^k+2, so its at most 2^k/(k+2) factors contribute under H_m/2^k+2 (H_m the harmonic number), a tail summing to 0.0009 from k = 12 against the 0.5976 of F₀..F₁₁ exactly.

verifiers: explore_machine_word_tower.py, explore_uint64_tower.py, explore_fermat_reciprocal_tail.py