Reading

A window reads f at bounded lookahead iff f is Lipschitz at cell scale in the window's own metric and the image of each deep input cell fits one output cell. Cell scale is load-bearing: the readable class contains below-the-top digit permutations whose pointwise ratios are unbounded; at ball windows cell scale and pointwise coincide. The fitting clause is where windows differ, and it follows from the cell family's Lebesgue number:

At the trailing end readability is Lipschitz, verbatim: reading at lookahead c is the statement d_b(f n, f n′) ≤ b^c d_b(n, n′), the minimal lookahead exactly max(0, ⌈log_b Lip_b(f)⌉) — multiplication is nonexpanding, free at c = 0, and ⌊n/v⌋ is Lipschitz iff rad v | rad b: the trailing division gate is a b-adic Lipschitz fact. No digit set changes this end — a redundant prefix's completions fill a full coset, cosets are equal or disjoint — so redundancy is a leading-end-only door. At the leading end every scaling is a log-metric isometry, so the whole gate is alignment: non-redundant, ⌊(u/v)n⌋ is window-local iff rad u | rad b with the denominator free (long division emits digits MSB-first from bounded remainder state); redundant digits {−a..a}, 2a + 1 > b, make the cells an overlapping cover and both radical gates dissolve — every rational slope reads at bounded delay, within one digit of the Lebesgue bound. The lookahead unifies as log_b(Lipschitz constant) plus a window margin: 0 at ultrametric windows, log_b(2a/(2a − b + 1)) at redundant covers, and infinite — a wall — at misaligned non-redundant reads. Catastrophic cancellation is the criterion's negative space: subtraction's log-metric blowup at its zero locus.

Scope. The four regimes verified under the one statement at stated scopes. Component tiers: the trailing instance proved, elementary; the coset rigidity a two-line proof; the numerator criterion a rule (the boundary-preimage method); the rational-slope delay law a rule at scanned digit sets (2,1), (4,2), (10,6).

verifiers: explore_dual_lipschitz.py, explore_dual_locality.py, explore_dual_redundant.py

A product's exponent is read from the operand exponents up to 1, but equality, comparison of nearby values, and the zero-test of a difference are unreadable at every finite precision: one deep fiber realizes difference exponents {0..5}, both signs, and zero. The finite pole's crown capability — the exact zero-test, a residue is zero or it is not, in every window — is exactly the dual pole's blind spot, and the dual pole's native reads — size, sign, order — are exactly what the tower's deletion removes: the two poles exchange crown capability and blind spot. The redundant purchase does not close the gap; it pays with it: behind the cover, sign is non-local at every lookahead, comparison blurs across 3 cells against the non-redundant window's 1, and the window cannot read its own exponent. Redundancy is the archimedean deletion performed a second time, inside the archimedean window — what it buys is arithmetic, what it spends is the archimedean data itself.

Scope. Property with witnesses at stated scopes. The redundant order reads (sign, order blur, normalization) are rules, the order-blur law an iff, at both scanned redundant systems.

verifiers: explore_dual_pole.py, explore_dual_redundant.py

Base b's trailing digits read exactly the finite places p | b; its leading digits perfectly hide exactly the same places — the bias of [n ≡ r (mod p)] on a deep leading fiber is exactly zero iff p | b, and otherwise nonzero on every deep fiber, with a derived attained ceiling. One numeration, two ends: the same primes exactly readable at one end, exactly invisible at the other. The same radical condition runs the arithmetic in exchange — trailing multiplication free, division gated by rad v | rad b; leading division free, multiplication gated by rad u | rad b — one condition on opposite parts of the fraction: each end freely reads the operation whose carry flow points away from it. And where a price survives, each pole prices in its own metric's arithmetic. Dividing by v costs the trailing end max_p ⌈v_p(v)/v_p(b)⌉ digits — a maximum over places — while multiplying by u costs the redundant leading end ⌈Σ_p v_p(u) log_b p + margin⌉ — a sum over places: the product formula surfacing as the two poles' price sheet.

Scope. The hiding law, the two-ends law, and the exchange are rules at stated scopes; the pricing is an identity, measured.

verifiers: explore_dual_pole.py, explore_dual_locality.py, explore_dual_lipschitz.py

