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, 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 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: 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: 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 (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 The witness at q = 2^e 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 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 (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 (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 (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 (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'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: 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: 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: 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: 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'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: 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: 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.

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: 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 (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 (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 (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 The witness at q = 2^e 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 (The witness at q = 2^e) 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 (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: The absolute value) is still read at lookahead 0 on every symmetric set, but the first nonzero digit no longer fixes the sign there.