Quadratic windows

At four such windows — the golden 1/φ = [0; 1, 1, …]; the silver √2 − 1 = [0; 2, 2, …] (Pell weights 1, 2, 5, 12, 29, …); the bronze [0; 3, 3, …]; and √3 − 1 = [0; 1, 2, 1, 2, …] (period 2) — the completion is an odometer at every one, and the reading is exact in the limit. The lookahead a map needs at depth t over the integers below N can only rise with N, so it has a limit at every depth, finite or not; at a periodic window that limit is printed by a carry automaton — a relation m·n′ = m′·n + c between an integer and its image, read off their digit strings position by position, leaves a bounded carry, so the relation is a finite automaton and two of its runs driven by one input close in finitely many pair states (the machinery is on Digit shifts). At the four windows: the successor n + 1 needs lookahead exactly 1 at every depth from 1 at silver and bronze and from 2 at golden and √3 − 1 — the depth one above the lowest position whose cap admits a nonzero digit — and never returns to 0, one digit of lookahead forever rather than a bounded burst; the unit's shift action needs none; dropping the low period's worth of digits needs the period or the period plus one, alternating; while ×m and ⌊n/m⌋ for every m = 2..7 are gated, the lookahead unbounded from that same depth on. The range scan prints that gate as a delay growing with range — the agreement depth of the deepest pair whose images differ grows in step with the deepest agreement the scan realizes at all, no plateau — and the count of realized depth-t cells grows by a factor of ε per depth. The same scan at the period-3 windows [0; 1, 1, a], a = 2, 3, 4 returns the same verdict, and the automaton reads ×a unbounded from depth 2 at every a = 2..7 there — the flip again at position 1. So the reading is not decided by membership in Z[α], which every integer has, but by the unit group: the unit shift reads and the tested non-units fail.

Scope. Rule: at the four windows the limit readings are the automaton's decision — the successor and the drop at all four, ×m and ⌊n/m⌋ at all 24 (window, m) cells, and ×a at the six windows [0; 1, 1, a]; the range scan, exhaustive to 3·10⁵ per window with the failure-depth reading taken at three ranges, and at the same bound for the three period-3 windows, sits at or below it. The failing half is a theorem at every irrational window for multiplication and floor division by any m ≥ 2 — the tear at a cell endpoint on Completions; and the whole column of every shift-free relation — the depth the gate opens from, one above the lowest position whose cap admits a nonzero digit, and the successor's constant 1 — is a theorem at every irrational window by the containment principle below; the comb and boundary-family blocks between carry the same address at the named families, by the witness each window's own engine builds. Beyond the tested windows the rest of the unit-gate statement — that the units read, and that nothing else does — is a conjecture.

verifiers: explore_ostrowski_window.py, explore_period3_borrow.py, explore_limit_maps.py

At every constant-a window with a ≥ 2 the ×a half is proved, no range cap: the even comb Y_K = q₂ + q₄ + ⋯ + q_K maps under ×a, by the telescoping borrow, to q_K+1 − a with bottom digit 0, while Y_K + q_K — the same string with its top digit raised — maps to q_K+1 + a·q_K − a with bottom digit 1: pairs agreeing to unbounded depth K whose images differ at the lowest digit, unconditionally in both K and a — one comb with no parity condition where the Zeckendorf family's witness worked only at every other depth, its parity stripe. Both inputs converge in the completion to the infinite even comb, their images to two distinct points — ×a has no continuous extension, and no constant-a completion is a ring; silver's ×2 and bronze's ×3 are the a = 2 and a = 3 instances. The one degeneracy is a = 1, where legality caps the bottom digit at 0 and squeezes the witness string out — exactly where Zeckendorf's parity-striped comb takes over.