If f is Lipschitz with constant L, it fits cell-to-cell at lookahead c once L·δ_t+c < ℓ_t — per-level fitting, which is readability outright where cells nest. Necessity is coarse: Lipschitz at cell scale, pointwise at ball windows. Three cover shapes give three regimes — balls of an ultrametric (ℓ_t = δ_t, fitting automatic, margin 0); a partition of a connected space (ℓ_t = 0, the lemma silent — readability a per-map alignment question); an overlapping cover with ℓ_t = ρδ_t (fitting bought at margin log_b(1/ρ)). At overlapping covers a redundant cell's children keep the overlap only in its interior, so the committed stream departs from the per-level bound by at most one digit — both directions realized at scanned witnesses; the bound is exact where cells nest. And readability is metric, not topological: even-position digit extraction is uniformly continuous — readable at growing modulus 2t — and readable at no bounded lookahead.

Scope. Rule at scanned scopes; the two-pole regimes above are its positional instances.

verifier: explore_reading_geometry.py

At partition covers the lemma is silent, and the permanent-wall half of the alignment question is answered by the cover's vertex set ∂ — the cell-boundary points, which stay cell endpoints at every deeper level. For f continuous and strictly monotone at an irrational input y, emission grows without bound iff f(y) ∉ ∂: an image on a vertex is interior to every image interval, the vertex's two sides agree only to its own depth, and emission freezes at a computable constant forever — where a rate stall only slows it. A map's permanent walls are exactly f⁻¹(∂) ∖ ∂, its rationalizing set. Redundant covers dissolve every wall — a positive Lebesgue number leaves no map with a modulus of continuity walled. Wall exposure is therefore the size of the vertex set, and the continued fraction's — all of Q — is the largest a rational-vertex grid can have (base b: Z[1/b] ⊂ Q). The cross-window witness: x² walls permanently at √(1/3) in the continued-fraction grid and reads on in base 10.

Scope. Rule at scanned scopes — the maps x² (walls at every scanned √r) and √x (wall-free: a rational square root forces a rational input); the cure realized at every scanned wall of x².

verifiers: explore_cf_nonlinear.py, explore_cf_redundant.py

An integer Möbius map with det = ±1 reads continued-fraction streams at bounded digit-delay: every nonnegative-entry unimodular map is a positive word in three exact transducers — the Stern–Brocot factorization — and delays add over a fixed word. A map with det ≠ ±1 is not boundedly readable: every one owns a mismatched witness. The sharp print is 2φ = [3; 4, 4, 4, …] with φ³ = 2 + √5 exactly, so emitting t quotients of 2φ consumes 3t quotients of φ — delay linear. Non-unimodularity does not stall every orbit — (2x, √2) reads at delay zero, since 2√2 keeps √2's rate — it guarantees witnesses exist. Necessity is proved at quadratic streams: readability transports through unimodular factors (Smith normal form), reducing the gate to the scalings x → nx, where φ is a universal witness — a matched rate would force the multiplier automorph of nφ to be a power of φ, which floor rigidity (the period trace is strictly increasing in every digit) reserves for the all-1s word alone, so nφ's stream would be φ's own — but the multiplier ring sits inside the lattice, and φ ∉ Z + Znφ. Serret's theorem — equal CF tails ⇔ GL(2, Z)-equivalence — is the classical shadow: readable multiplication is, again, the window's native units.

Scope. Positive direction proved for nonnegative words, word-free at quadratic streams; sign-crossing at general streams unscanned. Necessity proved at quadratic streams from proved pieces (floor rigidity, rate forcing, Serret transport).

verifiers: explore_cf_window.py, explore_cf_conductor.py, explore_cf_flow.py

At a quadratic stream the rate is arithmetic. The tail's period-matrix eigenvalue equals ε^i(y) — ε the field's fundamental unit, i(y) the unit index of the multiplier order of the lattice Z + Zy — so the cell-scale rate is r(y) = 2 i(y) R_K / ℓ(y) (R_K the regulator, ℓ the period length), and a measured stall ratio is (i_out/i_in)·(ℓ_in/ℓ_out). The delay is an instrument: the stall slope of x → nx measures the unit index of a conductor order. Where the classical index ceiling is not attained, the law follows the realized index and the deficit is the ring class number. And the law is map-blind: any monotone C¹ map with nonzero derivative is conductor-priced at quadratic orbits — the map enters only through which output orbit it selects.

Scope. Rule at 17 measured pairs including four sight-unseen; the automorph identity η = εⁱ exact at all 53 scanned pairs (the eigenvalue identity itself is classical); map-blindness proved at the flow layer's scope, measured within 1% at all six scanned nonlinear pairs.

verifiers: explore_cf_conductor.py, explore_cf_nonlinear.py, explore_cf_flow.py

