FLUSH — what a redundant reader of the circle computes

The object: the trailing Ostrowski numeration at an irrational α (OSTROWSKI) read by a bottom-up reader into a redundant output. Position t ≥ 1 may carry any digit up to a_(t+1) + s and position 0 any digit up to a₁ − 1 + s₀, for slacks s and s₀ ≤ s + 1, and the condition that a digit equal to a_(t+1) sits over a zero is dropped, so an integer has many output strings. The input stays greedy. The slack (s, s₀) buys an excess E = s₀α + s S₁, S_t = Σ_(k≥t) |θ_k|, by which the output's level-0 range, the real stars of its strings read from position 0 (its level t is position t), is longer than 1. A reader at lookahead c writes e_t having seen d₀ … d_(t+c). The completion reader writes, for each point of the odometer, an infinite string whose star is mx + M, x being the input's star and M an integer. The integer reader of n ↦ mn + ω writes, for each n, a finite string equal to mn + ω; where no ω is named it is ×m's, ω = 0. The notation (q_k, θ_k, the star Σ e_k θ_k of a string, tiles, cuts, the odometer, t₀) is OSTROWSKI's. This page shows that redundancy with positive excess cures n ↦ mn (m ≥ 2) on the completion and never floor division, for the reasons OSTROWSKI gives for their walls. It shows that at a purely periodic α the integers cost the completion reader's lookahead plus the flush, the duty to end, which is never owing a negative integer, and nothing else, and that there an integer reader of ×m has least lookahead 0 or at least 2, never 1. Wherever E > 0 it reads at every irrational α at a lookahead of at most 2⌈log₂ m⌉ + 3, and + 2 where s₀ ≥ 1. No reader of ×m, of either kind, reads below the cylinder bound c_lo, a formula in α's remainders, nor at (s, s₀) = (0, 1) below the pinned bound c_lo2, which c_int exceeds there by at most 2, and by at most 1 where c_lo2 > c_lo. At a periodic α the pinned bound deepens, level by level, to the pinned limit c_inf ≤ c_saf, and the script prints c_inf = c_saf at all 48 cells it reads, a pattern.

Which price is which. The walls of ×m were the coding's, since x ↦ mx is continuous on R/Z. Overlapping output tiles cure them, and the cure is READING's signed-digit cover moved onto the circle. At E = 0 the tear survives, because dropping that condition alone leaves the level-0 range of length exactly 1, overlapping no other lift's. Floor division is no continuous circle map: an input tile hides n mod m, and no output slack shows it. Between the completion and the integers two things differ. For ×m the lift is the output's real star less m times the input's, an integer. The integer reader carries the set of lifts still possible, and those are the fibre of R over R/Z, not residues mod m. At a purely periodic α tracking them costs nothing: the completion reader's least lookahead is that of the same game with the flush dropped. The flush is what is left. An integer's string ends, so a capped input digit at a deep enough position k leaves a residual the reader must write from where it stands. When (m − 1)a_(k+1) > s and m a_(k+1) < q_(k−1), that residual's only string needs a digit above a_(k+1) + s for a reader at lookahead 0 or 1; on most cells of the grid below the reader that must end needs no more lookahead than the same game with the flush dropped.

MAP         LEGAL OUTPUT      REDUNDANT, E = 0    REDUNDANT, E > 0
n ↦ n + 1   c = 1             c = 0               c = 0
n ↦ mn      DISCONTINUOUS     torn from t₀        completion: c_lo to c_ov
                                                  integers: ≥ c_lo; 0 or ≥ 2
                                                  (purely periodic α),
                                                  ≤ c_ov(0, 1) (s₀ ≥ 1),
                                                  ≤ c_sr (s₀ = 0)
                                                  both: ≥ c_lo2 at (0, 1)
⌊n/m⌋       DISCONTINUOUS     walled from t*      walled from t*

The script's grid: the six purely periodic α golden [1], silver [2], bronze [3], √3 − 1 = [1, 2], [1, 1, 1, 2] and [2, 1, 3, 1], where [a₁, …, a_p] is the α whose quotients repeat that block; the maps ×2 … ×5; and the six slacks (s, s₀) = (0, 0), (0, 1), (1, 0), (1, 1), (2, 2), (3, 3). On this page a periodic α is a purely periodic one, and the script's counts are those of flush.py --full. In the table c_ov is the overlap reader's lookahead, c_sr that of a reader built at s₀ = 0, c_lo the cylinder bound, c_lo2 the pinned bound and t* the depth from which floor division walls, each fixed in its section below.

The tear at E = 0

Tier: theorem.
Verifier: proof; flush.py::section_tear; flush.py::section_grid; flush.py::section_controls.

At s = s₀ = 0, with the condition dropped, no reader of n ↦ mn (m ≥ 2) at any lookahead commits, from the input tiles about (1 − α)/m, an output tile of depth t₀ or more, t₀ the first depth with q_t ≥ 2, at every irrational α. The successor reads at lookahead 0 there, and so at every slack, since slack only widens the output digits; the legal output needs lookahead 1 (OSTROWSKI: The affine maps).