An alternating alphabet relocates the flip, not the shape: at every period-2 window [0; 1, a, 1, a, …] with a ≥ 2 — √3 − 1 the tested a = 2 instance — the same down-borrow holds at every odd position, the positions whose digit cap is a, so the odd comb q₁ + q₃ + ⋯ + q_K telescopes under ×a to q_K+1 − 1 with b₁ = a, while the comb plus q_K maps to q_K+1 + a·q_K − 1, whose legal string has b₁ = 0 at odd K ≥ 3 (a − 2 at the K = 1 edge — distinct either way): pairs agreeing to unbounded depth whose images differ at b₁ — here a₁ = 1 pins b₀ at 0 exactly as Zeckendorf's alphabet does, yet no parity stripe appears; the degeneracy moves the flip one position up, ×a again has no continuous extension, and no period-2 completion is a ring either.

And when the borrow's span mismatches the comb's spacing, the discontinuity survives with a new carrier: at the period-3 window [0; 1, 1, 2, …] the large quotient's positions sit three apart while its borrow still spans two, so no single identity telescopes — the intermediate quotients' own rewrites chain, and every extension of the comb u_M = q₃ + q₆ + ⋯ + q_3M (teeth at the positions ≡ 0 mod 3, whose digit cap is 1) cascades to the bottom, landing the image 2·u_M on one of two legal strings by the parity of M: Zeckendorf's parity stripe, returned one level up, the flip still at b₁ — the lowest position whose cap admits a nonzero digit — so ×2 has no continuous extension and that completion is not a ring either.

Scope. The ×a discontinuity is a theorem at every constant-a window and at every period-2 window [0; 1, a, 1, a, …], both for every a ≥ 2, the comb families checked by greedy extraction at a = 2..7 (constant-a to depth 40, period-2 at odd K ≤ 41); ×2 is a theorem at the period-3 window [0; 1, 1, 2, …], its comb checked at M ≤ 26. The period-3 gate scans are scoped with the gate above.

verifiers: explore_silver_discontinuity.py, explore_constant_a_borrow.py, explore_period2_borrow.py, explore_period3_borrow.py

Across the period-3 family [0; 1, 1, a] the parity of a splits the comb's fate, and the split is a theorem at every a ≥ 3 (a = 2 is the cascade above): at each position K holding a large quotient, the two unit quotients above it give q_K+2 = 2q_K + q_K−1, so a top coefficient c on q_K−1 can absorb the next comb extension's cost a·q_K in place — everything below untouched — precisely when 2c = a − 1. Odd a carries that conserved half-coefficient (a − 1)/2 upward forever and freezes the image bottom at (0, 1, (a + 1)/2), the comb read with no flip; even a's best integer coefficient a/2 − 1 sheds one unit per extension, and b₂ stripes between a/2 and a/2 + 1 by the parity of M, both closed forms proved. But the split is a fact about the comb, never about the gate: every window a ≤ 7 carries the boundary family of the next section instead, whose witness never consults the parity of a at all.

Scope. Theorem at every a ≥ 3, its closed forms checked at a = 3..9, M ≤ 26.

verifier: explore_odd_a_freeze.py

The engine is the maximal string — the legal string of q_K − 1 — and that string is a theorem at arbitrary tail, periodicity never used: greedy on q_K − 1 = a_K q_K−1 + (q_K−2 − 1) recurses in steps of two, so the largest integer supported below position K writes as the alternating cap-filling — digit a_K−2i at position K − 1 − 2i, plus b₀ = a₁ − 1 at odd K — supported on one position parity and flipping whole with the parity of K, the flip at the lowest position whose cap admits a nonzero digit: the flip address derived for this family at every window at once.

Some reals carry two legal codings — two distinct points of the completion over one point of the line, the coding boundary. Dividing near-denominator combinations q_K + u q_K−r − t (u, r, t small and fixed, K running) by a inside one residue class of the convergent pair (q_K, p_K) mod a — the class chosen so the resulting inputs' limit misses the coding boundary while the image limit sits on it; a | t with p_K ≡ 0 mod a is exactly the boundary case and is excluded — yields one convergent input family whose images land beside the boundary on the side the convergent's sign (−1)^K dictates, alternating between the two codings of one point forever: the gate witnessed at every window a = 2..7, the flip at b₁ except a = 7's b₂, the parity of a never consulted.

