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 index ring's additive exponent. 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 and “log 0 = −∞” is realized as grade drop.

Scope. The per-field facts are standard (Zech logarithms, discrete-log number systems); the tower-wide composition is the chart. 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 index map recodes each channel independently, so the locality criterion is blind to it: addition stays channel-local, costing one unary Zech table Z(n) = ind(1 + gⁿ) per channel. 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, primitive-root-free; 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}), and 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. No coordinate hosts (+ local, × additive) — the zero/idempotent grading obstructs — and 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

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: MSD-first lex 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: a CRT-built family with constant window vector and unbounded v₂(1 + y) — no fixed window computes any coordinate of a sum. The diagonal is the factorial/primorial mixed radix, 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 wall: 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. Splits: 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 knob — 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 standing poverty: 3 | 2^w − 1 at exactly the even widths, so every member carries channel 3. Beyond n = 6 the blueprint rides the open all-Fermat-squarefree question.

verifiers: explore_machine_word_tower.py, explore_uint64_tower.py