Proof. At s = s₀ = 0 the level-0 range is exactly [−α, 1 − α], so a string of N has as real star the representative of Nα mod 1 in (−α, 1 − α); no N ≥ 0 sits on an end, since (N + 1)α is not an integer. The least string (0, a₂, 0, a₄, …) has star −α by the telescoping a_(k+1) θ_k = θ_(k+1) − θ_(k−1), and the greatest (a₁ − 1, 0, a₃, 0, …) has star 1 − α. A string's star minus −α is Σ (e_k − e_k^min) θ_k, a sum of non-negative terms, so a string within η of −α agrees with the least string at every position with |θ_k| > η, and likewise at the top. The two extremes part at position t₀ − 1. The non-cut y = (1 − α)/m is carried to the cut −α by x ↦ mx (OSTROWSKI: The containment criterion). The integers of every input tile about y have images mnα on both sides of −α and arbitrarily near it, so their output strings agree low down with the least string on one side and with the greatest on the other, whatever the reader chooses, and no output tile of depth t₀ holds both. The successor writes e₀ = d₀ + 1, or e₀ = 0 and e₁ = d₁ + 1 when d₀ = a₁ − 1, which is legal with the condition dropped because d₁ = a₂ forces d₀ = 0. At a₁ = 1 the same happens one position up.

The script enumerates all 8,321 strings of every N < 300 at s = s₀ = 0 over seven α (the grid's six and the fractional part of Euler's number, quotients 1, 2, 1, 1, 4, 1, 1, 6, …) and finds every star the representative, and every string near an end in agreement with that end's extreme. Its game reads ×2 … ×5 at no c ≤ 3 at each of the grid's six α, and the successor at 0.

The overlap reader

Tier: theorem.
Verifier: proof; flush.py::section_completion; flush.py::section_ranges; flush.py::section_grid.

At E > 0, ×m has a completion reader at every irrational α at lookahead c_ov, the least c with w_t = m(|θ_(t+c)| + |θ_(t+c+1)|) ≤ ov_t = |θ_(t+1)| + s S_(t+1) at every level t and w₀ ≤ E. c_ov bounds the completion reader's least lookahead, not always tightly: golden ×2 at (s, s₀) = (0, 1) has c_ov = 4, and the safety game below reads it at 3. c_ov is finite, since |θ_(k+2)| < |θ_k|/2. This is READING's signed-digit cure (READING: Lipschitz walls on absolute tiles are archimedean): a tile's children overlap, so an interval shorter than the overlap lies in one child.

Proof. The tails from level t have stars filling the interval T_t between −Σ cap_k |θ_k| over the k ≥ t with θ_k < 0 and Σ cap_k θ_k over those with θ_k > 0, cap_k being the output cap at k, the largest output digit allowed there: a_(k+1) + s, or a₁ − 1 + s₀ at k = 0 (the input cap is a_(k+1), or a₁ − 1 at k = 0). By the telescoping its length is |θ_(t−1)| + |θ_t| + s S_t, and 1 + E at t = 0. Its members e θ_t + T_(t+1), e = 0 … cap_t, cover it, and consecutive members overlap by ov_t. The legal input tails from position j have stars in the closed interval I_j between −θ_j and −θ_(j−1) (OSTROWSKI: The circle numeration), and those opening with a digit d lie in d θ_j + I_(j+1), which is inside I_j. So once d₀ … d_(t+c) are seen and e₀ … e_(t−1) written, the star still owed, at a lift M, lies in J_t = M + m(Σ_(k≤t+c) d_k θ_k + I_(t+c+1)) − Σ_(k<t) e_k θ_k, an interval of width w_t, and J_(t+1) lies inside J_t − e_t θ_t. Some lift M puts J₀ inside T₀ when w₀ ≤ E, and a member holds J_t when w_t ≤ ov_t. Committing that member keeps J_t inside T_t at every depth. The length of T_t tends to 0, so the output codes mx + M.

