# DUAL — the leading end of base b, read against the trailing end

The object: base b read top first. A positive integer n has e + 1
digits, e = e(n) = ⌊log_b n⌋, and its depth-t **leading tile** is the
set of integers with the same digit count and the same t leading digits.
Like a window of SIZE.md, this is a reading at a set of places, here the
archimedean place alone: size, read to t digits. So a floating-point
number names a leading tile. The trailing end reads the same integer
bottom first, and its depth-t tile is n mod b^t. A map f of the positive
integers is read at lookahead c when at every depth t the depth-t tile
of f(n) is a function of the depth-(t + c) tile of n, over the n with
f(n) ≥ 1, since zero has no leading tile; a map of two integers reads
the pair of their tiles, and a map valued in {0, 1} or {−1, 0, 1}, as
[x = y] or the sign of x − y, is read at lookahead c when at every depth
t its value is a function of the inputs' depth-(t + c) tiles. This page
shows that the two ends of base b exchange what they read: the places
p | b that the trailing end reads exactly, the leading end hides
exactly, and at a quadratic base β the exchange runs one way, the
leading end hiding an ideal of Z[β] by the time the trailing end reads
it, sometimes sooner or alone, and at a base of any degree span j hides
an ideal when a chain of the powers of β generates its quotient, and
only then when its index is q^j; the difference map (x, y) ↦ x − y,
which the trailing end reads digit by digit, is read at no finite
lookahead at the leading end;
multiplication reads by every factor at the trailing end and division by
every divisor at the leading end. It decides which nondecreasing maps
within bounded distance of a line λn (λ > 0) the leading end reads,
bounds their least lookahead, exactly in the cases the least-lookahead
law names, and shows that it reads maps outside that class. Then it
gives the leading end redundant signed digits {−a, …, a}, 2a + 1 > b:
the overlapping cover they buy reads every Lipschitz map of their range,
or its powers, into that range, and the purchase costs order, a lower
bound on size before a division, and, unless p ∣ 2a + 1, the exact
hiding of the places p ∣ b, degraded to a bias. Last come the leading
end's densities, whose own measure is log-uniform, the Haar measure of
the scale circle.

Which end pays for what. Each end reads, by every operand, the operation
whose carries run away from it. A product's low digits depend only on
the factors' low digits, so the trailing end multiplies at lookahead 0
and divides only where the divisor's primes divide b. Long division
emits the quotient from the top with a bounded remainder, so the leading
end divides by anything and multiplies only where the multiplier's
primes divide b. Where READING.md reads a leading numeration on R, a
scaling y ↦ uy with u > 0 reads iff 1/u ∈ Z[1/b]. On the integers a map
is a floor, and a floor adds one condition, that its jumps fall on tile
boundaries. Redundant digits blur size inside the archimedean window
itself, and order stays walled (read at no finite lookahead), and wider.

```
                 TRAILING END              LEADING END
tile, j digits  n mod b^j, a coset        b^j consecutive integers
the places p | b read exactly              hidden exactly
ideals of Z[β]   read once β^j ∈ I         hidden by then, sometimes
                                           sooner or alone
x − y            read at 0                 walled at every depth
x = y            only mod b^t              walled at every depth
n ↦ un           read at 0                 read iff rad(u) ∣ rad(b)
⌊n/v⌋            read iff rad(v) ∣ rad(b)  read; at digits_b(v)
                                           when v ≥ 2, b ∤ v
redundant digits buy nothing               an overlapping cover
```

rad(u) is the product of the primes dividing u; walled, read at no
finite lookahead.

## The leading-tile lemma
Tier: property.
Verifier: proof; dual.py::section_t.

If e + 1 ≤ t the depth-t leading tile of n is {n}. Otherwise it is
[P b^j, (P + 1) b^j) with j = e + 1 − t and P the t-digit prefix: b^j
consecutive integers, sign-definite. Its span is j, the digits it
hides, and it is deep when j ≥ 1. A tile of span j is therefore a
complete residue system mod b^j, and for m ≥ 2, n mod m is constant
on no tile of length at least 2. The predicate [m ∣ n] is weaker and
is answered by length, not depth: a tile shorter than m that holds no
multiple of m decides it false. At base 2 the depth-2 tile of 4 is
[4, 6), deep, and decides [7 ∣ n].

Proof. The integers with e + 1 digits and prefix P are exactly those
with ⌊n/b^j⌋ = P.

The script groups every n below 2^12, 3^7 and 10^4 by its tile at
depths 1 to 4, and every group is the stated interval.

## The two-ends law
Tier: criterion.
Verifier: proof; dual.py::section_h.

For m ≥ 2 and j ≥ 0, n mod m is a function of the last j digits iff
m ∣ b^j, and every residue mod m has the same count on every leading
tile of span j iff m ∣ b^j. So one condition decides both ends: depth j
of the trailing end reads m exactly where span j at the leading end
hides it exactly. A prime p is read by some trailing depth and hidden on
every deep leading tile iff p ∣ b, and for p ∤ b, n mod p is a function
of no trailing depth and hidden on no deep leading tile.