Every scanned window's digit process is the shift of an expanding map whose per-digit scale ln |T′| is the roof of a suspension flow, and the flow's entropy is exactly 1 (Rokhlin's and Abramov's formulas): entropy per digit equals scale per digit, a positional window being the constant-roof case. The continued fraction's suspension is the modular geodesic flow (Artin, Series), where a quadratic tail rides a closed geodesic of flow period 2 ln η = 2 i R_K per tail period — the conductor rate is the per-orbit return-time mean (the roof identity: over one tail period the product of complete quotients equals η, verified exactly at 25 tails). On this flow the commitment deficit D(n) = scale(image interval) − scale(committed cell) obeys 0 ≤ D(n) ≤ 3 ln(A + 2) + O(1) for monotone C¹ maps at badly approximable non-vertex outputs (quotients ≤ A): every reader is scale-synced regardless of the map — the scale clock always syncs, only the digit clock forks. Rate forcing: at an eventually periodic tail with quadratic output, emission is (r_in/r_out)·n + O(1) with the ratio rational — digit delay is bounded iff the rates match, else linear with the mismatch sign, both signs realized. At a wall the deficit grows linearly instead: measured slope at (x², √2) is 1.7627 = 2 ln(1 + √2) to four decimals — the cusp excursion that never returns.

Scope. Both proved at stated scope — the bound by scale accounting plus bad approximability, the forcing verified at ten pairs including two designed run-ahead witnesses. The ergodic vocabulary (suspension, roof, Abramov's formula) is classical import; the reading layer on top is the content.

verifier: explore_cf_flow.py

The window's native redundant cover adds to the Stern–Brocot cells the straddle chains: at a vertex v with Farey parents (l, r), the chain cell S_k(v) runs between the k-th mediants and contains v in its interior at every k. The alphabet is the exact-real-arithmetic classic — the root straddle is the image (1/2, 2) of the modified Stern–Brocot digit M (Niqui's {L, R, M} digit set), and productivity for Möbius maps is classical (Gosper, Vuillemin, Edalat–Potts); what the overlap does and cannot do is the content. The ladder law: the cover cells containing a point z are z's own cell ladder plus a chain segment of exactly K(v, z) = ⌊1/(q_v²|z − v|) − q_far/q_v⌋ rungs at each approached vertex — at a convergent, K equals the next partial quotient verbatim; at a rational the chain is infinite. The cover is graded: rank steps by +1 along every child relation, so overlap adds routes, never length. The two gates then split. The wall gate falls: x² reads √2, √3, √(3/2) through the chain with never-freezing emission, ln k slope equal to the input's scale rate to four decimals — the emitted stream is an infinite redundant representation of the rational output, the continued-fraction mirror of 0.1999… The rate gate stands: at the scanned stalling pair (x/2, 2φ) the maximal rank of a cover cell containing the image equals the plain tree position at every sampled depth — ladder spacing is orbit data no overlap changes, so rate forcing survives redundancy verbatim. And a delay's sign belongs to the clock: the same pair (2x, φ) stalls at 1/3 in the quotient clock and runs ahead at 4/3 in the tree clock (φ³ = 2 + √5 makes both exact) — only the mismatch belongs to the orbit, and the scale clock is the invariant ruler.

Scope. The ladder law's closed form exact at every scanned node (510 nodes × 12 depths); the rank grading a property on every child relation; the wall cure and the rate gate rules at scanned scopes.

verifier: explore_cf_redundant.py

Every window here gates its multiplication-like maps by the same shape: readable at bounded delay iff the map is a unit of the window's native structure.

Nonlinear maps sit under a second gate, orthogonal to units — the wall criterion: x² reads φ at bounded delay (its orbit ratio is 1) while walling permanently at √2 (its image is a vertex). Redundancy splits the gates by shape, and the split is verified at both poles. The redundant leading window dissolves its gate wholesale, because positional roofs are constant — scale rates always match there, so the only gate was boundary alignment, which any positive Lebesgue number kills. The redundant continued-fraction cover dissolves only the wall gate — its roofs are orbit-pinned, so overlap extends terminated ladders (rationals: walls cured) while never raising the reachable rank at an irrational (rate forcing survives). One purchase — a positive Lebesgue number — two fates, decided by whether the window's roof is constant or carries orbit data.

Scope. Each row a rule at its own scopes; the cross-window generality is a pattern over these windows, not a proof.

verifiers: explore_dual_lipschitz.py, explore_cf_window.py, explore_cf_redundant.py