The script runs this reader 36,000 times to depth 40 over nine α (the grid's six, the fractional part of Euler's number, [4] and [5]), ×2 … ×5 and five slacks, and it never fails to find a member (at the fractional part of Euler's number its lookahead is the least c meeting the conditions to depth 40). c_ov runs from 0 to 6 over the grid; at a periodic α the ratios |θ_(k+1)/θ_k| repeat with the period, so the 40 depths it checks decide them all.

Floor division walls at every slack

Tier: theorem.
Verifier: proof; flush.py::section_floors.

At every slack and every irrational α, ⌊n/m⌋ (m ≥ 2) commits no output tile of depth t* or more, t* the first depth with |T_t*| < 1/m, from any input tile at any lookahead. Every point is a wall, and no slack changes that: the price is the map's.

Proof. The strings sharing a depth-t prefix have stars in one translate of T_t, which is an arc of length |T_t| on the circle. Take any input tile, a non-cut x inside it, and a residue r mod m. By OSTROWSKI: Floor division is never MIDDLE here, for the integers n ≡ r in every input tile about x, the points ⌊n/m⌋α mod 1 come arbitrarily close to each of the m points (x − rα + P)/m, P = 0 … m − 1, which lie 1/m apart. An arc shorter than 1/m cannot come within ε of two of them once ε is small, so no depth-t* output tile holds the images of any input tile.

Over 9,063 tests at six α, m = 2, 3 and s = s₀ = 0 … 3, one per input tile of depth t* + c, c = 0 … 3, holding at least 12 of the inputs n < 60000, the script finds the images' circular hull longer than |T_t*| in every one, by at least 0.196.

The lift game

Tier: theorem.
Verifier: proof; flush.py::section_grid; flush.py::section_owed; flush.py::section_universal.

At a periodic α, the integer reader of n ↦ mn + ω (0 ≤ ω ≤ m) at lookahead c exists iff the reader wins a finite game, and the same game with the flush dropped, the safety game, is finite too. Over a finite alphabet of quotients the same holds for one reader serving every α with quotients in it, which sees the quotients through a_(t+c+1) and nothing else of α. The game at each c is finite, pruned to a box the proof below derives without the lookahead, so it is decided exactly, and the two least lookaheads, where finite, are found by searching c upward: c_int, the integer reader's, which must also flush, and c_saf, the safety game's, whose reader keeps some lift alive forever but need not end.

Proof. Write the residual H_t = m Σ_(k≤t) d_k q_k + ω − Σ_(k<t) e_k q_k, keeping the pre-read d_(t+1) … d_(t+c) apart, as g q_t + h q_(t−1), and set σ = g θ_t + h θ_(t−1). The pair (g, h) is a lattice point of integers, and a step sends it to (h + m d_(t+1), g − e_t − a_(t+1) h), labelled by the local quotient alone. The seed (m d₀ + ω, −M) carries the lift M, and each lift still possible carries its own pair, its branch. Every branch has the same H, since two differ by a multiple of (q_(t−1), −q_t), so the state is the set of lifts still alive together with the pending quotients, the position in α's period, the pending digits and three flags: whether the last input digit is 0, which bounds the next one; whether the step is at position 0, whose output cap is a₁ − 1 + s₀; and whether the last output digit is 0, which binds only when the game is run on the legal output (s = s₀ = 0 with the dropped condition restored, the table's legal-output column). A correct reader's own lift has σ_t = (output tail star) − m (input tail star from t + 1), so |σ_t| < (1 + s)|θ_(t−1)| + m|θ_t|, and |H_t| ≤ μ q_(t+1) with μ = max(m, 1 + s): a greedy input prefix is below q_(t+1), so H_t ≤ m(q_(t+1) − 1) + ω ≤ m q_(t+1) as ω ≤ m, and the output prefix, every digit at most a_(k+1) + s (at position 0 by s₀ ≤ s + 1, the reason for that bound), is at most (1 + s)(q_(t+1) − 1), by Σ_(k<t) a_(k+1) q_k = q_t + q_(t−1) − 1 ≤ q_(t+1) − 1 and Σ_(k<t) q_k < q_(t+1). The frame is unimodular, |q_t θ_(t−1) − q_(t−1) θ_t| = 1, q_t |θ_(t−1)|, q_(t−1)|θ_(t−1)|, q_t |θ_t| and q_(t−1)|θ_t| are at most 1, and q_(t+1) |θ_t| < 1 and q_(t+1) |θ_(t−1)| < a_(t+1) + 1, the two that multiply |H|, strict, so that branch obeys, whether or not the bound on σ_t is strict,

|g| < B_g = μ(A + 1) + 1 + s + m,    |h| < B_h = 1 + s + m + μ,

A the largest quotient. A win of the pruned game is a reader, since every branch it keeps is a true pair (g, h) of the residual, so its end, a branch at (0, 0), is H = 0. Pruning branches outside this box never removes a correct reader's own, so a loss is a loss: a reader may use its whole history, but the states it visits are closed under its moves, and an integer reader ends from each of them under zero input, so they lie in the greatest fixed point below. The integer game asks, besides safety, that under zero input the play reach the branch (0, 0) with nothing pending, which is H = 0: the string ended. The safety game omits that; its greatest fixed point keeps the states with a move whose every reply stays in the set.

The flush is a sign. Absorb a branch's pending digits into its tentative pair (G, H); then N_t = G q_t + H q_(t−1), the same at every branch, is what is owed if the input stops at t + c, and an integer reader never owes a negative integer, N_t being the value of what it writes from t on. Conversely, at every irrational α, a play that stays in the box and never owes a negative integer ends under zero input: there N_(t+1) = N_t − e_t q_t, so e_t = 0 from some T on, after which a step sends (g, h) to (h, g − a_(t+1) h) and keeps σ, which the box squeezes below B_g|θ_t| + B_h|θ_(t−1)| → 0, leaving the branch (0, 0) alone, α being irrational. At a periodic α the sign is read off the state. With α′ the conjugate, θ′_k = q_k α′ − p_k < 0 and ζ′_t = θ′_t/θ′_(t−1) = a_t + 1/ζ′_(t−1) > 1 depend on t mod p only, and the branch's tentative conjugate u = G ζ′_t + H obeys N_t (α − α′) = σ − u θ′_(t−1), σ = G θ_t + H θ_(t−1), and α − α′ > 1 (α′ < −1): once |σ| < 1 on the box, u ≥ 0 is N_t ≥ 1, or N_t = 0 with σ ≤ 0. A step sends u to u/ζ′_t − e_t plus a non-negative input term, so under zero input u < 0 persists, and every state an integer reader visits holds a branch with u ≥ 0. Conversely, in the safety game's fixed point on those states, a chain of such branches runs on under zero input by König's lemma, u shrinking by a factor ζ′_t or more through finitely many values to 0, which is (0, 0) with nothing pending, ζ′ being irrational. So c_int is the least lookahead of one safety game, and inside it every safe move flushes. Over a quotient alphabet ζ′ is not known to the state, and the script solves the integer game there, as everywhere, by alternating the safety cut with the attractor of the ended states under zero input.