And a level further out, at arbitrary period, by the same engine with no comb at all: at four fresh windows of periods 4 and 5, alphabets mixed and a₁ up to 3, the family witnesses ×m gated at all 24 (window, m) pairs, m = 2..7, the flip at b₀ or b₁, the successor reading at lookahead 1 beside it. And the carry automaton of the gate block decides the limit at every one of those 24 cells and at the six ×a cells of [0; 1, 1, a]: the lookahead unbounded from the depth just above the family's flip at the 24, and from the depth just above b₁ at all six — one position below this family's own flip at a = 7, so a family other than this one parts there. Where each comb family above needed a telescope built for it, this engine needs only the max-string theorem plus per-pair class existence — and that leg is settled: the class condition is periodic in the convergent pair mod m, so one member of each parity certifies it forever — the certificate — and every pair here is certified. Nor is the certificate a formality — existence is provably impossible at some windows: at the golden window no residue class holds both parities for m = 3, 5, or 7, so where the certificate cannot exist the address needs a different witness — a comb where one is written, and everywhere the unimodular family below. The excluded class is its own specimen: there the input family itself lands on the boundary and never converges — the max-string mechanism one level down.

Scope. The max-string identity — the legal string of q_K − 1 itself — is a theorem at arbitrary tail, verified K = 1..40 at the four period-4/5 windows; the boundary family's class membership is certified outright — one member of each parity plus the period of the convergent pair mod m — at every pair of both families, while its input convergence and wider image strings are a rule at scanned scope (at [0; 1, 1, a]: classes to K ≤ 400, agreement depths growing to 140, strings by greedy extraction at a = 2..7; at the four period-4/5 windows: all 24 (window, m) pairs, m = 2..7, classes to K ≤ 400, depths to 225, one pair needing r = 3).

verifiers: explore_max_string_witness.py, explore_general_max_string.py, explore_class_criterion.py

A shift-free relation m_o·w = m_i·n + c between an integer n and its image w — ×m, n ± c, and ⌊n/m⌋ as the union over c — sends the input's point x = nα − P to (m_ix + cα + j)/m_o with j = m_iP mod m_o, and every offset j occurs inside any deep cell: adding a zero-low-digit Y whose residue pair (Y, ⌊Yα⌉) mod m_o is (0, u) keeps the cell and moves j, and every pair is realized at every irrational window because consecutive convergents are unimodular — q_kp_k+1 − q_k+1p_k = ±1, so (q_k, p_k) and (q_k+1, p_k+1) span (Z/m)² at every k. The lookahead at depth t is then the least ĉ such that every output cut −sα, s ≤ q_t, has all its preimages among the input cuts of depth t + ĉ — an input cell holding no preimage maps to an arc holding no output cut — and it is infinite exactly when some preimage is not a cut: such a point is interior to a cell at every depth, the lattice — the integers' points nα mod 1 — accumulates at it from both sides, and the images accumulate at the cut from both of its sides. So the column is decided by cut containment, and the two codings of the cut −tα part at the first position p with q_p+1 ≥ max(t, 2); for −α that is the lowest admissible digit — position 0 when a₁ ≥ 2 and position 1 when a₁ = 1.

