Words and curves
What two leaves can measure about each other, and
which loci hold torsion at all.
A rung of the tower is Z/N with N the product
of the first k primes, one channel per prime
(The Object). Every channel is a field, so its
nonzero residues form a cyclic group of order p − 1, and a
unit's discrete log is its exponent to a fixed generator of
that group. A measurement program is a word — a formula over
the leaves, the input variables, in MUL/INV/NOT, where INV is the
meadow inverse (channel-wise inverse on the support, 0 elsewhere, so
division is total) and NOT is 1 − a; dropping NOT leaves the
monomial alphabet, whose words are the
aibj with exponents in Z, negative
ones reached through that same inverse. Words are read by the gates
gatem(w) = [wm = 1],
which decide order divisibility channel by channel, and what a program
is asked to decide is a shadow: an exact Boolean condition on
the ring, [ab = 1] or [f = 0]. One leaf, read by every
gate there is, measures exactly its order profile — ord a and
ord(1−a) — and stops there
(Measure). Two leaves measure their relative
position.
Words: the two-leaf world
The word-profile
theorem rule
The word family — gates on aibj,
exponents in Z via the meadow inverse — measures exactly the
leaf discrete logs up to one shared unit: profiles
coincide iff (a′, b′) = (au,
bu) for a single automorphism
x → xu (a cyclic-group fact, any letter
count; the two pencils ord(aib),
ord(abj) already generate, the three words
ord a, ord b, ord ab do not). A single leaf is
the one-letter case — an order is a discrete log up to its own
unit — so the genuinely two-leaf content is the relative position:
where a is a primitive root the profile pins
dloga b exactly, and [ab = 1],
which walls the one-leaf ladder, is one gate. A two-variable shadow
is therefore word-decidable iff constant on conjugacy orbits: every
multiplicative coset [aibj = 1] is
decided, and the additive world is blind except its
crystallographic skeleton (below). The two-leaf read
gatem(ab⁻¹) is the equality
grading on the units: [dlog a ≡ dlog b mod
(p−1)/gcd(m, p−1)] — reflexive, symmetric,
AND-transitive, unit-translation-invariant — a divisor-indexed
congruence ultrametric on the diagonal; it is not an inner
product: every word's discrete log is a linear form in the leaf
discrete logs, and the bilinear candidate factors through the two
single-leaf orders.
Scope. Proved (the theorem and the
grading).
verifier:
explore_joint_measurement.py
The
crystallographic skeleton rule
On a line a + b = c with c ≠ 0, the
inversion u = −1 forces stable points onto ab = 1 and
full stability forces every order-d element to one trace,
φ(d) ≤ 2 — only torsion of order 1, 2, 3, 6 survives
(order 4 lands on c = 0 = [ab⁻¹ = −1], wholly
decided): c = ±2 keep (±1, ±1), c = 1 keeps the
Φ6 pair (iff p ≡ 1 mod 6 — the word-visible part
of the dependent shadow a AND NOT a), c = −1
the Φ3 pair (iff p ≡ 1 mod 3), and every other
line is word-invisible. Deciding channels are exactly
p ≤ 3 — the trivial Galois group, and the same arithmetic
one level up is
the p = 3
rigidity.
Scope. Proved, plus census over all
p ≤ 100.
verifier:
explore_joint_measurement.py
The meadow
wall-breaker rule
Reach is alphabet-graded. Mixed words on one leaf's letters
{a, 1−a} already refine the order profile — first at
p = 11, where the residues 9 and 3 share the profile
(ord a, ord(1−a)) = (5, 5) and the word
a²(1−a) separates them: the wall witness was itself a
word. The four letters {a, b, 1−a, 1−b}
add the six ±1-ratio affine lines ([a + b = 3] stays
blind, witnessed at the Φ6 points of p = 7). And
the full meadow closure is complete:
NOT(a⁻¹)·(NOT a)⁻¹·a = −1 on units
a ≠ 1, so every constant is a one-leaf word and
[x = c] = gate1(xc⁻¹) pins every
residue (0 and 1 need no word: [x = 1] is □x and
[x = 0] is NOT ◇x, the two bits of
the pair). The meadow
inverse is the wall-breaker: every measurement wall in the
hierarchy, the single-leaf wall included, is a fact about
inverse-free alphabets.
Scope. Completeness proved; the alphabet
grading a rule for the swept ranges.
verifier:
explore_joint_measurement.py
Curves: the cut side
Past degree 1 the question inverts: not what a program reads, but
which loci hold torsion — which order-d unit pairs are
orbit-stable for a shadow [f = 0], meaning the pair and
all its conjugates (au, bu) lie on
the locus together. The grading meets coding theory: a torsion order
becomes a cyclic code, and what a shadow can hold becomes that code's
minimum distance.
The fiber
criterion criterion
A unit pair of torsion order d = lcm(ord a,
ord b) is orbit-stable for a shadow [f = 0] iff its
collected monomial fiber Σ cmwmt
(wm = aimbjm,
a character sum on Z/d) either vanishes
identically — f contains the whole cyclic group
⟨(a, b)⟩, the finite shadow of Lang's torsion-coset
theorem — or is a codeword of the cyclotomic cyclic code
(Φd) ⊆
Fp[T]/(Td − 1).
Those two cases are the two species: the whole-group
species, and the codeword species.
Scope. Proved, both directions.
verifier:
explore_curve_skeleton.py
The realizability
law rule
Bounded degree changes realizability, not the menu. Degree
D reaches order d through the codeword species iff
some exponent pair A, B with
gcd(A, B, d) = 1 puts a nonzero
(Φd)-codeword inside the triangle exponent set
{Ai + Bj mod d : i + j ≤
D} — the exponent reduction (criterion, proved). The
minimum degree is 1 for every even d (the antipodal word);
for odd prime d = q the code has dimension one, so
the triangle must cover all of Z/q — a modular
postage-stamp problem, the triangle cover number
c(q) = Θ(√q), bracketed between
√(2q) − 3/2 and 2⌈√q⌉ − 1 and censused exactly for
the 34 odd primes ≤ 149 (c(5) = 2 is the pentagon's
tightness); and qmin(d) − 1 for every
other odd d. The composite tax prices primality itself: at
equal least prime, prime orders cost √-scale degree where
composite orders pay their full least prime linearly (5 vs 25 and
35: degree 2 vs 4; 13 vs 143: 5 vs 10) — degree reads
compositeness where monomial count cannot.
Scope. Criterion and the even/other-odd
prices proved; the Θ(√q) bracket a rule with the census as
stated. Coverage is proved for prime powers at any exponent ≥ 2
(the line pigeonhole), and for composites with
qmin ≤ 7, with qmin² |
d, or with second prime >
3(qmin − 1)/2 (the slice forcing).
verifier:
explore_realizability.py
The two-fat-slice
exclusion rule
For every two-prime d = q·q′ — two close
primes, past the slice-forcing boundary — the question turns
combinatorial and closes. The rook reduction (criterion, proved):
with q′ prime the slices differ by constants, an evader is
a tensor-sum, and a codeword lives in the triangle iff the
triangle's complement in the q × q′ CRT grid is
rook-disconnected — matched row/column partitions with every
off-diagonal block inside the triangle; counting the blocks alone
re-proves the forcing boundary q′ > (3q − 4)/2,
and no prime lives between it and 3(q − 1)/2. The
arithmetic is closed by the staircase lemma: the weak form (≤
2s + 1 lines carry ≥ D + 1 − s lattice
points, proved by pure counting for every
s < (D + 1)/2) closes 46 of the 98 close pairs to
q ≤ 97 on its own, and the strong form (at most
s + 1 lines at depth D + 1 − s) is proved at
every (m, D) and every unit B. Consequence:
no covering system with two fat slices evades at any two-prime
d, any D ≤ q − 2, and the sweeps stand as
verification — complement connected at every swept close pair and
unit B, no witness. Composites of three or more primes with
a close second prime keep only the slice-forcing scope.
verifiers:
explore_cover_exclusion.py,
explore_staircase_reduction.py
What every read above costs — the exact gate count of a stable
orbit, and the word-op price the meadow level moves it into — is
The price of a read.