The script's c_int agrees at all 144 cells with the table, in flush.py, of a second computation over the quadratic field of α, the 24 of the (0, 0) column finding no reader at any c ≤ 3; the reader it extracts from each win writes the right value under the output caps and ends, for every n < 1000. Solved at twice the box, the flushing branches of the reader of ×2 at s = s₀ = 1 over the quotient alphabet {1, 2} (the universal reader below) never leave the box itself, over the alphabet's two constant α and four random ones and every n < 250: at most (4, 2) against (10, 6). At every cell of the grid and every c up to c_int (to the cap where none) the two winning sets, the integer game's and the safety game's on the states with a branch of u ≥ 0, are equal; ζ′ replaced by the real side's ratio |θ_t/θ_(t−1)| moves the set at 116 of the 144 cells.

The completion reader is the safety game

Tier: theorem.
Verifier: proof; flush.py::section_completion; flush.py::section_grid; flush.py::section_band.

At every periodic α and over every finite quotient alphabet, with s₀ ≤ s + 1, the completion reader's least lookahead c_comp equals c_saf at ω = 0, c_comp over an alphabet being that of one completion reader serving every α with quotients in it, which sees them through a_(t+c+1). So tracking the lifts costs no lookahead, and c_int − c_comp is the flush's price alone. The lifts are these integer differences: the fibre of R over R/Z, which the circle carries, and not n mod m, which OSTROWSKI proves no tile carries and which stays floor division's.

Proof. In a safe play the set of branches is never empty, each branch has one parent, and the box holds finitely many. By König's lemma one chain of branches, each the parent of the next, runs forever. Its σ_t obeys |σ_t| ≤ B_g|θ_t| + B_h|θ_(t−1)|, which tends to 0, so the output codes mx + M for that chain's lift: a safe reader is a completion reader. A completion reader's own lift carries a branch, inside the box by the lift game's bound, so the reader plays safe, and by the lift game's proof, the states it visits closed under its moves, the finite game is won too.

The script tracks the overlap reader's own lift in the game's frame over its 36,000 runs, with A the largest of a₁ … a₄₁, the quotients its tracked times 0 … 40 use (at the fractional part of Euler's number the box is not defined over the whole expansion): it uses at most 0.92 of B_g and 0.42 of B_h. It finds c_saf ≤ c_ov at every cell, and c_saf unchanged at twice the box at four cells.

The flush floor

Tier: theorem.
Verifier: proof; flush.py::section_digitwise; flush.py::section_grid; flush.py::section_band.

Let m ≥ 2. If s ≥ (m − 1) a_(k+1) at every k ≥ 1, the integer reader reads at lookahead 0, whatever s₀. If (m − 1) a_(k+1) > s and m a_(k+1) < q_(k−1) at infinitely many k, it reads at no lookahead below 2. So at a purely periodic α with largest quotient A, c_int is 0 when s ≥ (m − 1)A and at least 2 otherwise, and never 1.

Proof. For the first half the reader writes e₀ = m d₀ mod a₁, e₁ = m d₁ + ⌊m d₀/a₁⌋ and e_k = m d_k beyond, a function of the digits seen at lookahead 0 with value mn, since q₁ = a₁. The output caps hold: d₀ ≥ 1 forces d₁ ≤ a₂ − 1, so e₁ ≤ m a₂ − 1. For the second, take a reader at lookahead c ≤ 1, an integer n, and one of the k with n's digits all below position k − 1 and the whole of mn written below level k − 1. On n′ = n + a_(k+1) q_k it writes the same prefix, having seen the same digits, and it owes exactly m a_(k+1) q_k, from level k − c ≥ k − 1. Write q_(k+j) = U_j q_k + V_j q_(k−1), V_j ≥ 1 at j ≥ 1. A string of value m a_(k+1) q_k from level k − 1 has m a_(k+1) q_k = X q_k + Y q_(k−1) with Y = e_(k−1) + Σ_(j≥1) e_(k+j) V_j, so q_k divides Y. Y ≥ q_k would force m a_(k+1) ≥ q_(k−1), so Y = 0 and the only string is e_k = m a_(k+1), over its output cap a_(k+1) + s.

Over the grid the script finds c_int = 0 exactly where s ≥ (m − 1)A and 2 or more elsewhere, never 1. c_int − c_saf is 0 at 91 of the 120 finite cells, 1 at 28 and 2 at one ([1, 1, 1, 2] ×3 at s = s₀ = 3, where c_saf = 0). At four cells beyond the grid, [4] and [5] ×2 at s = s₀ = 3, and [4] and bronze ×3 at 5, c_ov = 1 and c_int = 2: the completion reader reads at 1 and the integer reader cannot. The first half's reader (flush.py's digitwise one) is correct at every α of the grid, ×2 … ×5 and n < 1000, at s = (m − 1)A with s₀ = 0; and at one k in each position of α's period, the first k ≥ 2 with m a_(k+1) < q_(k−1), m a_(k+1) q_k has exactly one string from level k − 1 of any digit sizes.

The integers at every positive excess

Tier: theorem.
Verifier: proof; flush.py::section_cone.