Read member by member. At m_o = 1 the preimages of −sα are (−(s + c)α + j)/m_i, cuts only at j = 0 with m_i dividing s + c: so ×m + c is unbounded from the lowest admissible digit for every m ≥ 2 and every c, while n + c at c ≥ 0 has every preimage a cut and is finite, with the exact column min{ĉ : q_t+ĉ ≥ q_t + c} (0 while q_t = 1) — at c = 1 the constant 1 from the lowest admissible digit's depth on, since q_t+1 ≥ q_t + q_t−1: the successor's lookahead 1, read by the automaton at fourteen periodic windows, is a theorem at every irrational one; at c ≥ 2 the column is eventually 1, with early entries above it exactly where q_t+1 − q_t < c. The decrement n − c, c ≥ 1, sends −α back to the lattice point (c − 1)α, never a cut, and borrows where the increment does not: the inputs c − 1 + q_K agree to depth exactly K across consecutive K, while their images q_K − 1, whose points θ_K − α sit beside −α on alternating sides, are the two codings of −α below depth K and part at the lowest admissible digit. At m_o ≥ 2 the images of inputs converging to one point accumulate at m_o points 1/m_o apart, a jump; as the input point sweeps the circle so does that constellation, and a fixed displacement cannot ride a dense orbit inside one arc of the partition one depth above the flip, which has at least two, so some position puts a cut between two of the points: unbounded from the lowest admissible digit for every (m_o, m_i, c), the floors ⌊n/m⌋ included. So every shift-free relation is unbounded from the lowest admissible digit except n + c at c ≥ 0, which is finite with an exact column.

The unimodular family is the residue lemma inside the principle, and the witness it writes down. At −α for ×m: Y_K = mq_K + aq_K+4 + bq_K+5 with (a, b) ∈ [0, m)² the one solution of a(q, p)_K+4 + b(q, p)_K+5 ≡ (1, 0) mod m, and n_K = (Y_K − 1)/m; Y_K's star — the signed offset of Y_Kα from its nearest integer — is mθ_K plus a remainder under (8/9)(m − 1)|θ_K|, so the images mn_K = Y_K − 1 sit beside −α on alternating sides within (2m − 1)|θ_K|, their cells −α's two neighbours at every depth below K minus a constant — the two parities of the maximal string — while the inputs converge to −α/m, never a cut; at ×m + c the target pair is (c + 1, ρ) mod m and the inputs converge to (ρ − (c + 1)α)/m. The raised-top family that proved the address first at the periodic windows — n = (q_K − 1)/m against its top raised by one cap, the images straddling −α by the crossing ratio |θ_K+2/θ_K| < (m − 1)/m, under 2/3 at every window — is the sub-case a = b = 0 with q_K ≡ 1 mod m, and its need for that residue to recur was the price of one convergent where two are unimodular: a window whose quotients are chosen so that it never occurs, possible at every m ≥ 3, is a cell it cannot enter, and the address there is the same. Other cuts need not part lowest — −3α's codings at the golden window part at b₂, what a boundary-family class with that t reads — and the address is the minimum over all witnesses, which is why it sits at −α's.

A shifted relation — the input string moved up or down r positions before the relation is read — is not an address at all: its image point is the pseudo-star Σ d_kθ_k+r, a function of the string and of no circle point, and the automaton prints pure shifts unbounded at some strides and finite at others (Digit shifts). The drop by l — the string shifted down l positions, the map the gate above reads at the period — is a Diophantine property of the window's quotient growth: the single-digit inputs jq_D and (j + 1)q_D drop to points stepping by θ_D−l, and where a_D+1 ≥ q_D−l+1 + q_D−l the sweep wraps the circle and a consecutive pair straddles −α, parting at the lowest admissible digit with the inputs agreeing to depth exactly D. A window with that inequality at infinitely many D — a designed Liouville-type tail — has the drop by 1 unbounded from the lowest admissible digit, while the four windows of the gate above read the drop by their period finite with peak l + 1. Between those two ends the question is open: at e − 2, whose quotients grow but sit far below its denominators, a big digit's sweep never leaves the cell of 0 that the big quotient two positions below sets, and the finite-range column reads flat across a decade of range — a scan, deciding nothing.