Proof. The first half is the suffix read
(COORDINATES.md#the-suffix-and-floor-reads). For the second, a span-j
tile is b^j consecutive integers. Each residue appears b^j/m times
when m ∣ b^j, and otherwise ⌊b^j/m⌋ or ⌊b^j/m⌋ + 1 times, both counts
occurring, on every such tile.

When rad(m) ∣ rad(b), m is hidden from span max_p ⌈v_p(m)/v_p(b)⌉ on,
v_p the p-adic valuation, the depth at which the trailing end first
reads it. The finite mirror is
SIZE.md#the-hiding-lemma: a window of a residue ring hides the sign bit
exactly iff the ring's size over the window's is even, as a leading tile
hides m exactly iff m ∣ b^j. The script reads all 1595 triples
b = 2..12, m = 2..30, j = 0..4, the leading half on every tile with a
one- or two-digit prefix; the trailing half is the suffix read.

## The two ends of a quadratic base
Tier: criterion.
Verifier: proof; dualquad.py::main, dual2i.py::section_controls,
dual2i.py::section_ideals, dual2i_split.py::main,
dualdeg.py::section_witness, dualdeg.py::section_cubic.

Let O = Z[x]/(x² + px + q) = Z + Zβ, β the class of x, q ≥ 2, and
digits D = {0, …, q − 1}. A leading tile of span j is a translate of
T_j = {Σ_(k<j) d_k β^k}, and a depth-j trailing tile is a coset of
β^j O; when x² + px + q is irreducible and −1 ≤ p ≤ q, each element of
O is written once (Kátai and Kovács, Acta Sci. Math. 42 (1980),
99–107), and the law below does not need it. Depth j reads an ideal I when
β^j ∈ I, and span j hides I when every residue mod I has the same count
on T_j. Write (I : x) for {y : xy ∈ I}. Then span j ≥ 1 hides I iff

    O/(I : β^(j−1)) = Z/m with m ∣ q, generated by 1,

that is iff I ⊇ β^(j−1)(m, β − r) for some m ∣ q and r with
r² + pr + q ≡ 0 mod m. Depth j reads I iff β ∈ (I : β^(j−1)), so with
s ≥ 1 the least span and β ↦ r in O/(I : β^(s−1)) = Z/m, the least
depth is s − 1 + w, w ≤ max_l v_l(q) the least with r^w ≡ 0 mod m,
and I is read at no depth when some prime dividing m does not divide
r. So read implies hidden, both need the index of I to divide q^j, and
the leading end is early by w − 1 digits or alone. At a split prime
norm, −2 + i say, (β̄) = (q, β + p) is hidden from span 1 and read at no
depth, −p being a unit mod q. The script reads the law at 100 bases, 2 ≤
q ≤ 12 with −1 ≤ p ≤ q and −4 + i, over the 17144 pairs (I, j) with the
index of I dividing q^j, 1 ≤ j ≤ J, q^J ≤ 10⁴, 9085 hidden, and the
least depth to J at every ideal of least span 1 ≤ s ≤ J, gaps 0, 1 and 2
printed. The span-1 criterion and the if half of the proof below read no
degree; the only if is quadratic, and the law is the chain law's
degree-2 face (DUAL.md#the-chain-law). At x³ + x² + x + 2, Q = (2, β² +
β + 1), with O/Q = F₄, is hidden from span 2 and read at no depth, while
O/(Q : β) = O/Q is not cyclic, and over the chain law's 250 cubic bases
the colon law misses 1492 of the 12626 pairs whose index divides q^j.

Base 2i is x² + 4: m ∣ 4 and r ∈ {0, 2}, so read at depth j implies
hidden at span j implies read at depth j + 1. Since (2i)² = −4, its
even places write x and its odd places y of x + 2yi in base −4, so a
span-j tile is a translate of the box [0, A_j) × [0, B_j),
A_j = 4^⌈j/2⌉, B_j = 4^⌊j/2⌋, and (2i)^j Z[2i] = A_jZ × B_jZ. At an
index 2^k the least span equals the least depth iff I = aZ × dZ, and is
one less otherwise; each index 2^k, k ≥ 2, holds three ideals, two of
them boxes when k is even and one when k is odd. No one ideal decides
both ends: (2i) = 4Z × Z and (4, β − 2) = {x + 2y ≡ 0 mod 4}, read at
depth 2, are both hidden at span 1, their intersection 4Z × 2Z, of
index 8 against a box
of 4 points, is not, so no H makes span 1 hide exactly the I ⊇ H, as
b^jZ does at base b.

Proof. Write a character of O as (χ(1), χ(β)) ∈ (Q/Z)²; β acts by
(a, b) ↦ (b, −qa − pb) and β̄ = −p − β by (−pa − b, qa). Call χ
dead when χ(1) ≠ 0 and qχ(1) = 0. A character's sum over T_j is
∏_(k<j) Σ_(d∈D) exp(2πi dχ(β^k)), and a factor is 0 iff βᵏχ is dead; so span 1
hides J iff every χ ≠ 0 of O/J is dead, iff 1 generates O/J with order
dividing q. If: T_(j−1) is complete mod β^(j−1)O, so each coset of
I + β^(j−1)O gets its share, and inside it β^(j−1)D is equidistributed
on (I + β^(j−1)O)/I ≅ O/K, K = (I : β^(j−1)). Only if: hiding passes to
every ideal over I, so to each l-primary part I_l, the kernel of
O → (O/I)_l, and K is the intersection of the (I_l : β^(j−1)); by the
CRT, let I have l-power index, v = v_l(q). β maps the characters of
O/L onto those of O/(L : β), with kernel the (t, 0) of O/(L + βO), a
quotient Z/g of O/βO. The step: a ψ' ≠ 0, not dead, in the image has a
preimage not dead. Else a preimage (a, a') has qa = 0, so
ψ' = (a', −pa'), a' ≠ 0 and l^v a' ≠ 0, and β̄(a, a') = (x, 0) with
l^v x ≠ 0, whose multiples killed by l^v put l^v elements in the
kernel: g = l^v, and a + (1/l^v)Z holds 0. If span 1 does not hide K,
a φ ≠ 0 of O/K is not dead, and the step from (I : β^(j−2)) down to I
lifts it to a χ with no βᵏχ dead, k < j: a nonzero sum. At some ideals
of mixed index the step dead-ends, at q = 6, 10 and 12 in the script.

The 2i boxes. A character (α, γ) of the box has a sum that is a product
of two geometric sums, so span j hides I iff every χ ≠ 0 has α ∉ Z,
A_jα ∈ Z or γ ∉ Z, B_jγ ∈ Z. Write I = Z(a, 0) + Z(c, d), 0 ≤ c < a,
g = gcd(a, c). The x-coordinates of I are gZ and its y-coordinates dZ,
so (α, 0) is trivial on I iff gα ∈ Z and (0, γ) iff dγ ∈ Z, and
(α, γ) ↦ (γ, −4α) gives d ∣ g ∣ 4d; (A, 0) ∈ I iff a ∣ A and
(0, B) ∈ I iff (ad/g) ∣ B, and 2i(c, d) ∈ I gives d ∣ c and
a ∣ 4d + c²/d. At index 2^k the least depth t exists, (2i)^(2k) = ±4^k
lying in 2^k Z[2i] ⊆ I, and a, d, g are powers of 2; t = 0 is Z[2i], a
box. Let t ≥ 1. At
t − 1 one axis is short of t's and the other is read, so span t − 1
hides I iff d ∣ B_(t−1) when t is even, iff g ∣ A_(t−1) when t is odd.
When c = 0, g = a and ad/g = d, so this is the read at t − 1, which
fails. When c ≠ 0, g < a. If t is even and span t − 1 does not hide I,
with R = A_t = B_t, then d ∣ R, d ∤ R/4 and d ∣ g ∣ a ∣ R force
d = g = R/2, a = R, c = R/2 (the one c < a with gcd(a, c) = g), where
a ∤ 5d. If t is odd, with R = A_(t−1) = B_(t−1), then g ∣ 4R, g ∤ R and
g < a ∣ 4R force g = 2R, a = 4R;
then 2d = ad/g ∣ R and g ∣ 4d force d = R/2, a = 8d, c = 4d, where
a ∤ 20d. The ideals are a = dm, c = du,
0 ≤ u < m, m ∣ u² + 4: d ∣ g, d ∣ c and a ∣ 4d + c²/d give it, and
2i(a, 0) = m(c, d) − u(a, 0), 2i(c, d) = u(c, d) − ((u² + 4)/m)(a, 0)
the converse; at index d²m = 2^k, 16 ∤ u² + 4, so m is 1 or 4
at k even and 2 or 8 at k odd, and the roots u = 0 at m = 1 and 2,
u = 0, 2 at m = 4 and u = 2, 6 at m = 8 give the three from k = 2 on.

## The chain law
Tier: theorem.
Verifier: proof; dualn.py::section_chain.

Let f be monic of degree n with f(0) = ±q, q ≥ 2, O = Z[x]/(f) = Z[β],
and D and T_j as at a quadratic base; let I be an ideal of finite index
N, G = O/I and g_k the class of β^k. The chain of (I, j) grows a set
S ⊆ {0, …, j − 1} from the empty set by any k with q g_k in G_S, the
subgroup the g_s, s ∈ S, generate. Then span j hides I if the chain
reaches G_S = G, and, when N = q^j, only if. At degree 2 it reaches G
at every pair span j hides, so there it is a criterion at every index,
equivalent to the colon law.

Proof. A character χ of G sums over T_j to
∏_(k<j) Σ_(d∈D) exp(2πi dχ(g_k)), a factor being 0 iff χ(g_k) ≠ 0 and
qχ(g_k) = 0; that reads no degree. Since q g_k ∈ G_S stays true as S
grows, the greedy chain decides whether some chain reaches G. If: a
χ ≠ 0 is 0 on G_∅ and not on G, so one step, adding k, is the first
after which χ is not 0 on G_S; then χ(g_k) ≠ 0, and q g_k lies in the
earlier G_S, where χ is 0, so qχ(g_k) = 0 and the sum is 0.
Only if, at N = q^j: the q^j points of T_j put each class of G once,
so G = Dg_0 ⊕ ⋯ ⊕ Dg_(j−1) factors G by the cyclic sets
{0, g, …, (q − 1)g} of q distinct points. By Hajós's theorem
(Math. Z. 47 (1942), 427–467), for cyclic sets of any length (stated so
as Theorem 1 of Corrádi and Szabó, Comment. Math. Univ. Carolin. 51
(2010), 1–8), one Dg_k is a subgroup, so
q g_k = 0 and k starts the chain. The other Dg_(k′) factor G/⟨g_k⟩
directly, so by induction on the number of cyclic sets, the statement
being one of any finite abelian group factored by sets
{0, h, …, (q − 1)h}, their chain reaches it, and it lifts, a step
q g_(k′) ∈ G_(S′) + ⟨g_k⟩ being one in G.
Degree 2: if span j hides I, the colon law gives O/K = Z/m generated
by 1, m ∣ q, K = (I : β^(j−1)), so q g_(j−1) = 0 and g_(j−1)
generates (β^(j−1)O + I)/I; the chain of O/β^(j−1)O, of index q^(j−1)
where T_(j−1) is complete, reaches it by the only if and maps onto
G/⟨g_(j−1)⟩.

The script runs the chain at the colon law's 100 quadratic bases, 0
off over the 17144 pairs whose index divides q^j, and at 250 cubic
bases x³ + ax² + bx ± q, 2 ≤ q ≤ 6, −2 ≤ a, b ≤ 2, q^J ≤ 128. Over all
24966 cubic pairs (I, j), 1 ≤ j ≤ J, it reaches G at no unhidden pair
(testing 2q g_k, 3346 do); over the 12626 whose index divides q^j it is
off at none of the 4428 with N = q^j and misses 12 hidden pairs, at
x³ ± x² + x ± 2 with Q = (2, β² + β + 1): Q² at j = 6 and 7, 2Q at
j = 7. There every g_k has order 4, so no k enters the chain, and T_j
covers G 2^j/N times, a multiple factorization, where Hajós's theorem
says nothing.

## The chain at depth
Tier: theorem at q = l^e where f's l-adic factor has degree ≤ 2 or is
x³ + a₀; property at j ≥ t and at squarefree q; rule at a cubic 2-adic
factor at q = 4 and 8 (verified wherever O/I has exponent at most 32).
Verifier: proof; dualrs.py::section_l2, dualrs.py::section_w,
dualmult.py::report, dualmult.py::main, dualpw.py::section_k,
dualpw.py::section_t.

Let depth t read I, as at a quadratic base, t the least such: its depth.
The chain law's converse, at the tier's scope: at an I read at some
depth, span j hides I only if the chain of (I, j) reaches G. Put F_k =
β^k G; F_k/F_(k+1)
is cyclic on g_k, and q g_k ∈ F_(k+1) since q ∈ βO. So q^t ∈ β^t O ⊆ I,
and G is a sum of l-groups, l | q. At j ≥ t, F_j = 0, so each q g_k lies
in the subgroup g_(k+1), …, g_(j−1) generate and the chain runs down
from j − 1.
At squarefree q, q/l is a unit on the l-part, so l kills each of its
layers, and none is trivial above its own depth t_l (F_k = βF_k forces
F_k = 0): it has order l^(t_l), and hiding needs N | q^j, so each t_l ≤
j and t = max t_l ≤ j. The content is the pairs **below depth**, j < t.
The script reads the 250 cubic bases of the chain law at q^J ≤ 256 and
108 quartic x⁴ + ax³ + bx² + cx ± q, q = 2, 3, a, b, c ∈ {−1, 0, 1}, at
q^J ≤ 64 and 81: of the 14138 and 4338 hidden pairs, the chain misses 24
and 12, all read at no depth (a plant testing depth by qβ counts all 36
as read at some depth), and the 606 hidden pairs below depth, all cubic
at q = 4, reach
G at every one: 96 at a factor of degree 2, which the theorem below
covers, and 510 at degree 3, whose O/I have exponent 4, 8, 16 and 32 at
130, 202, 94 and 84 of them, which DUAL.md#the-witness-at-q--2e
covers.

At q = l^e, l prime, the converse at every I read at some depth is a
theorem wherever f's factor f₀ over the l-adic integers with
f₀ ≡ x^r mod l (Hensel; β is a unit on the other factor) has r ≤ 2, as
at x³ + ax² + bx ± 4 wherever a or b is odd, or is x³ + a₀, as at
x³ ± q.
With T_W = {Σ_(k∈W) d_k g_k : d_k ∈ D} for a finite window W of
indices, through G/⟨g_k⟩ by induction on |G| + |W| it is enough that
T_W uniform on G ≠ 0 forces q g_k = 0 at some k ∈ W. G is Z_l[β]/L,
Z_l[β] = Z_l[x]/(f₀), L a Z_l-lattice (not always an ideal), and
the closure reduction (dualrs.py's R14, sketched in DUAL.md#open-fronts)
puts in a least counterexample both invariant factors of G
above q and each of its l + 1 subgroups of order l some ⟨q g_k⟩. Both
above q put L in l^(e+1)Z_l[β]; with M = l^(−e−1)L, multiplying by l^e
carries M/lM onto those subgroups, and ⟨q g_k⟩ is one of them exactly
when β^k ∈ M − lM. With i the least such k, every later one lies in N′ =
β^(i+1)Z_l[β] ∩ M, whose image in M/lM is proper: else N′ = M by
Nakayama, β^i ∈ β^(i+1)Z_l[β], and β would be a unit, but l | f₀(0). So
the hits after β^i lie on one line, and two lines are fewer than l + 1.
The proof reads any window W and no nilpotence; dualrs.py prints the
two-line bound at every such f₀ of degree 2, up to β ↦ vβ with v a unit,
over every rank-2 l-group to order 256 at q = 2, 4, 8 and (Z/32)² at q =
4, 8, to 243 at q = 3, 9 and (Z/27)² at q = 9, and three lines at f₀ =
x³ + 4 on Z/8 × Z/8, a group of rank 2 below the factor's degree 3.
At f₀ = x³ + a₀ the recurrence gives g_(3a+i) = (−a₀)^a g_i, so every
term lies in ⟨g_0⟩, ⟨g_1⟩ or ⟨g_2⟩, and a character χ ≠ 0 that is 0 or
one-to-one on each of the three has no zero factor at a k with q g_k ≠
0: T_W is not uniform. A cyclic G has a faithful χ, and a least
counterexample of rank 3 dies by the count (DUAL.md#open-fronts), so
take G of rank 2 and χ with kernel ⟨h⟩, h ∉ lG, which makes G/⟨h⟩
cyclic. Every subgroup of order l is some such ⟨h⟩'s, and ⟨h⟩ meets
⟨g_i⟩ trivially unless the two share it, so ⟨h⟩ goes through one no
⟨g_i⟩ holds; failing that, l = 2, the three ⟨g_i⟩ hold the three
subgroups of order 2, and an ⟨h⟩ holding g_0 kills ⟨g_0⟩ and meets the
other two trivially. The step reads only that the terms lie in l + 1
cyclic subgroups, never G's invariant factors, and a quotient keeps
f₀. dualrs.py finds that ⟨h⟩ closed (DUAL.md#open-fronts) at 1014174
sequences over 237 pairs (G, a₀), every rank-2 l-group of exponent
above q to order 256 at q = 2, 4, 8 and 243 at q = 3, 9 (`--full`;
every triple to order 32 at q = 2, 4 and 27 at q = 3, 3000 drawn per
pair elsewhere), and open at some sequence of x³ + 2x + 2.

## The witness at q = 2^e
Tier: rule (verified at q = 2, 4, 8 on every G of exponent at most 32,
and on (Z/64)² at q = 2, 4).
Verifier: dualpw.py::section_k, dualpw.py::section_q1,
dualpw.py::section_q2, dualpw.py::section_q3.

The statement the chain at depth rests on past a factor of degree 2
(DUAL.md#open-fronts) holds at q = 2, 4 and 8 wherever f's 2-adic
factor f₀ has degree 3, on every G of exponent at most 32. At squarefree
q the converse does not need it, since there hiding forces j ≥ t
(DUAL.md#the-chain-at-depth); at q = 4 and 8 it carries the converse at
every I whose O/I has exponent at most 32.

A quotient's exponent is at most G's, so a least counterexample of
exponent at most 32 is one among such G; by the cyclic case and the
count of the chain at depth it has rank 2, and by the closure
reduction both invariant factors
above q and no closed subgroup but 0 and G. With q = 2^e it is
therefore enough that on every G = Z/2^N × Z/2^M, e < M ≤ N ≤ 5, at
every f₀ = x³ + a₂x² + a₁x + 2^e with a₁, a₂ even (any a₀ = 2^e v, v a
unit, comes to 2^e by β ↦ wβ, w³ = v⁻¹, cubing being onto the units of
Z₂), every generating sequence has a closed ⟨h⟩, h ∉ 2G, whose
character χ with kernel ⟨h⟩ is then a witness: at each k ∈ W with
qg_k ≠ 0, χ(g_k) = 0 or qχ(g_k) ≠ 0, so with W* those k no factor of
χ's sum over T_(W*), counted with multiplicity, vanishes, and W* does
not hide G, which is all the statement asks (dualrs.py's H1). At e = 1
f₀ is Eisenstein; above, it need not be irreducible nor Z₂[β] maximal,
and nothing below asks either. A generating sequence is β^k mod L for
one Z₂-lattice L of O₀ = Z₂[β], and two with one L differ by an
automorphism of G, so the check runs over (f₀, L). With c₂ the β²
coordinate, c₂(yx) is a perfect pairing on O₀/2^N O₀ (its Gram matrix
on 1, β, β² has determinant −1 at every monic cubic), the characters of
G are the c₂(y·) with y killing L, and the one with kernel ⟨h⟩ shows
⟨h⟩ closed iff no k with qg_k ≠ 0 has c₂(yβ^k) a nonzero multiple of
2^(N−e). At M = N, L is Z₂ν + 2^N O₀ for one point ν of P²(Z/2^N);
below, L is read off ν and a line c in the characters ν^⊥ that kill ν,
those killing L being ⟨c⟩ + 2^(N−M)·ν^⊥. As a₁, a₂ are even, β³ lies in
2O₀ and qβ^k in 2^N O₀ from k = 3(N − e), so k < 3N reads every k with
qg_k ≠ 0; their window runs to that bound 3(N − e) at every f₀ at
e = 1, and above e = 1 only at N = e + 1 among the G read.

dualpw.py (`--full`) finds a closed ⟨h⟩ at every instance, pairs
(f₀, ν) at M = N and triples (f₀, ν, c) below, each lattice met more
than once: on every such G of exponent at most 32 at each q, from 112
instances on (Z/4)² to
22020096 on Z/32 × Z/16, and on (Z/64)² at q = 2, 4. At N = 2, 3 and a₀
= 2, 4 every instance's sequence generates G with ν in its kernel, and
the instances meet every lattice of a generating triple of G, 28, 168
and 112 at (Z/4)², Z/8 × Z/4 and (Z/8)². The closed ⟨h⟩ are those a
brute membership reader finds at every instance at N = 2, 3 (q = 2) and
on (Z/8)² (q = 4), and at 1000 drawn per G at N = 4 and 500 at N = 5 at
each q, where a reader dropping the last k that can be active disagrees
at some draws, not all; at x³ + 2^e, where the binomial factor's proof
holds, every instance has one. The fewest closed ⟨h⟩ at one instance is
2 or 3 on every G of exponent at most 32 but two, where it is 1: Z/32 ×
Z/16 at q = 2, f₀ = x³ + 2x² + 2x + 2, and (Z/32)² at q = 4, f₀ = x³ +
14x² + 2x + 4; on (Z/64)² it is 2 at q = 2 and 5 at q = 4.

## The crown exchange
Tier: property.
Verifier: proof; dual.py::section_z.

The leading end reads sign and exponent natively and a product's
exponent to one bit, e(xy) − e(x) − e(y) ∈ {0, 1}. It reads neither
equality nor the order of nearby values at any depth: two points of one
deep tile of span j differ by any integer in (−b^j, b^j), so on that
tile paired with itself [x = y] and the sign of x − y take every value
and e(|x − y|) takes 0, …, j − 1, at every depth. The trailing end reads
x − y at lookahead 0 but x = y only modulo b^t, and a residue ring
reads x − y = 0 exactly, channel by channel.

Proof. b^(e(x)+e(y)) ≤ xy < b^(e(x)+e(y)+2). The difference set of an
interval of b^j integers is (−b^j, b^j).

The script finds e(xy) − e(x) − e(y) taking exactly 0 and 1 over all x, y below
2^10, 3^7 and 500 at bases 2, 3 and 10, and the tiles [64, 128) at base
2 and [1000, 2000) at base 10 realizing every difference exponent below
their spans, 6 and 3, with both signs and 0.

## The coset rigidity
Tier: property.
Verifier: proof; dual.py::section_c.

Let a digit set D write every integer as a finite trailing string, as
{−a, …, a} does whenever 2a + 1 ≥ b and a ≥ 1. The completions of a
trailing prefix of value V and length t are then exactly the coset
V + b^t Z. Two such tiles of one length are equal or disjoint, so the
trailing tiles are the b-adic balls however redundant D is.
READING.md's Lipschitz and division criteria hold unchanged, and no
such digit set buys the trailing end an overlap: for such digit sets
redundancy is a purchase for the leading end only.

Proof. The extension's digits write any integer z, and the completion
is V + b^t z. For {−a, …, a}: take d ≡ n mod b in D and n′ = (n − d)/b.
Then |n′| ≤ (|n| + a)/b < |n| while |n| > a/(b − 1), and every |n| ≤ a
is a digit.

The script writes and reads back every |n| ≤ 10^4 at (b, a) = (2, 1),
(3, 1), (4, 2), (10, 5) and (10, 6). At each, five extension digits
reach every z with |z| ≤ b^3, so every prefix of length up to 3 fills
its coset within b^(t+3) of V.

## The affine class theorem
Tier: theorem.
Verifier: proof; dual.py::section_a, dual.py::section_0.

Let f be nondecreasing with |f(n) − λn| ≤ C, λ > 0. f is read at some
lookahead iff
- Slope: λ = b^r/h for integers r ≥ 0 and h ≥ 1, the reduced
  numerator of λ dividing a power of b, r taken least; and
- Alignment: for some K ≥ 0 every positive multiple N of h b^K has
  f(N) ≥ λN > f(N − 1).

Three families follow. The **numerator criterion**: ⌊(u/v)n⌋ with
gcd(u, v) = 1 is read iff rad(u) ∣ rad(b), so the denominator is free
and every floor division reads. The **phase law**: ⌊(n + s)/v⌋ with
0 ≤ s < v is read iff s = 0, and n + ω, ω an integer, iff ω = 0. The
**sum criterion**: f = Σ w_i ⌊n/v_i⌋ with w_i ≥ 1, ℓ = lcm(v_i) and U =
Σ w_i ℓ/v_i is read iff rad(U) ∣ rad(b), U the numerator over the lcm,
unreduced. So g = ⌊n/3⌋ + ⌊n/7⌋ is read at base 10, U = 10, and is no
⌊(10n + s)/21⌋ with 0 ≤ s < 21, since those stay within 1 of 10n/21 and
g(20) − 200/21 = −32/21. The arithmetic maps the leading end reads are
wider than the numerator family and its phases.

Proof. Write Δ = ⌈C/λ⌉ + 1, and n*(B) = min{n : f(n) ≥ B} for the
crossing of B, so |n*(B) − B/λ| ≤ Δ. The depth-t output boundaries
are the integers M b^J with 1 ≤ M < b^t. A monotone f sends a
depth-(t + c) input tile into one output tile iff no crossing sits
strictly inside it. So f is read at lookahead c iff every crossing n*
with f(n* − 1) ≥ 1 lying in a deep tile, of span j = digits(n*) −
t − c, is that tile's left end, b^j ∣ n*: call such a crossing
aligned.

Slope. n*(b^J) has at least J − G digits for a constant G, so at
depth 1 and lookahead c being aligned makes b^(J−G−1−c) divide it. The
integer n*(b^J)/b^(J−G−1−c) lies within Δ b^(G+1+c−J) of the fixed
real b^(G+1+c)/λ, which is therefore an integer: λ is a power of b
over an integer, which is b^r/h once r is taken least.

Alignment, necessity. For J ≥ r and M with exactly t digits,
N₀ = M b^J/λ = h M b^(J−r) is an integer. The crossing lies within Δ of it and
has at least t + J − r − 1 digits, so being aligned gives
b^(J−r−1−c) ∣ n*.
N₀ is a multiple of the same power, so once b^(J−r−1−c) > Δ the two are
equal. That threshold J₀ depends on neither M nor t, and every multiple
of h b^(J₀−r) is h M b^(J−r) with b ∤ M, t = digits(M) and J ≥ J₀, so it
is its own crossing.

Alignment, sufficiency. For J ≥ r + K the crossing of M b^J is
N = h M b^(J−r), of at most digits(h) + t + J − r digits, so at
c ≥ digits(h) its tile has span at most J − r and N is aligned. For
J < r + K the crossing is below h b^(t+K−1) + Δ + 1, in no deep tile
at c ≥ digits(h) + K + digits(Δ).

The families. ⌊(u/v)n⌋: the slope needs u ∣ b^r, and then every
multiple N of h = v b^r/u has f(N) = λN > f(N − 1), K = 0. ⌊(n + s)/v⌋
with 0 < s < v has f(N − 1) = N/v at every multiple of v, so it fails at
every K, and n + ω needs ω ≥ 0 for f(N) ≥ N and ω < 1 for
f(N − 1) < N. For the sums, f(n) ≤ λn with equality iff ℓ ∣ n, and
f(N − 1) = λN − Σ w_i when ℓ ∣ N, so alignment holds at K iff
ℓ ∣ h b^K, iff U ∣ b^(r+K).

The slope half is READING.md#the-wall-criterion on the integers; the
alignment half is what floors add. It is not implied by the slope:
⌊n/3⌋ + ⌊n/6⌋ has λ = 1/2 and U = 3, so it fails at every base prime to
3. The proof constructs a misaligned crossing wherever a condition
fails, and the families' verdicts are also checked by computation. At
171 sums, the 55 pairs 2 ≤ v₁ < v₂ ≤ 12 at bases 2, 6 and 10 and six
more sums at base 10, three of them weighted, a crossing reader (depths
1 to 3, lookahead to 10) and the alignment condition read directly each
agree with rad(U) ∣ rad(b) at all 171, 42 of them read. The slope holds
with rad(U) ∤ rad(b) at 2 sums at base 2, 3 at base 10 and none at base
6. At depths 1 and 2, the numerator criterion holds at all 273 cases,
the 91 coprime maps ⌊(u/v)n⌋ with u, v ≤ 12 at each of bases 2, 6 and
10, and the phase law holds at v = 3, 5, 7 and |ω| ≤ 3 at bases 2 and
10. An
exhaustive reader grouping every n below 10^6 finds g at base 10 with
1552 and 1103 input tiles whose image meets two output tiles, summed
over depths 1 to 3, at c = 0 and 1 and none at 2. Over n below 2^13, 6^5
and 10^4 it agrees with the crossing reader at all 1368 (sum, depth, c)
it decides, at depths 1 and 2 and c ≤ 3, 1130 of them at an input depth
t + c below the run's digit count, where an input tile holds more than
one number.

## The least-lookahead law
Tier: theorem; pattern (the scanned lookahead under the sharper bound
of the last paragraph at the 42 read sums, unproved as a bound on
c_min).
Verifier: proof; dual.py::section_k.

In the affine class theorem's notation, with Δ = ⌈C/λ⌉ + 1 as in its
proof and c_min the least lookahead at which f is read, take K least,
δ = digits_b(h), μ = v_b(h), the exponent of the largest power of b
dividing h, and h′ = h/b^μ. Then
c_min ≥ c_deep = digits_b(h′) − [h′ = 1], and c_min ≤ max(c_deep, δ + K)
whenever Δ ≤ (b − 1) b^(δ+K). So when K = 0, h ≥ 2, b ∤ h and
Δ ≤ (b − 1) b^δ,

    c_min = digits_b(h),

the lookahead priced exactly: ⌊n/3⌋ reads at 1 at base 10, and g at 2.

Proof. The deep bound. For J ≥ r + K the crossing of M b^J is
N = h M b^(J−r), its depth-(t + c) tile has span digits(hM) + J − r −
t − c, and N is aligned iff c ≥ digits(hM) − t − v_b(hM). For M prime
to b, v_b(hM) = μ; M is taken so because v_b is not additive at a
composite b (2 · 5 at base 10). The bound is then δ − μ when the
product overflows into δ + t digits and δ − μ − 1 otherwise, and
every M gives at most δ − μ. The overflow interval [b^(δ+t−1)/h, b^t)
is nonempty iff h > b^(δ−1), iff h′ ≥ 2. Its length grows with t, and
any b consecutive integers hold one ≡ 1 mod b. So at every large J a
crossing of the layer J ≥ r + K needs c_deep. For J < r + K the
crossing is below b^(δ+t+K−1) + Δ, hence below b^(δ+t+K) when
Δ ≤ (b − 1) b^(δ+K), and its tile has span at most δ + K − c.

The script reads c_scan, the least lookahead that suffices at every
crossing it scans (output depths up to the first whose overflow interval
holds an integer prime to b, and at least to 3, exponents to r + K + 6),
so c_scan ≤ c_min, at the 42 read sums. c_scan ≥ c_deep at all 42, with
a crossing of the layer J = r + K + 2 needing exactly c_deep found.
All 42 meet Δ ≤ (b − 1)
b^(δ+K) and sit under the bound, and c_scan = digits_b(h) at all 30 sums
the law covers; since c_scan ≤ c_min, these are consistency checks, and
only the proof carries the upper bound. ⌊n/3⌋ + ⌊n/9⌋ at base 2 has
h = 9 and c_scan = 4, decided first at depth 4 by the crossing 135 of 15
· 2². A reader stopping at depth 3 reads 3, as the script prints. c_scan
sits under the sharper bound max(c_deep, δ + K − 1) at all 42 sums, with
equality at 41: a pattern, unproved as a bound on c_min.

## The two-ends exchange
Tier: criterion.
Verifier: proof; dual.py::section_a, reading.py::section_r.

Let u, v ≥ 1 be coprime. At the trailing end n ↦ un is read at
lookahead 0 and ⌊n/v⌋ is read iff rad(v) ∣ rad(b). At the leading end
⌊n/v⌋ is read and ⌊(u/v)n⌋ is read iff rad(u) ∣ rad(b). One radical
condition falls on opposite parts of the fraction.

Proof. The trailing half is READING.md#the-division-criterion at the
chain b^t, with multiplication 1-Lipschitz. The leading half is the
numerator criterion.

## The structural split
Tier: property.
Verifier: proof; dual.py::section_s.

A map is read at lookahead 0 iff it sends every tile into a tile of the
same depth, and that asks for no arithmetic. At base 2, the flip n ↦ n
XOR 2^(e−1) changes the second digit, on n ≥ 2. At base 10, π(n) sends
the second digit d to 9 − d, on n ≥ 10. The power n ↦ b^e is
nondecreasing with b^e/n running over (1/b, 1], so no line lies within a
bounded distance of it. All three are read at lookahead 0, and the flip
and π are not monotone. On a finite product of finite fields a map is
channel-local iff it is a polynomial (SIZE.md#the-locality-criterion):
on a squarefree residue ring locality and algebra coincide, and at the
leading end they part. The trailing end's ring Z/b^t is no such ring
once b^t is not squarefree, and there the two can part: at base 2 they
agree at Z/4 (64 each) and part at Z/8, where the maps read at
lookahead 0 number 2^(2+4+8) = 2^14, the value mod 2^t chosen
one binary digit at a time, while the polynomial functions number
∏_(i<4) 8/gcd(8, i!) = 8 · 8 · 4 · 4 = 2^10 (Kempner, Trans. Amer.
Math. Soc. 22, 1921). The script counts the polynomial functions by
brute force, and the maps read at lookahead 0 by brute force at Z/4
and by the digit-by-digit product at Z/8, the two agreeing at Z/4;
every polynomial function is among those maps.

Proof. Each fixes the digit count and rewrites the leading t digits by a
map that reads only them, so a depth-t tile maps into one depth-t tile.

The script finds every tile sent into one tile at depths 1 to 4 for the
flip below 2^12 and for π and the power below 10^5. The flip sends 2 to
3 and 3 to 2, π(10) = 19 > π(11) = 18, and the power's b^e/n is 0.1010
at n = 99.

## The redundant reader
Tier: theorem.
Verifier: proof; dual.py::section_r.

Give the leading end the digits {−a, …, a} with 2a + 1 > b, and read
0.d₁d₂… as y = Σ d_i b^(−i) in [−ρ, ρ], ρ = a/(b − 1) > 1/2. The
completions of a depth-t prefix of value V are exactly the interval
[V − ρb^(−t), V + ρb^(−t)], and adjacent children of a tile overlap by
(2ρ − 1)b^(−t−1) > 0. A map is read at lookahead c here when a reader
seeing the inputs c digits ahead can always commit a child tile that
holds every image still possible. Every map F: [−ρ, ρ]^k → [−ρ, ρ]
of k ≥ 1 inputs that is L-Lipschitz in the sup metric is read at lookahead

    max(0, ⌈log_b L + log_b(2a/(2a − b + 1))⌉).

So every scaling y ↦ (u/v)y with |u/v| ≤ 1 is read whatever the
radical of u, and so are the mean (x + y)/2 and the product xy/ρ:
redundancy dissolves every wall (READING.md#the-wall-criterion) of a
Lipschitz map of [−ρ, ρ]^k into [−ρ, ρ].

Proof. The j-digit strings write every integer in [−aR_j, aR_j],
R_j = (b^j − 1)/(b − 1), by induction, since the intervals
[bz − a, bz + a] over consecutive z abut when 2a + 1 ≥ b. A limit of
finite completions is a completion, which gives the interval. A tile's
children are centred at V + d b^(−t−1) with radius ρb^(−t−1); the
extreme ones reach V ± (a + ρ)b^(−t−1) = V ± ρb^(−t), and adjacent
ones overlap by 2ρb^(−t−1) − b^(−t−1). So every subinterval of a tile
of length at most (2ρ − 1)b^(−t−1) lies in one child. At b^c ≥
2ρL/(2ρ − 1), if the committed depth-t tile holds F of the inputs'
depth-(t + c) tiles, as [−ρ, ρ] does at t = 0, then F of the
depth-(t + 1 + c) tiles lies inside it with diameter at most
2ρL b^(−t−1−c) ≤ (2ρ − 1)b^(−t−1). It fits a child, and committing that
child keeps the hypothesis.

At (2, 1) the lookahead is READING.md's max(0, ⌈log₂ L⌉ + 1). The bound
is a sufficient lookahead, and for a C² map F of one input, not affine
on [−ρ, ρ], L the sup of |F′|, it is the least: with ρ = a/(b − 1) it is
the inequality b^c(2a + 1 − b) ≥ 2aL of
REDUNDANT.md#the-many-stream-theorem at one stream and lead 0, the lead
at which that page's output root tile is [−ρ, ρ] itself. In that page's
letters, its gradient sup Λ is this page's L, its delay (lead plus
lookahead) is c here, its slack is 2a + 1 − b, and its digit-interval
length |I| is 2a. At the continued-fraction
numeration the same purchase cures walls and not the lag
(RATES.md#the-ladder-law), since there a tile's scale is not a function
of its depth. With 2a + 1 = b the overlap is 0, and balanced ternary
reads y/2 at the stream 1 0 0 … at no finite lookahead, every input
tile's image holding the boundary 1/6 in its interior. At lookahead 3 the
script's balanced-ternary reader sticks before its first digit,
while at signed binary a reader at lookahead 0 commits all 12. At
(2, 1), (3, 2), (4, 2), (10, 6) and (10, 9) it never sticks at the
stated lookahead on random streams to depth 30, for y/3, 2y/5, −y/7, the
mean and xy/ρ.

## The hedge
Tier: property.
Verifier: proof; dual.py::section_e.

If moreover a ≤ b − 1, then y ↦ |y| is read at lookahead 0, while on the
all-zero stream the sign of y is read at no depth. The reader copies the
prefix, negated when its first nonzero digit is negative, and writes
zeros while the prefix is zero: on the all-zero stream it never learns
the sign, and hedges with the zeros that hide it.

Proof. With first nonzero digit d_i, |V| − ρb^(−t) ≥ b^(−i)(1 − ρ) ≥ 0,
so every completion is 0 or has the sign of d_i, and the absolute values
of the tile form the tile of the prefix the reader writes. The all-zero
tile holds both signs at every depth.

At a > b − 1 the first nonzero digit no longer fixes the sign: at
(2, 2) the prefix 1 has the tile [−1/2, 3/2]. The script checks every
prefix to depth 5 at (2, 1) and (3, 1) and to depth 3 at (10, 6) and
(10, 9); balanced ternary (3, 1) has no overlap, and the proof, which
needs only ρ ≤ 1, holds there too.

## What the purchase spends
Tier: property.
Verifier: proof; dual.py::section_p.

- The order blur. Two depth-t tiles of values V < V′ have completions in
  both orders iff V′ − V < 2ρb^(−t). A tile clear of the ends then has
  its order open against 2⌈2a/(b − 1)⌉ − 1 tiles, itself included: three
  at (2, 1) and (10, 6), where the standard digits leave one. The band
  of open order, one tile wide under standard digits, widens to
  2⌈2a/(b − 1)⌉ − 1 tiles.
- No normalization. The tile of the prefix 1 0 … 0 is
  [1/b − ρb^(−t), 1/b + ρb^(−t)] and holds 1/b in its interior at every
  depth, so neither the exponent of y nor its standard string is read on
  that stream.
- Division's bit. y ↦ x/y is read at no depth on a y-prefix of zeros,
  whose tile holds values of both signs arbitrarily near 0. Given a
  certificate y ≥ η > 0, η x/y is (1 + ρ/η)-Lipschitz on
  [−ρ, ρ] × [η, ρ], and the redundant reader reads it with each y-tile
  clipped to [η, ρ]. On a y-prefix of zeros the cover supplies no lower
  bound on |y| at any depth: η is archimedean data from outside the
  stream.

Proof. The tiles are intervals of radius ρb^(−t) about values spaced
b^(−t), and the rest is interval arithmetic.

The sign's non-locality is not on this list: a balanced non-redundant
end has it already. The script counts open-order sets of exactly
three at (2, 1), (10, 6) and (3, 2), sees the tile of 1 0 … 0 hold 1/b
in its interior at depths 1 to 10, and reads η x/y at η = 1/2 at
(b, a) = (2, 1) at lookahead 3 on 100 random streams.

## The redundancy leak
Tier: criterion.
Verifier: proof; dual.py::section_p.

Read an integer with t + j signed digits {−a, …, a}, 2a + 1 > b and
j ≥ 1. For a prime p ∣ b, the residues mod p are uniform over a prefix's
completions, counted once per value or once per string, iff
p ∣ 2a + 1. Counted per value the bias, the largest gap between a
residue's share of the completions and 1/p, is below 1/(2aR_j + 1),
R_j = (b^j − 1)/(b − 1), and vanishes with j. Counted per string it is
the last digit's bias, the same at every j.

Proof. With V the integer a prefix's t digits write, its completions
are V b^j + z with z ∈ [−aR_j, aR_j], once each as values. Since
p ∣ b, R_j ≡ 1 and z ≡ d₀ mod p, d₀ the last digit.
The first count is uniform iff p ∣ 2aR_j + 1 ≡ 2a + 1, and a string's
residue is its last digit's, uniform over {−a, …, a} iff p ∣ 2a + 1.

The standard digits hide every p ∣ b exactly (the two-ends law), so
redundancy degrades that hiding to a bias. This purchase spends a
finite place's hiding, not archimedean data. Every even base leaks
parity, and an odd radical can restore exact hiding: b = 9, a = 7
hides 3. The script reads all 132 (b, a, p, j) with b ≤ 10,
(b − 1)/2 < a ≤ b − 1, p a prime dividing b and 1 ≤ j ≤ 4.

## The period law
Tier: theorem.
Verifier: proof; dual.py::section_m.

Standard digits, n ↦ un with u ≥ 2, κ = ⌊log_b u⌋, input depth t + c
and output depth t, with lookahead c ≥ 1. A deep input tile
[P b^j, (P + 1)b^j), j ≥ 1, is an exception when its image meets two
output tiles. With θ = 1 when uP has t + c + κ + 1 digits and 0
otherwise, and τ = c + κ + θ, every b^τ consecutive P of one θ hold
exactly

    γ ⌊u(b^j − 1)/(b^j γ)⌋    exceptions,  γ = gcd(u, b^τ),

u − γ when b^j γ > u. The count is 0 iff u ∣ b^τ, that is iff
rad(u) ∣ rad(b) and τ ≥ max_p ⌈v_p(u)/v_p(b)⌉: the numerator
criterion's multiplier half, at its depth threshold, is the zero locus
of one density. For gcd(u, b) = 1, on tiles longer than u (b^j > u),
over the (t + c)-digit P as t grows, the density of exceptions tends to

    (1 − 1/u)/b^c      counted per tile, and
    (1 − 1/u) H(ξ)/b^c with each tile P weighted log_b((P + 1)/P),

ξ = {log_b u}, H(ξ) = b^(ξ−1)(1 + (b − 1)(1 − ξ)). Under counting, the
split between the classes θ = 0 and θ = 1, which the multiplier's
mantissa sets, cancels, leaving the factor 1 − 1/u. The log weights keep
the mantissa's share, in H(ξ), and H > 1 on 0 < ξ < 1, so they see more
exceptions at every base.

Proof. The image's output tiles have length b^J, J = j + τ, and the
tile is an exception iff a multiple of b^J lies in
(uPb^j, uPb^j + u(b^j − 1)], iff 1 ≤ σ ≤ u(b^j − 1)/b^j with
σ = (−uP) mod b^τ; σ = 0 fails since b^τ > u. Over b^τ consecutive P, σ
runs over the multiples of γ, each γ times, which gives the count. It
is 0 iff γ > u(1 − b^(−j)), and as γ ∣ u and 1 − b^(−j) ≥ 1/2, iff
γ = u. For the densities the count is u − 1 per b^τ, and the class
θ = 0 holds the fraction w₀ = (b^(κ+1) − u)/(u(b − 1)) of the P, so the
density tends to (u − 1)b^(−c−κ)(w₀ + (1 − w₀)/b) = (1 − 1/u)/b^c.
Under the log weights the classes hold 1 − ξ and ξ, which gives H. ln H
is concave and 0 at ξ = 0 and 1, so it is positive between.

The script counts each of 1257 cases (base, multiplier, lookahead, span,
class, phase), each at one depth, at bases 2, 6 and 10, multipliers 2 to
12 and 25, each exactly on the formula, with every zero where u ∣ b^τ.
At (b, u, c, j) = (10, 3, 1, 2) the densities are 0.066667 = 1/15 and
0.114118, and at (2, 3, 1, 2) they are 0.333336 against 1/3 and
0.353762 against 0.353759.

## The dual Haar measure
Tier: property.
Verifier: proof; dual.py::section_m.

The mantissas form the compact group R_>0/b^Z, the scale circle, whose
Haar measure is log-uniform. The mantissas of the depth-t leading
tiles with prefix P lie in the arc [P, P + 1)·b^Z, of Haar measure
log_b((P + 1)/P): Benford's law is the Haar measure of these arcs. The
arcs have unequal Haar measure, which is why a density at the leading
end must name its measure. A trailing tile is a coset of b^t Z, the
integers in a coset of b^t Z_b
in the b-adic integers Z_b, and those cosets have equal Haar measure
b^(−t), which is why a trailing density of a union of residue classes
needs no named measure.

Proof. log_b carries the scale circle onto R/Z and Haar onto Lebesgue
measure. Haar measure is invariant under multiplication by every q > 0
because log is a homomorphism, so a fixed arc keeps its mass when the
measure is pushed forward.

Log-uniformity as the scale-invariant law is known (Pinkham, Ann.
Math. Statist. 32, 1961; Hill, Statist. Sci. 10, 1995), and the period
law's factor H > 1 is what it changes. The script's control: under
multiplication by 3 the counting share of the tile of leading digit 1
at base 10 moves from 0.1111 to 0.3704, while its Haar mass stays
0.301030, the sums telescoping.

## Each end prices in its own metric
Tier: property.
Verifier: proof; dual.py::section_k, dual.py::section_0,
reading.py::section_r, reading.py::section_l.

One map, ⌊n/m⌋ with m ≥ 2 and b ∤ m, has an exact price at both ends.
The trailing end reads it at exactly max_(p∣m) ⌈v_p(m)/v_p(b)⌉ digits of
lookahead, a maximum over the places, infinite where some p ∤ b. The
leading end reads it at exactly digits_b(m) = ⌊Σ_p v_p(m) log_b p⌋ + 1,
a sum over the places, each weighted by its size. At base 10, ⌊n/4⌋
costs 2 at the trailing end and 1 at the leading end, and ⌊n/3⌋ is read
at no finite lookahead at the trailing end and at 1 at the leading end.
The leading price is the archimedean size of m, which the product
formula writes as a sum over the places; the trailing price takes the
same places one at a time and keeps the worst.

Proof. The trailing price is the least c with m ∣ b^c, by
READING.md#the-division-criterion on the chain b^t. The leading price
is the least-lookahead law at h = m, K = 0 and
Δ = m ≤ (b − 1)b^(digits_b(m)).

## Open fronts

Which maps do the two ends of an exotic base read? At a quadratic base
the ideals part one way (DUAL.md#the-two-ends-of-a-quadratic-base); the
difference map and the scalings are not yet read there. At degree 3 the
chain law misses hidden pairs, Q² and 2Q at x³ ± x² + x ± 2 at
q^J ≤ 128 (DUAL.md#the-chain-law), each one swept read at no depth,
and which ideals of index below q^j span j hides is open. Where I is
read at some depth (DUAL.md#the-chain-at-depth) the converse is proved
at q = l^e when f's l-adic factor f₀ has degree at most 2 or is x³ + a₀,
and past that
rests on a statement about any finite abelian G with g_0, g_1, …
generating it, obeying f's recurrence and 0 from some k on, a class the
chain's step keeps: if T_W is uniform on G ≠ 0, some k ∈ W has q g_k =
0. Call S ≤ G closed when q g_k ∈ S puts g_k ∈ S at every k ∈ W with q
g_k ≠ 0: the statement at G/S then lifts to G, so a least counterexample
has no closed S but 0 and G, which at q = l^e puts every invariant
factor of G above q, each subgroup of order l at some ⟨q g_k⟩ and the
g_k, k ∈ W, with q g_k ≠ 0 generating G (dualrs.py). The count of the
chain at depth reaches every degree r: the β^k after the first hit lie
in a proper subspace of M/lM, too few lines at full rank, so a least
counterexample has rank 2 to r − 1; below full rank it fails (x³ + 4 on
Z/8 × Z/8). With rank 2 forced, at a cubic factor the statement follows from
one at rank 2, every invariant factor above q: some ⟨h⟩, h ∉ lG, is
closed, its character then being a witness outright; with G = C/L, C =
Z_l², one scalar f₀-sequence ρ(c_k), ρ a primitive functional, avoids
e consecutive valuations on the k with q g_k ≠ 0. It is proved at f₀ =
x³ + a₀, on (Z/l^(e+1))², and at q = l wherever no depth over-fills
(dualrs.py's T5). There f₀ is Eisenstein, the candidate ⟨h⟩ are
vertices at one depth of the Bruhat–Tits tree of C, and each k with
l g_k ≠ 0 is a gate: a chain l^j⟨h⟩ through ⟨l g_k⟩ must go on to
⟨g_k⟩. The lattices β^k Z_l[β] project onto the two ends of one edge
up to scaling, so of the classes of k mod 3 one gates no candidate
on the candidates' side of the edge,
one at most one per depth and the class of the recurrence's trivial step
at most one more, unless its term degenerates and lands shallower; at
most l gates per depth leave a closed ⟨h⟩. At l = 3 a depth over-fills
only at exponent at least 3⁶ (derived, never run). dualrs.py reads the
count at 604952 generating sequences of exponent at most 27 at q = 2,
3, 5, 0 against it, a closed ⟨h⟩ at every one; the 3174 over-full, all
at q = 2, cut the unbroken chains to one vertex at some depth at 3123,
never to none. At q = l the over-full depths are the front, the lander
(a term landing shallower)
at l = 2 past exponent 32 first, below which
DUAL.md#the-witness-at-q--2e holds, its fewest closed ⟨h⟩ falling to
1 at Z/32 × Z/16 (at l = 3 past 3⁶ and at l ≥ 5, at least l − 1 landers
at one depth, none is read): it reopens on an argument that reads where
a lander's gate sits, not how many gates a depth holds. At e ≥ 2, where
no gate count is derived and the binomial factor's ⟨h⟩ can be open off
x³ + a₀ (it is open already at q = 2, x³ + 2x + 2), it
reopens on a proof that reads how a₁ and a₂ move the terms between
cyclic subgroups. At q = 4 and 8 the witness holds to exponent 32
(DUAL.md#the-witness-at-q--2e) and is unproved past it. At q = 4 the
fewest closed ⟨h⟩ is 1 on (Z/32)² and 5 on (Z/64)², the quotients
Z/64 × Z/2^M, 2 < M < 6, unswept, as is exponent 64 at q = 8; whether
that fewest falls to 0 is the front. The statement on T_W holds at
every sequence dualrs.py sweeps (`--full`), a sweep over the factors of
one degree covering every base whose factor has that degree: factors of
degree 3 at q = 4 and 8 in the groups of order 64 neither cyclic, of
rank above 3 nor of exponent at most q (those by proof) and at q = 9 of
order 81, and at
Z/16 × Z/8, (Z/16)², (Z/8)³, (Z/32)² at q = 4, (Z/16)² at q = 8, (Z/27)²
at q = 9; of degree 4 at q = 4 of order 16 and 32; and the bases x³ +
ax² + bx ± q, −2 ≤ a, b ≤ 2, at q = 2, 3, 4 to order 16, 27 and 16 (32
at q = 4 with a, b even). Every miss swept (DUAL.md#the-chain-at-depth)
has a unit part, where β is invertible, of order at least 16: whether a
miss needs one not killed by q is open. Do the over-redundant digit sets
a ≥ b add a case of their own? The redundant reader still holds at every
a, and the absolute value (REDUNDANT.md#the-absolute-value) is still
read at lookahead 0 on every symmetric set, but the first nonzero digit
no longer fixes the sign there.