Wherever E > 0, at every irrational α, bounded quotients or not, the integer reader of n ↦ mn + ω (m ≥ 2, ω ≥ 0) reads at a lookahead bounded in m alone: at c_ov(0, 1) ≤ 2⌈log₂ m⌉ + 2, the overlap reader's lookahead at (s, s₀) = (0, 1), wherever s₀ ≥ 1, and at c_sr ≤ 2⌈log₂ m⌉ + 3 wherever s₀ = 0, the lookahead of the seam reader, which spends level 1's slack once where the target holds a lift's seam, the point −1 over α at which one lift of T₀ at the (0, 0) caps meets the next. E > 0 is s ≥ 1 or s₀ ≥ 1, and a reader at some caps is one at any larger caps, so the two readers at (0, 1) and (1, 0) carry every slack. Every overlap reader at the (0, 1) caps, whatever lift and members it commits, is an integer reader. Each is a reader of one α, which reads off α's whole expansion the ratios ζ_k = |θ_k/θ_(k−1)| = [0; a_(k+1), a_(k+2), …], and not the universal reader below.

Proof at s₀ ≥ 1. At (0, 1) every output cap is a_(t+1), position 0's a₁ included, and ζ_(t+1)(a_(t+2) + ζ_(t+2)) = 1. Over θ_t, T_t is [−1, a_(t+1) + ζ_(t+1)] and the member e is [e − 1, e + ζ_(t+1)], so e holds J_t iff j⁺ − ζ_(t+1) ≤ e ≤ j⁻ + 1, j⁻ ≤ j⁺ the ends of J_t over θ_t. Write the owed integer in its cone coordinates, N_t = K q_(t+1) + L q_t. Over θ_t, J_t is L − K ζ_(t+1) plus [i⁻, i⁺], m times the unseen input's interval, i⁻ < 0 < i⁺. Writing e sends (K, L) to (L − e, K − a_(t+2)(L − e)), which is non-negative iff L − ⌊K/a_(t+2)⌋ ≤ e ≤ L. If K ≥ 0 every e that holds J_t lies there: e ≤ ⌊L − Kζ_(t+1) + i⁻ + 1⌋ ≤ L; and e ≥ L − ⌊(K + 1)ζ_(t+1) − i⁺⌋, where, with K = u a_(t+2) + r and 0 ≤ r < a_(t+2), (K + 1)ζ_(t+1) ≤ (u + 1) a_(t+2) ζ_(t+1) < u + 1. An input digit adds a multiple of q_(t+c+1), whose coordinates are non-negative. At level 0 a lift is a K₀ with N₀ = K₀ a₁ + L₀, its star over α is x₀ = N₀ − K₀/α, strictly inside J₀ as i⁻ < 0 < i⁺, and J₀ inside T₀ gives −1 < x₀ < a₁ + ζ₁ = 1/α, so K₀ > N₀α − 1 ≥ −1 and L₀ > K₀ζ₁ − 1 ≥ −1. So K, L ≥ 0 at every level: the reader never owes a negative integer. Under zero input N ≥ 0 falls by e_t q_t, so the output stops, after which the star is constant and lies in J_t inside T_t, whose length tends to 0: it is 0, which is N = 0 at irrational α. No step used a bounded quotient or a box. For the bound, |θ_(k−1)| ≥ |θ_k| + |θ_(k+1)| gives w_t ≤ m|θ_(t+c−1)|, and |θ_(k+2)| < |θ_k|/2 puts it below |θ_(t+1)|, the overlap at s = 0, once c ≥ 2⌈log₂ m⌉ + 2; then also w₀ < |θ₁| < α = E.

The seam, s₀ = 0. At the (0, 0) caps T₀ over α is [−1, a₁ − 1 + ζ₁], of length 1/α, the shift from one lift to the next, so J₀ lies inside one lift of T₀ or holds that lift's seam. Inside, the reader above reads from level 0: the cone argument never used position 0's cap, and x₀ < 1/α still. Holding the seam, with σ = x₀ + 1 and |σ| ≤ w₀/α, the seam reader writes e₀ = 0 and e₁ = a₂ + 1, level 1's slack spent once, and then reads as above from level 2. Then x₂ = a₃ + ζ₃ − 1 + σ/(ζ₁ζ₂), so J₂ lies in T₂ = [−1, a₃ + ζ₃] once w₀ < ζ₁ζ₂α = |θ₂|, and J₁ lies in the member a₂ + 1 alike. The cone: M = N₀ + 1 is a positive integer whose star over α is σ, and a positive integer whose star over θ_j lies in (−1, 1) has K ≥ 1 at level j (K = 0 makes it L q_j with |L| < 1; K ≤ −1 forces L ≥ a_(j+1) and a star above 1). The two moves leave the owed integer at K₁(M) − 1 and K₂(M) − 1, both ≥ 0, and L₂ ≥ 0 since x₂ > −1, so from level 2 the cone holds and the reader ends. So the seam reader at c_sr, the least c with w₀ < |θ₂| and w_t ≤ |θ_(t+1)| at every t ≥ 1, is an integer reader at (1, 0), and w₀ ≤ m|θ_(c−1)| < |θ₂| once c ≥ 2⌈log₂ m⌉ + 3. Equality w₀ = |θ₂| never occurs: m ≥ 2 would divide the coprime q₂ and p₂.