Scope. Theorem at every irrational window for every shift-free relation — the principle, the exact column of n + c, the decrement and the jump — periodicity used nowhere; the drop a theorem at its unbounded end, the Liouville-type tail, a rule at the four periodic cells of its finite end, and open between. Checked against the carry automaton at 189 (window, relation) cells over nine periodic windows — n + c for c = 2..5 equal to the formula entry for entry, the decrement, ×m + c and six m_o ≥ 2 relations unbounded from exactly the depth above the lowest admissible digit — and in exact integers at e − 2, ∛2 − 1 and five windows designed so that q_K ≡ 1 mod m never occurs, one at each m = 3..7, with golden and bronze beside them as controls, every K from 8 up the certified ladder: the decrement's and the ×m + c family's images part at exactly the lowest admissible position at all 12,150 readings, the jump finds its x₀ at or below 3 at every cell, and the ×m family parts there at all 833 readings with the floors' jump found below 29 at all 221. The raised-top sub-case is checked at all 54 (window, m) cells the automaton reads, every K a multiple of the state period up to 252; the golden witnesses are the automaton's own. At the Liouville-type window the straddling pair is found within 2 of its predicted crossing at every big digit D = 4, 8, …, 24.

verifiers: explore_relation_address.py, explore_aperiodic_address.py, explore_witness_family.py, explore_limit_maps.py

How common the certificate is turns out to be a 2-adic question. At a constant-a window, run the denominator recurrence one step lower — U₀ = 0, U₁ = 1, U_n+1 = a·U_n + U_n−1 — and for an odd prime m not dividing a² + 4 let z(m), the rank of apparition, be the first index at which m divides a term. The boundary family's certificate exists iff z(m) ≡ 2 mod 4 (at m = 2 it always does), and that criterion reads off the unit: z(m) ≡ 2 mod 4 exactly when the multiplicative order of ε mod m has 2-adic valuation v₂ ≤ 1. So a prime inert at the window (a² + 4 not a square mod m) never qualifies — inert m ≡ 1 mod 4 has z odd, inert m ≡ 3 mod 4 has v₂(z) = v₂(m + 1) ≥ 2 — while a split m ≡ 3 mod 4 always does. Among all odd primes the qualifying density is 1/3 for a generic window, and 7/24 exactly when a² + 4 is 8·(square) — the Pell family a = 2, 14, 82, …, where splitting ties to m mod 8. Windows whose ε are odd powers of one unit share v₂(z) at every prime, so the golden pair a = 1, 4 (ε = φ, φ³) and the Pell rows print identical columns. At every window the certificate-less primes are thus the majority — two thirds generically, 17/24 on the Pell rows — and nothing waits on them: the address is the unimodular family's everywhere, so what the criterion measures is how often the boundary family's witness exists beside it.

Scope. The criterion, the unit law, the inert/split laws and the odd-power sharing are theorems, confirmed at every scanned prime — and the densities are theorems too. The one free ingredient, how often a split m ≡ 1 mod 4 has v₂(ord ε) ≤ 1, is Chebotarev equidistribution in the 2-power Kummer tower over Q(√(a² + 4)), and the tower's root-adjoining degrees never collapse: the unit's norm −1 is not a square in the real field Q(√(a² + 4)), so √ε generates a non-normal quartic, which no abelian extension — no cyclotomic-quadratic composite — can contain. So no entanglement corrects that count; the only collapse anywhere is the classical √2 inside the eighth roots of unity, which is what ties splitting to m mod 8 on the Pell rows and moves nothing else. That is Hasse's density method for even and odd orders (1966), carried out for the golden window by Lagarias (1985) and for every window with a norm −1 unit by Moree (1996), whose densities are exactly the 1/3 and 7/24 above. The scan agrees within 2·10⁻³ at 12 windows over odd primes to 10⁶, and the method's finer fingerprint — among split m ≡ 1 mod 4 with j = v₂(m − 1), the layers v₂(z) = 0, 1, e ≥ 2 arriving with probabilities 2^1−j, 2^1−j, 2^e−j, the layers stopping at e = j − 1 — holds within three standard deviations at every cell.

verifiers: explore_class_criterion.py, explore_apparition_density.py, explore_kummer_layers.py