The script runs the reader exactly, least lift, at the grid's six α, the fractional part of Euler's number and one random α with quotients in {1, 2, 3}, ×2 … ×5, c from c_ov(0, 1) to two above: on every n < 1000 and 100 random greedy strings of length 60, with ω = 0 and m and the least and greatest member, no input fails and no step has K or L negative. c_ov(0, 1) is at most 4, 5, 5, 6 for m = 2 … 5, the bound being 4, 6, 6, 8, met at ×2 by four of the eight α, and it equals c_int at 18 of the grid's 24 cells. The reader at c_int − 1 fails at all 24. The same reader at the same lookahead on the (1, 1) ranges and caps, where an integer reader exists, breaks the cone and fails at 27 of the 32 (α, m) cells: there the wider T₀ admits the lift K₀ = −1 at n = 0, which fails at all 27 and alone at 13, other inputs failing too at 14. So the s = 0 ranges are what hold the cone.

The seam reader runs the same way at c_sr and c_sr + 1, on the same α, inputs, ω and members: no input fails, no step has K or L negative, and the seam is taken at every one of the 32 (α, m) cells. c_sr is at most 5, 6, 6, 7 for m = 2 … 5 against the bound 5, 7, 7, 9, met by golden ×2 alone, and runs 1 to 5 above c_int(1, 0) over the grid's 24 cells; the seam reader at c_int(1, 0) − 1 fails at all 23 where that is at least 1. With the seam's bar loosened to w₀ ≤ |θ₁|, the s = 0 bar, the lookahead falls at 21 cells and the reader fails at 12, every failing input with no member at level 2, the window the |θ₂| bar keeps.

The cylinder bound

Tier: theorem.
Verifier: proof; flush.py::section_cylinder; flush.py::section_pinned; flush.py::section_pinlimit.

At every irrational α and slack, no completion reader of x ↦ mx and no integer reader of n ↦ mn + ω (m ≥ 2, ω ≥ 0) reads below c_lo, the least c with w_t = m(|θ_(t+c)| + |θ_(t+c+1)|) ≤ |T_(t+1)| at every level t ≥ 0 with |T_(t+1)| < 1, a bar with no s₀ in it. Wherever E > 0, c_ov ≤ c_lo + max(2, t₁), t₁ the least t with |T_(t+1)| < 1, and t₁ ≤ max(1, 2⌈log₂(2s + 1)⌉); the gap is at most 2 at a purely periodic α and wherever |T₃| < 1. At the golden ratio φ, c_lo is the least c with mφ^(−c) ≤ 1 + s and c_ov the least with mφ^(−c) ≤ s + min(φ^(−2), s₀/φ).

At (s, s₀) = (0, 1) the zero cylinder is pinned: at every level t with |T_(t+1)| < 1, a completion reader of x ↦ mx, or an integer reader at ω = 0, writes e₀ … e_t all 0 at lift 0 over the inputs whose digits d₀ … d_(t+c) are all 0. Let Z(c) ask, at each such t, that mI_j lie inside I_(t+1), j = t + c + 1, and that m times each sub-cylinder of I_j by the digit d_j lie inside one member of T_(t+1); the pinned bound c_lo2 is 1 plus the largest c at which Z(c) fails, and c_lo ≤ c_lo2 ≤ min(c_comp, c_int); by the completion reader's theorem, c_lo2 ≤ c_saf, at most c_int, wherever c_saf is defined. As t₁ ≤ 1 there, c_int is c_lo2 plus 0, 1 or 2 at every irrational α, and plus 0 or 1 wherever c_lo2 > c_lo. At golden, c_lo2 is c_lo rounded up to even. At a periodic α, read L levels into the zero cylinder's subtree, the bar c_L (c_1 that of mI_j ⊂ I_(t+1) alone, c_2 = c_lo2) is non-decreasing in L and reaches, at a finite L, the pinned limit c_inf: 1 plus the largest c at which some pinned state loses, the safety game's state at a pin level t (one with |T_(t+1)| < 1) with the lift 0's branch alone and every pending digit 0. c_lo2 ≤ c_inf ≤ c_saf, and c_inf is what the game's all-zero pre-read reads.

Proof. Fix t with |T_(t+1)| < 1 and the inputs whose digits d₀ … d_(t+c) are all 0. Their stars are dense in I_j, of length |θ_(t+c)| + |θ_(t+c+1)|, the integers other than 0 among them too, and over all of them a reader at lookahead c has written the same e₀ … e_t. So each output star, mx + ωα + M with M an integer, lies in one translate of T_(t+1). For each M the x it allows form a closed interval of length |T_(t+1)|/m < 1/m, and those of different M are translates by multiples of 1/m, so disjoint. Finitely many meet I_j, and a dense subset of I_j inside their union puts I_j inside one, so m|I_j| ≤ |T_(t+1)|, which is w_t ≤ |T_(t+1)|. Upward: for L ≥ 1, |T_(L+1)| − |T_L| = |θ_(L+1)| − |θ_(L−1)| − s|θ_L| < 0, so |T_(t+1)| < 1 at every t ≥ t₁. As |θ_(t+1)| = a_(t+3)|θ_(t+2)| + |θ_(t+3)|, |T_(t+3)| ≤ |θ_(t+1)| + s S_(t+1) = ov_t, and |T₃| = |θ₂| + |θ₃| + s S₃ < E = s₀α + s S₁: at s₀ ≥ 1 as |θ₂| + |θ₃| < α, at s ≥ 1 as |θ₂| + |θ₃| < s(|θ₁| + |θ₂|). With K = max(2, t₁), w_t(c_lo + K) = w_(t+K)(c_lo) ≤ |T_(t+K+1)| ≤ |T_(t+3)| ≤ ov_t at every t, below E at t = 0, so the overlap reader's bars hold at c_lo + K. For t₁, S_t ≤ |θ_(t−1)| + |θ_t| gives |T_(t+1)| ≤ |θ_(t−1)| + 2s|θ_t|, and |θ_k| ≤ 2^(−⌊(k+1)/2⌋), strictly but at k = −1, so |T_(t+1)| < (1 + 2s)2^(−⌊t/2⌋) at t ≥ 1, at most 1 once t ≥ 2⌈log₂(2s + 1)⌉. At a purely periodic α the ratios |θ_k/θ_(k−1)| repeat with the period, so w_t/|T_(t+1)| does too and the bar holds at every t, as it does at t ≥ 2 wherever |T₃| < 1, which gives K = 2. At golden |θ_k| = φ^(−k−1), so |T_(t+1)| = (1 + s)φ^(−t), ov_t = (φ^(−2) + s)φ^(−t), E = s₀/φ + s and w_t = mφ^(−t−c).

The zero cylinder. At s = 0, T_L = I_L for L ≥ 1, its members eθ_L + I_(L+1), e = 0 … a_(L+1), each two consecutive ones overlapping by |θ_(L+1)|. Over I_j the lift is one M and e₀ … e_t write Nα − P, N = Σ e_k q_k ≤ q_(t+1) + q_t − 1 as e_k ≤ a_(k+1), so with K = M + P every point of K − Nα + mI_j lies in I_(t+1), and K − Nα is interior to I_(t+1), 0 being interior to I_j. It is so at N = 0 alone: for 0 < N < q_(t+1), |Nα − K| ≥ |θ_t| (Lagrange's best approximation), the farther end's distance; for N = q_(t+1) + N′, N′ < q_t, K − Nα is the end −θ_(t+1) plus a point at distance 0, at least |θ_(t−1)| = a_(t+1)|θ_t| + |θ_(t+1)| ≥ |I_(t+1)|, or at least 1; and at N = 0 the integer K in an interval of length below 1 around 0 is 0. So M = 0 and mI_j ⊂ I_(t+1); over each sub-cylinder C of I_j the reader has also written e_(t+1), so mC lies in one member, and a reader at c, being one at every larger c too, meets Z(c′) at every c′ ≥ c. c_lo ≤ c_lo2 as m|I_j| ≤ |I_(t+1)| is c_lo's bar, and c_int ≤ c_ov(0, 1) ≤ c_lo + 2 by the section above and the gap bound. Z(c) holds once 2^⌊(c−1)/2⌋ ≥ m, as |θ_(k+2)| < |θ_k|/2, so c_lo2 is finite. At a constant quotient, ratio r, mI_j ⊂ I_(t+1) reads mr^c ≤ 1 at c even and mr^(c−1) ≤ 1 at c odd, and c_lo is the least c with mr^c ≤ 1. At a = 1 the sub-cylinders other than I_(j+1), at c odd, lie on the side where member 0 reaches as far as I_(t+1), and at c even on the side member 1 covers from 0 to I_(t+1)'s end; I_(j+1), holding 0, sits in member 0 by the same bar at t + 1. So at golden Z(c) is mI_j ⊂ I_(t+1) alone.

The pinned limit. At level i of the subtree the opponent has added the digit d_(j+i−1) and the reader e_(t+i), and m times the inputs left must lie in the window the reader has committed, Σ e_kθ_k over k = t + 1 … t + i plus I_(t+i+1). A reader passing every L exists by König's lemma, choices being finite on both sides; it codes mx exactly on the subtree, so its lift-0 branch is a true one, which the box keeps, and the pinned state wins. Conversely a safe play from the pinned state keeps a lineage coding mx + M with M = 0, and by the pin no move at that lift but e = 0 is in a safe play, so its output lies in every window. Every c from c_comp on passes every L, so c_L reaches c_inf at a finite L, and c_inf ≤ c_comp = c_saf since every completion reader writes the zero cylinder at lift 0. At a purely periodic α the pinned state one period in plays as the all-zero pre-read with only its lift-0 branch, position 0's cap a₁ − 1 + s₀ being a₁ at s₀ = 1; a win there makes the pre-read, holding more branches, win, and a win from the pre-read, the opponent playing zeros, writes zeros through every pin level t by the pin and so passes through a state holding each pinned state's branch at lift 0; every safe continuation keeps a lineage coding mx + M, by the completion reader's theorem, and M = 0 by the pin, so the strategy followed from each pinned state never empties its branch set.

The script reads c_lo's bars from above, so that an exact tie passes, and c_ov's both ways, which agree at every cell read beyond the golden controls; six grid cells meet a tie, at s = (m − 1)a, a the constant quotient. c_lo ≤ c_saf and c_lo ≤ c_int at every grid cell with E > 0, and c_ov − c_lo is 0 at 31 of those 120, 1 at 67 and 2 at 22; at the fractional part of Euler's number and one random α with quotients in {1, 2, 3}, |T₃| < 1 at every slack and the gap is 0 to 2. Printed, not proved: c_lo = c_saf at 54 of the 120 cells, and the pattern that c_saf is 0 wherever c_lo is (the converse proved). The α = [0; 1, …, 1, 10⁸, 10⁸, …], N + 1 quotients 1 before the 10⁸s, with s the least making |T_N| ≥ 1 (1, 3, 6, 11, 19, 32 at N = 2 … 7), has t₁ = N, and at s₀ = 1, over m = 2 … 4096 in powers of 2, its largest gap is N, c_lo being 1 and c_ov N + 1: the bound max(2, t₁) is met.

At (0, 1), every hull tested exactly over t < 60, c_lo2 exceeds c_lo at 12 of the 24 cells, the second level lifting it past the one-level bar, c_lo rounded up to even at a constant quotient, at silver ×4 alone (2 to 3), and Z(c) fails at every c below c_lo2 at the six α and m = 2 … 9. c_saf = c_int at all 24, and c_int − c_lo2 is 0 at 6, 1 at 14 and 2 at 4 (golden ×5, silver ×5, √3 − 1 ×3, [2, 1, 3, 1] ×3): where c_lo2 > c_lo, 0 at 6 and 1 at 6; where c_lo2 = c_lo, 1 at 8 and 2 at 4, never 0, a pattern printed and not proved. At e − 2 and the random α, read to t < 110, c_lo ≤ c_lo2 ≤ c_ov(0, 1), with c_lo2 = c_ov at ×3 … ×5 of e − 2.

The pinned limit, read at the six α and m = 2 … 9 with the subtree's intervals exact, two periods of pin levels and L up to 14: c_L stops by L = 10, at c_inf, and the game's all-zero pre-read agrees, at all 48 cells. There c_inf = c_saf, a pattern printed and not proved: the zero cylinder alone is as hard as the whole game, so at the 24 grid cells, where c_saf = c_int, the integer reader's lookahead is read off the pinned subtree's geometry. At c_saf − 1 every pre-read loses, at all 48. c_inf at ×2 … ×9 is 3 5 5 6 6 7 7 7 at golden, 2 3 3 4 4 4 4 4 at silver and 2 2 3 3 3 3 3 4 at bronze.

The universal reader

Tier: rule (the finite game solved exhaustively at the cells below; c_int = 2 across a class where a quotient above s/(m − 1) recurs, a property, with the flush floor's theorem).
Verifier: flush.py::section_universal.

Over the alphabet {1, …, A} the lift game with the opponent choosing each quotient is one finite game, and a win is a reader that sees the quotients through a_(t+c+1) and nothing else of α, correct at every α with quotients at most A, the alphabet's class.

×2 at s = s₀ = 1 reads at exactly 2 over {1, 2} and over {1, 2, 3}. ×3 at s = s₀ = 1 reads at exactly 3 over {1, 2}, although all 472 purely periodic α of primitive period at most 8 in that class read it at 2: an opponent free to switch quotients costs one digit that no periodic α of period at most 8 charges. ×3 at s = s₀ = 2 reads at 2 over {1, 2}. With the flush floor the three wins at 2 pin c_int at exactly 2 at every α of their class, periodic or not, at which a quotient a with (m − 1)a > s recurs, a 2 or more at these slacks, as m a_(k+1) < q_(k−1) then holds at every deep such k; ×3 at s = s₀ = 1 over {1, 2} is left between 2 and 3. Each win is certified on every n < 500 at the class's constant α and twelve random ones. The reader is a tool: flush.py's Game(Source(alphabet = (1, 2, 3)), m = 2, s = 1, s0 = 1, look = 2), once its integer game is solved, reads a greedy string at any such α, given its quotients far enough, through its read method, which reports whether it ended.

Open fronts

Where c_int falls at E > 0 is open. At (0, 1) and a periodic α, c_lo2 ≤ c_inf ≤ c_saf ≤ c_int is proved; the script prints c_inf = c_saf at every cell read and c_saf = c_int at every grid cell: c_saf ≤ c_inf, why every pre-read shares the all-zero pre-read's threshold, is the first question, and c_int ≤ c_saf, the flush free at (0, 1), the second. The pinned states do not reach every pre-read: the states the winning ones reach by winning moves hold a branch of every pre-read, with its pending quotients and digits, period position and last-digit flag, at 31 of the 48 cells of m = 2 … 9 in the wide run (23 of the 24 at m ≤ 5, the default run; tie.py), and each of the 137 left over has a winning single lift no such play reaches; states shifted in g are untested. Toward the second, every pre-read reaches the branch (0, 0) with nothing pending by winning moves under zero input at all 48 of the wide run: the flush on inputs ending within the pre-read (tie.py). Whether a reader at c_inf carries every pre-read into a state holding a winning pinned state's branch is open, and the offset 0, on the seam between members 0 and 1 at every level at once, is the first place to look. That c_saf is 0 wherever c_lo is, printed at every cell of the grid, is not proved. At (1, 0) c_sr runs 1 to 5 above c_int at the grid's 24 cells, and no law found gives c_int there from α's quotients. On the α whose quotients are N + 1 ones and then 10⁸s, which of c_lo and c_ov is loose is open; a reader that defers its lift through the levels where |T_(t+1)| ≥ 1 is the probe.