READING — what a digit-by-digit reader computes
The object: a numeration, a digit system that writes the points of a complete metric space, the numeration's completion, as digit streams. Its depth-t tiles are the sets of points sharing a t-digit prefix. They nest, their mesh δ_t tends to 0, and their Lebesgue number ℓ_t is the largest ℓ such that every set of diameter below ℓ lies in one tile. A reader of a map f at lookahead c sees the input's tile at depth t + c and commits the output's tile at depth t, and its commitments nest into one output stream. c_min(f, t) is the least lookahead that works at depth t. This page prices readability by the tiles' shape, sorts maps into three classes by the Lipschitz criterion, decides the two integer maps n ↦ mn and n ↦ ⌊n/m⌋ on every divisor chain, and shows which place pays for a wall. The answer to the last is the archimedean place: the absolute digit tiles of every other completion of Q or F_q(x) are balls, on which no Lipschitz self-map of the unit ball walls, and on R's non-redundant interval tiles some map walls until redundancy is paid for. Below, rad(m) is the product of the primes dividing m.
NUMERATION COMPLETES TO TILES WHAT READS
base b, trailing the b-adic ring balls ⌊n/m⌋ iff
rad(m) ∣ rad(b)
divisor chain M_t its profinite ring balls m M_t ∣ M_(t+c),
depth by depth
primorial chain ∏ F_p balls never, from m's
least prime on
base x over F_q[x] F_q[[x]] balls ⌊n/m⌋ iff m = a x^j,
a constant
base b, leading R a partition y ↦ uy (u > 0) iff
1/u ∈ Z[1/b]
1/x-adic, F_q[x] F_q((1/x)) floating y ↦ uy, every u ≠ 0
d-bonacci, trailing an odometer (d = 2) balls ×2 and ⌊n/m⌋
or over a torus torn (no
continuous
extension) at
every
d; ×m at 99
of 99 pairs,
d ≤ 10, m ≤ 12
(by float
checks)
The reading lemma
Tier: theorem.
Verifier: proof; reading.py::section_l.
If f is L-Lipschitz, it is read at lookahead c at depth t once L δ_(t+c) < ℓ_t, provided the tiles chosen at successive depths nest, as ball tiles always do, and at tiles that are the closed balls of radius δ_t of an ultrametric once L δ_(t+c) ≤ δ_t, so where δ_(t+1) = δ_t/b the fit costs at most max(0, ⌈log_b L⌉) digits. A partition of a connected space into two tiles or more has ℓ_t = 0, the lemma says nothing, and readability is a question of alignment asked map by map. A cover by overlapping tiles, such as the closed tiles of the signed-digit cover, can have ℓ_t > 0 from the overlap, but a Lebesgue number alone does not make the next commitment a child of the last; that cover's own reader is proved in the next claim.
Proof. A depth-(t + c) tile has diameter at most δ_(t+c), so its image has diameter at most L δ_(t+c). Below ℓ_t it lies in one depth-t tile. In an ultrametric a set of diameter at most r lies in the closed ball of radius r about any of its points, so at ball tiles diameter δ_t is enough. Where the tiles nest, choosing that tile at each depth gives nested commitments, which is a reader.
At trailing base 10 the script prints c_min = 0 for 7n, 1 for ⌊n/2⌋ and 2 for ⌊n/4⌋ at depths 1 to 3, and no c ≤ 3 for ⌊n/3⌋.
Lipschitz walls on absolute tiles are archimedean
Tier: theorem.
Verifier: proof; reading.py::section_b.
A numeration is non-redundant when it writes each point by one stream, so its tiles partition the space (leading base b drops the streams ending in b − 1 repeated: its tiles are half-open). Call a point y a wall of a map f when the reader that commits at each step only what the input's tile forces commits at y a depth that stays bounded as the input depth grows. On the unit ball of any non-archimedean completion of Q or F_q(x) (Z_p, F_q[[x]], the ball of F_q((1/x))), with absolute tiles, fixed in position rather than moved with the point's valuation, the digit tiles are the closed balls of radius δ_t, so every L-Lipschitz self-map of the ball is read at lookahead max(0, ⌈log_g L⌉) at every depth, g the size of the residue field, and there are no walls. On a real interval every non-redundant numeration by interval tiles, finitely or countably many per depth, gives an affine self-map a wall. Redundancy reads past walls: on the signed-digit cover, whose children overlap so that a reader chooses rather than is forced, a reader reads every L-Lipschitz self-map of [−1, 1] at lookahead max(0, ⌈log₂ L⌉ + 1). So with absolute tiles the archimedean place charges nothing but the redundancy a numeration of R by interval tiles reading every Lipschitz self-map must carry, which every other place gets free, and the cover's bound is at most one digit past the bound the reading lemma gives Z₂. Q_p, which carries like R, pays nothing.
Proof. The first half is the reading lemma at ball tiles. For walls on R, take a tile endpoint v inside the interval at the first depth that splits it, a point y₀ that is no endpoint at any depth (the endpoints are countable), and f(y) = v + λ(y − y₀) with λ > 0 small enough to map the interval into itself. Every input tile holding y₀ holds it in its interior, so its image holds v in its interior and lies in no tile of v's depth: y₀ is a wall. Connectedness is why ℓ_t = 0: a positive Lebesgue number would make every tile open, and a connected space has no partition into two or more open sets, while the non-archimedean completions are totally disconnected. For the cure, give [−1, 1] signed binary digits, so a depth-t tile is [a − r, a + r] with r = 2^(−t) and its children are [a − r, a], [a − r/2, a + r/2] and [a, a + r]. An interval of length at most r/2 inside the tile lies in one child: in an end child if it misses a, in the middle one if it holds a. At lookahead c with 2^c ≥ 2L, suppose the tile committed at depth t holds the image of the input's depth-(t + c) tile, as [−1, 1] does at t = 0 for a self-map. The image of the input's depth-(t + 1 + c) tile lies inside that image, so inside the committed tile, and has length at most r/2, so it fits a child; committing that child keeps the hypothesis and the commitments nest.
The theorem is about absolute tiles. Read with the leading degree or exponent first, as a floating-point reader does, tiles scale with the point, and y ↦ y − 1, which cancels leading digits, reads at no bounded lookahead at any place: at the input 1 + x^(−N), or 1 + 10^(−N) in R, commits no output digit before the input's digit N positions below its lead is read. Scaling escapes this off R. At Q_p read from the valuation up, the first j digits of uy, u a unit, are fixed by the first j of y, multiplication by u being well defined mod p^j; at the 1/x-adic place the leading j digits of uy are fixed by the leading j digits of y for every u ≠ 0, since with no carries a lower term of y reaches only lower terms of uy. Over R the leading base-b reader of y ↦ uy, u > 0, walls unless 1/u ∈ Z[1/b] (the wall criterion; floating tiles have the same endpoints Z[1/b]).
At the 1/x-adic numeration of F_2((1/x)) (characteristic 2, no carries) the script finds multiplication and division by x + 1 and by x² + x + 1 fixing the leading j output digits from the leading j input digits at every j from 2 to 11, over every input of 12 digits. By hand, at leading base 10, 3 × 0.3…3 (k threes) is 1 − 10^(−k), so y ↦ 3y maps that tile onto [1 − 10^(−k), 1 + 2·10^(−k)), which holds 1 in its interior at every k, while y ↦ 2y maps the input tile [n, n + 1)·10^(−t−1) into one output tile of depth t, since 2n + 2 ≤ 10(⌊2n/10⌋ + 1) for every integer n: it reads at c = 1.
Two other prices of Z belong to the characteristic, not the place: the carries (SIZE: The F₂[x] control) and a bundle's capacity (BINDING: The characteristic cap). This one, the connectedness, belongs to the place.
The wall criterion
Tier: criterion.
Verifier: proof; reading.py::section_w.
Take a partition cover of a real interval whose tile endpoints B stay endpoints at every deeper depth, tiles half-open on the right, f continuous and strictly increasing, and y ∉ B. If f(y) ∉ B, the reader at y commits output to unbounded depth (it emits without bound). If f(y) ∈ B, its emission, the depth committed, freezes at a constant. So the walls of f are exactly f⁻¹(B) \ B. A decreasing f turns each half-open tile around, so an endpoint can wall too: when B = −B, negation maps a tile [v, v + h) of width h onto (−v − h, −v], meeting the tiles on both sides of the endpoint −v at every depth past −v's own, so it walls at every endpoint v.
Proof. y lies inside its tile at every depth. If f(y) ∉ B, then f(y) lies inside its output tile at every depth, and by continuity a fine enough input tile maps into it. If f(y) ∈ B, every input tile about y maps onto an interval with f(y) in its interior, and a tile of depth past the endpoint's own never holds both sides of it. At y ∈ B an increasing f maps [y, y + h) onto [f(y), f(y + h)), which fits one half-open tile, so the endpoints themselves never wall.
At leading base 10, B = Z[1/10] and y ↦ uy (u > 0) has walls B/u \ B, empty iff 1/u ∈ Z[1/10]. Conversely, if 1/u = k/10^c, the preimage of a depth-t tile endpoint is an endpoint at depth t + c, so no input tile of that depth maps across one, and lookahead c reads everywhere. So ×2 reads and ×3 walls at 1/3. For y ↦ y² the script prints emission frozen at 0 at √0.2 and √0.5, at −1 (not even the units digit) at √2 and √3, and growing as 19, 59, 119, 199 at input depths 20, 60, 120, 200 at √(1/3), and as 19, 59, 119, 200 at √(1/7).
The Lipschitz criterion
Tier: criterion.
Verifier: proof; reading.py::section_m.
On a trailing numeration at base b, f is read at lookahead c iff it is b^c-Lipschitz in the agreement ultrametric dist(y, z) = b^−(agreement depth). It is read at bounded lookahead iff it extends to a Lipschitz self-map of the completion. Continuity is weaker, and it splits the maps into three classes: LIPSCHITZ (bounded lookahead), MIDDLE (a continuous extension to the completion, with a lookahead finite at every depth and unbounded) and DISCONTINUOUS (no continuous extension: no lookahead at some depth). Continuity on the integers alone decides nothing, since they are discrete in the value metric and dense only in the agreement one. MIDDLE is inhabited: the decimation D(n) = Σ_(j≥0) n_(2j) 2^j at base 2, n_j the digit of n at position j, has c_min(D, t) = t − 1 exactly.
Proof. "Agreement to depth t + c forces image agreement to depth t" is dist(fy, fz) ≤ b^c dist(y, z), and a Lipschitz map on a dense subset of a complete space extends to it with the same constant. On a completion with finitely many tiles per depth, which is compact, continuity gives a modulus: image agreement to t from input agreement to s(t). Conversely a lookahead finite at every depth is such a modulus on the dense subset, so f is uniformly continuous there and extends continuously to the completion. Nothing forces s(t) ≤ t + c. D's output digits 0..t − 1 are input digits 0, 2, …, 2t − 2, so depth 2t − 1 suffices and depth 2t − 2 does not.
Metric, not topological: a map can be readable at every depth and still not at any bounded lookahead. Related: for rational word functions Choffrut's theorem (1977) makes co-sequential the same as Lipschitz for the suffix distance (Frougny–Sakarovitch, Combinatorics, Automata and Number Theory, 2010, Thm 2.6.13); that distance counts unmatched letters, not agreement depth. The script prints c_min(D, t) = 0, 1, …, 9 at t = 1..10.
The division criterion
Tier: criterion.
Verifier: proof; reading.py::section_r.
Let a trailing numeration's depth-t tiles be the classes n mod M_t of a divisor chain M_1 ∣ M_2 ∣ ⋯. Multiplication by m is 1-Lipschitz in the chain's agreement metric, since it keeps every agreement mod M_t. At a depth t with M_t ≥ 2, ⌊n/m⌋ is read at lookahead c iff m M_t ∣ M_(t+c).
Proof. If m M_t ∣ M_(t+c), n mod m is fixed by n mod M_(t+c), so inputs agreeing there have quotients differing by a multiple of M_(t+c)/m, which M_t divides. Conversely, inputs agreeing at depth t + c differ by a multiple of M = M_(t+c), so the one-step pairs (r, r + M) decide. As r runs over 0..m − 1 the difference ⌊(r + M)/m⌋ − ⌊r/m⌋ takes the value ⌊M/m⌋ and, when m ∤ M, also ⌊M/m⌋ + 1. Two consecutive integers are not both divisible by M_t ≥ 2, so m ∣ M is forced, and then the difference is M/m.
Three chains. At base b the condition is m ∣ b^c, and it holds at a bounded c at every depth iff rad(m) ∣ rad(b). At the factorial chain M_t = (t + 1)! it holds at every depth, at the least c with m ∣ (t + 2)⋯(t + c + 1), a lookahead that moves with the depth but never passes m, since m consecutive integers have a product divisible by m!: every floor division is LIPSCHITZ there (proved; the script does not scan this chain). At the primorial chain M_t = p_t#, the product of the first t primes p_1, …, p_t, the condition m p_t# ∣ p_(t+c)# holds iff m is squarefree with every prime in (p_t, p_(t+c)], so every m ≥ 2 fails at every depth from its least prime's index on. On the primorial completion, ∏ F_p (TOWER), every ⌊n/m⌋ with m ≥ 2 is DISCONTINUOUS: at depths 1 to 5, ⌊n/3⌋ reads only at depth 1, ⌊n/5⌋ at depths 1 and 2, and ⌊n/4⌋ at none. The script's brute search agrees with the divisibility at all 1142 (chain, m, t, c) it scans at bases 10 and 12 and the primorial chain. It runs the one-step reduction the proof uses, so it checks the floor arithmetic and not the reduction.
The division trichotomy
Tier: theorem.
Verifier: proof; reading.py::section_x.
On a divisor chain, ⌊n/m⌋ is LIPSCHITZ iff the least c with m M_t ∣ M_(t+c) is bounded over t, MIDDLE iff it is finite at every t and unbounded, and DISCONTINUOUS iff some depth has none. All three occur on one chain. At a fixed base the least c is constant in t, so that ⌊n/m⌋ never falls in MIDDLE is a fact about fixed-radix chains, not rings.
Proof. The division criterion, depth by depth, with the three classes of the Lipschitz criterion, whose compactness argument holds on the completion of any divisor chain, finitely many tiles per depth. For the example, take radix 2 at the depths that are powers of two and radix 3 elsewhere. Then M_(t+c)/M_t is the product of the radices at depths t + 1..t + c. For m = 2 the least c reaches the next power of two, c = 2^(⌊log₂ t⌋ + 1) − t, finite and unbounded. For m = 3 it is at most 2, since two consecutive depths from 2 on are never both powers of two. For m = 5 it never exists.
The script prints c_min(⌊n/2⌋, t) = 1, 2, 1, 4, 3, 2, 1, 8, 7, 6 at t = 1..10, with the largest value 32 over t ≤ 40. For ⌊n/4⌋ it prints finite values up to 96, for ⌊n/3⌋ at most 2, and ⌊n/5⌋ unread at all 40 depths.
Division over F_q[x]
Tier: criterion.
Verifier: proof; reading.py::section_r.
The same statement holds with polynomial division, for a chain with deg M_1 ≥ 1, where the integer proof takes M_t ≥ 2: ⌊n/m⌋, the quotient of n by m, is read at lookahead c at depth t iff m M_t ∣ M_(t+c). At base x it is read at bounded lookahead iff m is a constant times a power of x. The sufficiency proof above transfers, since the remainder has degree below deg m and so is fixed by n mod m. The necessity proof over Z does not, since the pairs (n, n + kM) are not chains of one-steps, but linearity replaces it. Division by m is F_q-linear, so with M = M_(t+c) the condition is that ⌊kM/m⌋ ∈ (M_t) for every polynomial k. If m ∤ M, write M = hm + s with s ≠ 0 of degree below deg m, and take k = x^(deg m − deg s): then ks has degree deg m, and ⌊kM/m⌋ = kh + a for a nonzero constant a. With h ∈ (M_t), from k = 1, a would lie in (M_t), which has no nonzero constants. So m ∣ M, the quotient of kM is kM/m, and k = 1 asks M_t ∣ M/m. The script's brute search, every input below a degree bound over F₂[x] grouped by its residue, at bases x and x(x + 1) with m of degree 1 to 3, agrees at 168 of 168 cases. The division criterion therefore reads the same over Z and over F_q[x], and so does its fixed-base form rad(m) ∣ rad(base).
The comb
Tier: theorem.
Verifier: proof; reading.py::section_c.
Take the trailing d-bonacci numeration, whose positional weights are q_k = q_(k−1) + ⋯ + q_(k−d), with q_j = 2^j for j < d, and whose greedy digits are exactly the strings with no d consecutive ones. At every d ≥ 2 the completion carries no continuous addition extending the integers', so it is not a topological ring extending them; d = 2 is Zeckendorf. Doubling walks a carry down: 2q_k = q_(k+1) + q_(k−d) for k ≥ d. So the comb T_K = q_d + q_(2d+1) + ⋯ + q_K, which steps by d + 1, doubles to a comb that steps by d, and the bottom of that comb cycles through d phases with period d(d + 1) in K. T_K and T_(K+d+1) agree to depth exactly K + d + 1, while their doubles differ at a digit ≤ d − 2, so ×2 has no continuous extension. At Zeckendorf the scan finds adding 1 read where doubling is not: the successor n + 1 has c_min = 1 at depths 1 to 8, scanned over n < 46368.
Proof. A string with no d consecutive ones sums below the next weight, one of its top d indices being absent, so it is its value's greedy expansion; conversely d ones at j, …, j − d + 1 sum to q_(j+1), so a greedy expansion has none. Write K = d + (d + 1)i′ and i = i′ mod d. The digits of 2T_K are the bottom {0, …, i} and the teeth j ≡ i + 1 mod d from d + 1 + i to K + 1 when i ≤ d − 2, and the teeth j ≡ 0 mod d from d to K + 1 when i = d − 1. The base is 2T_d = q_(d+1) + q_0. The step adds 2q_(K+d+1) = q_(K+d+2) + q_(K+1): the q_(K+1) doubles the top tooth, each doubled tooth j leaves q_(j+1) and doubles the tooth d below, so every tooth moves up one. At the bottom tooth the carry moves q_(i+1) down onto the bottom; at i = d − 2 the full bottom sums to q_d, a tooth, and at i = d − 1 the tooth d splits to q_(d+1) + q_0. Each result has its teeth d apart and a bottom run shorter than d below a gap, so it is canonical, and the d bottoms differ pairwise at a digit ≤ d − 2.
The script prints d patterns and period d(d + 1) at every d = 2..6, with the doubles of T_K and T_(K+d+1) first apart at a digit ≤ d − 2, the largest such digit d − 2 at each d, and reads the proof's phase sets off 112 doubles at d = 2..8, all matching. At Zeckendorf, 2n reads at no c ≤ 6 at depths 1 to 3, a check that the scan detects a discontinuity. Known on the completion's other side: the d-bonacci system is measurably conjugate to a translation of the (d − 1)-torus (at d = 3, Rauzy, Bull. Soc. Math. France 110, 1982, who states as Remarque 6.3 the conjugacy with the d = 3 completion; for every substitutive Arnoux–Rauzy sequence, Berthé, Jolivet and Siegel, Uniform Distribution Theory 7, 2012). The completion itself is totally disconnected and maps onto that torus (by φ below, its image compact and holding nα, dense as β has degree d): at d = 2 it is the Zeckendorf odometer (OSTROWSKI) over a circle rotation, and each d ≥ 3 sits over a torus translation. The group extending the integers' that the completion lacks exists in a coarser topology: Carton, Sudbery and Yassawi (arXiv:2606.30496, 2026) build the U-adic integers of every zero-preserving Pisot numeration U, U its sequence of positional weights, set the agreement topology aside, and project them onto a torus, isomorphically at Zeckendorf (Rittaud and Vivier had the Zeckendorf case, 2012, as they report); they find a ring "difficult" and prove no obstruction. The comb is the obstruction in the topology they set aside. That addition has no continuous extension at Zeckendorf is older: Barat, Berthé, Liardet and Thuswaldner (Ann. Inst. Fourier 56, 2006, Example 5.5) add (01)^∞ and (10)^∞ along two integer approximations and get two cluster points, saying the same holds for every Ostrowski numeration. The comb is sharper, one argument added to itself.
Floor division on the d-bonacci completion
Tier: theorem.
Verifier: proof; bonacci.py::section_f.
At every d ≥ 2 and m ≥ 2, ⌊n/m⌋ has no continuous extension to the d-bonacci completion. The proof reads the torus the completion sits over; β is the largest root of x^d − x^(d−1) − ⋯ − 1, a Pisot number, its other roots inside the unit circle (Brauer, Math. Nachr. 4, 1950). With α = (β⁻¹, …, β⁻⁽ᵈ⁻¹⁾) and ν_k = (q_(k−1), …, q_(k−d+1)), the recurrence run backward giving q_(−1) = 1 and q_j = 0 for −d < j ≤ −2, θ_k = q_k α − ν_k shrinks geometrically: each coordinate solves the recurrence and its β-part cancels. So φ(y) = Σ y_k θ_k mod Z^(d−1) is continuous on the completion, and φ(n) = nα. The inputs q_K tend to 0, and ⌊q_K/m⌋α = (θ_K + ν_K − r_K α)/m with r_K = q_K mod m. The state (q_K, …, q_(K−d+1)) mod m is purely periodic, the recurrence running backward mod m as its last coefficient is 1, and not constant, since it holds 2 beside 1 at K = d − 1. On a class γ of its period every cluster point of ⌊q_K/m⌋ maps to (ν_γ − r_γ α)/m, ν_γ and r_γ being the values of ν_K mod m and of r_K on γ, and two classes with different states give different points: where their r differ because β is irrational, where only ν differs because (ν_γ − ν_γ′)/m ∉ Z^(d−1). So ⌊n/m⌋ has at least two cluster values over the input 0. The circle case d = 2 is OSTROWSKI: Floor division is never MIDDLE here.
The fibre lemma
Tier: theorem.
Verifier: proof; fibre.py::section_p1; fibre.py::section_n.
A coding of a torus point z is a point y of the d-bonacci completion with φ(y) = z. (1) For every z ≠ −α, z and z + α have equally many codings. (2) 0 has the one coding 0; so every nα, n ≥ 0, has the one coding n, the codings of −α are the d limits of q_K − 1, one per residue of K mod d, and every −kα, k ≥ 1, has exactly d. (3) ×m has no continuous extension as soon as some z′ with one coding has mz′ with more than one. On P_m, the points (g − rα)/m, g ∈ Z^(d−1), this reads class by class: write κ for the class (r mod m, g mod m) and nκ for (nr mod m, ng mod m); ×n is torn as soon as some nonzero class κ has one coding and nκ has more, the zero class counting as more.
Proof. (1) The successor n ↦ n + 1 extends continuously to S: split n at position K into the part H above and L below; a run of d ones can form only across K, and rewriting its top d ones as the next weight touches positions from K − d + 1 up and cascades only upward, leaving fewer than d − 1 ones below, so the digits of n + 1 below K − d + 1 are those of L + 1, or all 0 when L + 1 = q_K (H then has a 0 at K, the top d − 1 digits of L being ones). So φ(Sy) = φ(y) + α, both sides continuous and equal on the dense integers, and S is onto, its compact image holding every n ≥ 1 and 0 = lim S(q_K − 1). The predecessor P, which turns the lowest 1 of x ≠ 0, at j, to 0 and writes the string of q_j − 1 below it, is continuous off 0 and undoes S on the integers, so P∘S is the identity on the open set U = S⁻¹(K_d ∖ {0}), where the integers are dense, and S is injective on U. S⁻¹(0) lies over −α. So for z ≠ −α the codings of z lie in U, and S carries them one to one onto those of z + α.
(2) The codings of z = (g − rα)/m are the infinite paths of a finite graph: lattice points s_k with s_(k+1) = M⁻¹(s_k − m y_k v_0), M the companion matrix of the weights and v_0 = (1, 1, 0, …, 0), started where (s_0)₁ = −r and (s_0)_(i+1) ≡ −g_i mod m and kept in a box: each contracting eigen-coordinate is m b_l times a legal tail's sum Σ y_(k+n) λ_l^n, λ_l a conjugate of β and b_l v_0's coordinate along it, and the β-coordinate obeys a bound the recursion keeps. A node is a state with its current run of ones. Two starts with infinite paths give different codings, and from one start each label sequence has one path, so z has one coding iff the graph's live part is a single path.
At m = 1 every cycle reads 0 at the state 0 or a rotation of 1^(d−1)0. With ι(ξ) = ξ(M)e₁, an isomorphism Z[β] → Z^d of Z[β]-modules, β acting as M (M^k e₁, k < d, is unitriangular), M^k v_0 = ι(β^(k+1)), so a closed walk of length p through s reading v_0 … v_(p−1) gives (M^p − I)s = −Σ v_k M^k v_0, and Z = Σ v_k β^k/(β^p − 1) = −ι⁻¹(s)/β lies in Z[β], β being a unit. Its digit string .v_(p−1) … v_0 v_(p−1) … has no d consecutive ones, so it is Z's greedy β-expansion unless a tail is (1^(d−1)0)^∞, the quasi-greedy expansion of 1 (W. Parry, Acta Math. Acad. Sci. Hungar. 11 (1960) 401–416). And β has property (F), every element of Z[β] ∩ [0, ∞) having a finite greedy expansion (C. Frougny and B. Solomyak, Ergodic Theory Dynam. Systems 12 (1992) 713–723, for x^d − a₁x^(d−1) − ⋯ − a_d with a₁ ≥ ⋯ ≥ a_d ≥ 1). So the string is 0, and then s = 0, M^p − I being invertible with no conjugate of the Pisot β on the unit circle, or a shift of (1^(d−1)0)^∞, and then s ≠ 0, as Z > 0. On a pattern the node's run of ones fixes the next label, and reading u^j, u the rotation of 1^(d−1)0 from that node and ψ(u) = Σ u_k β^k, s is −ι(βψ(u)/(β^d − 1)) whatever j, so the walk is back after d steps. The graph being deterministic, every strongly connected component of its live part that holds a cycle is that one cycle.
A coding y ≠ 0 of 0, lowest 1 at j, repeats a node at some k₁ < k₂ past j, and repeating the block between them gives a coding y′ of 0 with y′_j = 1 and a periodic tail. A zero block makes y′ an integer n ≥ 1, and φ(y′) = nα. A pattern block makes y′ agree, above a zero L of its pattern, with q_K − 1 for K ≡ L mod d, whose string has its zeros at the positions ≡ K mod d (the scaling certificate below), and read some P < q_L below L; so y′ = lim (q_K − r), r = q_L − P ≥ 1, and φ(y′) = −rα. Neither is 0, no nonzero multiple of α lying in Z^(d−1). So 0 has one coding, and by (1) along 0, α, 2α, … so has every nα. If Sy codes 0 then Sy = 0, so the codings of −α are S⁻¹(0). If Sy = 0, the prefixes n_i → y have n_i + 1 → 0, so the lowest 1 of n_i + 1 sits at j_i → ∞ and n_i = P(n_i + 1) carries q_(j_i) − 1's string below j_i, a function of j_i mod d; and each limit of q_K − 1 along a residue of K mod d maps to lim q_K = 0. By (1) every −kα has as many codings as −α, d.
(3) Let F extend ×m continuously, let z′ have the one coding y and z = mz′ the codings c ≠ c′. Write C_t(w) for the depth-t cylinder of w, the points sharing its t lowest digits. The depth-t tiles φ(C), C a cylinder of depth t, are finitely many closed sets covering the torus; V_t(w), the complement of the union of φ(C) over the depth-t cylinders C ≠ C_t(w), is open, and every coding of a point of it lies in C_t(w). Fix t and s. As z′ has one coding, z′ ∈ V_t(y); take a ball N about z′ inside it, of radius ε < 1/(2m), so that x ↦ mx maps N onto the ball of radius mε about z. For s′ ≥ s large φ(C_s′(c)) lies in that ball, and an integer n₀ ∈ C_s′(c) has n₀α with the one coding n₀, so n₀α ∈ V_s(c). The open set O of x ∈ N with mx ∈ V_s(c) is therefore not empty, and Kronecker's theorem (1, β⁻¹, …, β⁻⁽ᵈ⁻¹⁾ are rationally independent, β having degree d) gives an n ≥ 0 with nα ∈ O: then n ∈ C_t(y) and greedy(mn) ∈ C_s(c). The same holds for c′, so the closure of ×m's graph holds (y, c) and (y, c′), and F does not exist. For the classes: g ≡ g′ mod m gives the same point and z + α = (g − (r − m)α)/m, so a class is one α-orbit, −α = (0 − mα)/m in the zero class, and by (1) every point of a nonzero class has the same count. Take z in κ with r ≥ 1: nz lies in nκ, and in the zero class it is −(nr/m)α, which has d codings.
Scalings torn at one point
Tier: rule (each point's or class's read a finite check per pair,
d = 2..10, m = 2..12, in double precision, its margins chosen, not
derived; the families past m = 12 by E1 and E4, at the d read).
Verifier: fibre.py::section_f3; fibre.py::section_census;
fibre.py::section_short; fibre.py::section_preimage;
fibre.py::section_closure.
The first point is z′ = (e₁ − α)/m, e₁ the first unit vector, in the class (1, e₁) of P_m. Along K ≡ 0 mod the period of the state (q_K, …, q_(K−d+1)) mod m, the state is that of K = 0, (1, 1, 0, …, 0), so n_K = (q_K − 1)/m is an integer and n_Kα = (θ_K + ν_K − α)/m tends to z′, ν_K being (1, 0, …, 0) mod m. And mz′ = −α, which has d codings, so ×m is torn wherever z′ has one coding. Two consequences of the fibre lemma's (3) carry one read further. (E1) A singly coded nonzero class κ of P_m tears ×km for every k ≥ 1, mκ being the zero class. (E4) For n prime to m and a multiply coded nonzero class w, the class n⁻¹w depends on n only mod m: if it has one coding, every ×n′ with n′ ≡ n mod m is torn.
The script finds z′ with one coding at 76 of the 99 pairs d = 2..10, m = 2..12, with two at none; the other 23 meet the limit of 800000 nodes. The coding found is the certificate's limit of A_K (K ≡ 0 mod π, min(3π, 400) digits) at the 69 certified pairs read, and greedy(n_K)'s on 40 digits at the 75 whose state period is found below 5000. Where z′ is unread, other classes tear. A class's graph lies over its orbit under M mod m, s_(k+1) ≡ M⁻¹s_k mod m, and a class of short orbit has one coding at (7, 5), (7, 11), (8, 7), (8, 11), (10, 3), (10, 5) and (10, 7); a preimage n⁻¹w of a multiply coded w in P_m′ has one at (7, 7), m′ = 11, and at (8, 5), (9, 5) and (9, 11), m′ = 3. At m′ = 4, w = −σ, σ = (2, 3, 2, 0, …, 0), is multiply coded at every d ≥ 4 (periodic codings, below) and 3⁻¹w = σ singly coded at d = 4..10, and at d = 3, w = (1, 3, 3) is multiply and −w singly coded, so by E4 every ×n with n ≡ 3 mod 4 is torn at d = 3..10, (6, 11), (9, 7) and (10, 11) among them. By E1, F3 at (d, 2) tears every even n at d = 2..10, not only n ≤ 12, and the class at (10, 3) tears (10, 9). So ×m is torn at all 99 pairs. By E4 also every ×n with n ≡ 2 mod 3 is torn at d = 8 and 9, and n ≡ 5 or 7 mod 11 at d = 7; at d = 3 every ×n with n ≢ 1 mod 11 is torn (below).
The box is widened by 1e-7 on each polygon side and by a factor 1 + 10⁻⁹ on each bound, which only adds nodes.
Multiply coded classes
Tier: rule (verified d = 2, 3, m = 2..12; d = 4, m = 2..7; d = 5,
m = 2..4, in double precision).
Verifier: fibre.py::section_census.
A point of P_m off α's orbit can have several codings, so one coding at every point of P_m is not the route to every tear. Of the 12675 nonzero classes read, 371 are multiply coded, none at d = 2; 28, 54 and 289 at d = 3, 4, 5, a class of P_m′ counted again in every P_m, m′ | m. Each has 2, 3, 4, 5, 6 or 10 codings (live walks settled at 100 and 200), no branch node, and one live cycle but at five classes, which have two.
The multiply coded classes of each P_m read are a union of orbits of κ ↦ Mκ mod m, M the companion matrix, which sends (r, g) to (r + Σg, r, g₁, …, g_(d−2)), and the count is one per orbit: orbits of 1 to 12 classes, at (3, 11) one orbit of 10 with two codings each. Write T_d(m) for the residues n mod m with nκ multiply coded or zero for some singly coded κ; by the fibre lemma's (3), ×n is torn for every n ≥ 1 in them. At every pair read T_d(m) holds every non-unit of Z/m, and only them where no class is multiply coded. The units it holds are 3 at (3, 4), (4, 4) and (5, 4); 3 and 7 at (3, 8); 7 and 11 at (3, 12); 5 at (4, 6); and every unit but 1 at (3, 11), so at d = 3 every ×n with n ≢ 1 mod 11 is torn.
Periodic codings
Tier: theorem.
Verifier: proof; periodic.py::section_formal; periodic.py::section_exact;
periodic.py::section_controls.
Let V be a word of length P with no d consecutive ones read cyclically, ψ(V) = Σ v_k β^k and X_V = βψ(V)/(β^P − 1). If mX_V lies in Z[β], V^∞, with v_k at every position ≡ k mod P, codes the point (g − rα)/m of P_m with (r, g) = ι(mX_V), r exactly, not mod m. So two such words V, V′ code one point iff X_V − X_V′ lies in Z[β] with first ι coordinate 0. At m = 4 the class −σ = (2, 1, 2, 0, …, 0) is multiply coded at every d ≥ 4, σ being (2, 3, 2, 0, …, 0) = ι(1 + β + 2β²) mod 4.
Proof. M^k v_0 = ι(β^(k+1)) (the fibre lemma's (2)), so the states of V^∞ return after P steps iff (M^P − I)s_0 = −ι(mβψ(V)), solved by the lattice point s_0 = −ι(mX_V); from it they repeat, so they stay bounded. A bounded state sequence from a start of z lies in z's box, each contracting eigen-coordinate being m b_l times its tail sum (M⁻¹ expands any other value) and the β-coordinate within the bound the recursion keeps, so it is an infinite path of z's graph, a coding. Points (g − rα)/m and (g′ − r′α)/m agree iff r = r′ and g ≡ g′ mod m, 1 and α's coordinates being rationally independent. The words, low digit first: U = 00 1^(d−1) 0^(d−2) 1 00 and W = 0 1^(d−2) 0 11 0 1^(d−4) 00 1, A = UW, B = WU, period 4d + 4, and S = 1 0^(d+1) 1^(d−3) 0 1 0, period 2d + 2. Their runs of ones are 1^(d−1), 1, 1^(d−2), 11, 1^(d−4), 1 and 1, 1^(d−3), 1, apart at every join, so they are legal at every d ≥ 4, and A^∞ ≠ B^∞, U and W differing at their second digit. In Q(β), β^d = 1/(2 − β), x^(d+1) − 2x^d + 1 being (x − 1) times the d-bonacci polynomial; the runs having lengths affine in d, tψ(V) − X(t^P − 1) at t^d = 1/(2 − t) is a rational function of t alone, with poles at 1 and 2 only, and it is 0 for X_A = (2β² − β − 1)/4, X_B = (−2β² + 3β + 3)/4 and X_S = (2β² − 3β + 1)/4. With ι(β) = e₁ + e₂ and ι(β²) = 2e₁ + e₂ + e₃, ι(4X_A) = (2, 1, 2, 0, …, 0), ι(4X_B) = (2, 1, −2, 0, …, 0), the same point of −σ, X_A − X_B = β² − β − 1 = ι⁻¹(e₃), and ι(4X_S) = (2, −1, 2, 0, …, 0), a point of σ.
The script checks the identity in t symbolically, the words exactly in Q(β) at d = 4..40, and that the float graphs at d = 4..10 read A^∞ and B^∞ as −σ's only codings and S^∞ as σ's only one.
Pairs of codings
Tier: theorem.
Verifier: proof; pairs.py::section_k.
Let y code a point z of P_m and let y′ be legal, δ = y − y′. Then y′ codes z iff some bounded integer sequence x, a carry sequence, has
δ_t = x_t − (x_(t+1) + ⋯ + x_(t+d)) at every t ≥ 0, x_0 + ⋯ + x_(d−1) = 0.
So y − y′ is Σ_j x_j (e_j − e_(j−1) − ⋯ − e_(j−d)), positions below 0 dropped: the carry 0^d 1 ↔ 1^d 0, q_j = q_(j−1) + ⋯ + q_(j−d), applied x_j times at j. Its windows W_t = (x_t, …, x_(t+d−1)) step by a shift, x_(t+d) = 2x_t − ΣW_t − δ_t and ΣW_(t+1) = x_t − δ_t, and m is gone. Every nonzero w ∈ {−1, 0, 1}^d with Σw = 0 starts a pair: y = [w = 1]^∞ and y′ = [w = −1]^∞, w_k at the positions ≡ k − 1 mod d, code one point, which lies in P_m for m = d − 1. Such windows number the central trinomial coefficient, the coefficient of x^d in (1 + x + x²)^d, less one: 6, 18, 50, 140, 392, 1106 at d = 3..8.
Proof. By the fibre lemma's (2), y and y′ code z iff they label bounded paths s_k, s′_k from starts with equal first coordinate and the rest equal mod m. Then E_k = (s_k − s′_k)/m is integral and bounded, its first coordinate 0 at k = 0, and E_(k+1) = M⁻¹(E_k − δ_k v_0), where M⁻¹ sends (c₁, …, c_d) to (c₂, …, c_d, c₁ − c₂ − ⋯ − c_d). In w = (E₂, …, E_d, E₁ − E₂ − ⋯ − E_d), an integral bijection with inverse E = (Σw, w₁, …, w_(d−1)), the step is w ↦ (w₂, …, w_d, 2w₁ − Σw − δ), so the w at time k is the window W_k of one sequence x, ΣW_(t+1) = x_t − δ_t is the displayed relation, and ΣW₀ = (E₀)₁ = 0. Conversely, from bounded carries put s′_k = s_k − mE_k: it obeys y′'s recursion, stays bounded, and starts at a start of z, so it lies in z's box (periodic codings) and y′ codes z. For the windows, x_t = w_(1 + t mod d) has δ_t = x_t, as every window sums to 0, and y, y′ are legal, w holding both signs. y has period d, (β^d − 1)⁻¹ lies in (d − 1)⁻¹Z[β] by the resultant of the d-bonacci polynomial and x^d − 1, which is ±(d − 1), the polynomial taking 1 at each d-th root of unity other than 1 and 1 − d at 1, so mX_y lies in Z[β] and y codes a point of P_m (periodic codings), which y′ codes too.
The triangle wave
Tier: theorem.
Verifier: proof; pairs.py::section_wave.
At every d ≥ 5 some pair of codings has a carry of size a = ⌊(d − 1)/4⌋, so no bound on the carries holds at every d. Let x have period P = d − 1, climb 0 → a by steps of 1, fall a → −a, climb −a → 0 and rest at 0 for P − 4a steps. Then
y = (0^a 1^(2a) 0^(P−3a))^∞, y′ = (1^a 0^(2a) 1^a 0^(P−4a))^∞
code one point of some P_m with carry sequence x: at d = 13, (000111111000)^∞ and (111000000111)^∞, carries reaching 3.
Proof. As x_(t+d) = x_(t+1), the window sum x_(t+1) + ⋯ + x_(t+d) is the period's sum S plus x_(t+1), so δ_t = x_t − x_(t+1) − S. The moving part has x_(t+2a) = −x_t, so S = 0 and δ_t = x_t − x_(t+1), in {−1, 0, 1}; y = [δ = 1] and y′ = [δ = −1] are the words above, their runs at most 2a < d, cyclically too, so both are legal. The first window sums to S + x_0 = 0, so by the pair theorem y′ codes the point y codes, which lies in some P_m, y being periodic (periodic codings). The script reads each wave at d = 5..30 against the periodic-codings criterion, its largest carry a (7 at d = 30); at d = 10 the prefix difference D_n of (001111000)^∞ and (110000110)^∞ puts D_nα within 5·10⁻²³ of Z⁹ at n = 1600, against 0.5 for D_n + 1.
The real support
Tier: theorem.
Verifier: proof; real_support.py::section_control;
classes.py::section_control; heat.py::section_sup.
Every carry is a linear form in δ. Write the carry relation as δ = Δ(F)x, Δ(z) = 1 − z − ⋯ − z^d, F the shift (Fx)_t = x_(t+1). The roots of Δ are ρ₀ = 1/β inside the unit circle and ρ₁, …, ρ_(d−1), the inverses of the other d-bonacci roots, outside it, all simple, so 1/Δ = Σ_j c_j/(1 − z/ρ_j), c_j = −1/(ρ_jΔ′(ρ_j)), expands on the unit circle as h(z) = Σ_m h_m z^m with
h_m = Σ_(j≥1) c_j ρ_j^(−m) (m ≥ 0), h_m = −c₀β^m (m < 0),
and L(d) = Σ_m |h_m| is finite. Every bounded real x on t ≥ 0 with δ = Δ(F)x bounded and first window sum 0 is then
x_t = Σ_(k≥0) g^(t)_k δ_k, g^(t)_k = h_(k−t) − ε_t h_(k+1), ε_t = β^(−t)/B, B = 1 + β^(−1) + ⋯ + β^(−(d−1)),
so a carry of a pair of codings, or of any bounded path with δ in {−1, 0, 1} and first window sum 0, has |x_t| ≤ ‖g^(t)‖₁, and its window sum x_(t+1) + ⋯ + x_(t+d) = x_t − δ_t has size at most ‖g^(t) − e_t‖₁.
Proof. x^p_t = Σ_(k≥0) h_(k−t)δ_k is bounded by L·sup|δ| and solves every equation, the coefficient of z^(k−t) in Δ(z)h(z) = 1 being 1 at k = t and 0 elsewhere. The bounded solutions of Δ(F)x = 0 on t ≥ 0 are the cβ^(−t), 1/β being the one root in the closed unit disc, so x = x^p + cβ^(−t), and x₀ + ⋯ + x_(d−1) = 0 fixes c = −(x^p₀ + ⋯ + x^p_(d−1))/B. The window sum of h is one term: the coefficient of z^n in Δ(z)h(z) = 1 gives h_(n−1) + ⋯ + h_(n−d) = h_n − [n = 0], so x^p₀ + ⋯ + x^p_(d−1) = Σ_k h_(k+1)δ_k, the second term of g^(t). real_support.py recomputes the triangle wave's x from g^(t) at d = 9, 13, 21 to 2·10⁻¹⁴, and heat.py reads the identity to 1.6·10⁻¹⁵ at d = 13, 40, 100. As g^(t)_k = (1 − ε_t)h_(k−t) + ε_t(h_(k−t) − h_(k+1)) with 0 < ε_t ≤ 1,
‖g^(t)‖₁ ≤ (1 − ε_t)L + ε_t D_(t+1), D_s = Σ_m |h_m − h_(m+s)|,
and ‖g^(t) − e_t‖₁ ≤ (1 − ε_t)L_s + ε_t(D_(t+1) + 1), L_s = L − |h₀| + |h₀ − 1|, the row at k = t holding h₀ − 1.
Summed over a class mod P = d − 1, h is a sawtooth:
H_r = Σ_(m ≡ r mod P) h_m = ((P − 1)/2 − r)/P − 1/P², r = 0, …, P − 1,
so L = W + E, W = Σ_r |H_r| = P/4 at even P and (P² − 1)/(4P) + 1/P² at odd P, at most (d − 1)/4 at every d ≥ 3 but d = 4 (W = 7/9), and E = Σ_m (|h_m| − s_m h_m) ≥ 0, s_m the sign of H_r on m's class. Proof. h converges absolutely on |z| = 1, so with w = e^(2πi/P), Σ_r H_r w^(kr) = h(w^k) = 1/Δ(w^k). At k = 0 that is 1/Δ(1) = −1/P. At 0 < k < P the w^(kj), j = 1, …, P, sum to 0 and w^(kd) = w^k, so Δ(w^k) = 1 − w^k, while Σ_r r z^r = P/(z − 1) at z^P = 1, z ≠ 1, makes the sawtooth's transform 1/(1 − w^k); the constant −1/P² carries k = 0 alone. A sign change of H falls between r = P − 1 and 0 and at r = (P − 1)/2, whose class at odd P is negative, so W sums two arithmetic runs. classes.py reads the sawtooth to 6·10⁻¹⁴ and W to 1.2·10⁻¹² at d = 3..100.
The walk
Tier: theorem.
Verifier: proof; edge.py::section_control; edge.py::section_edge;
remainder.py::section_edge.
As 1/Δ(z) = (1 − z)/(1 − 2z + z^(d+1)), h_m = (G_m − G_(m+1))/2, G the Green's function of the walk with steps −1 and +d, each of probability 1/2: Σ G_m z^m converges on 1/β < |z| < 1, not on the circle (G_m tends to 2/P), and there (1 − z)G(z) = −2z/Δ(z), so the (G_m − G_(m+1))/2 are 1/Δ's coefficients on the annulus, which are h's, Δ having no root with 1/β < |z| ≤ 1. And G is a binomial series. A path of n steps with u up-steps ends at u(d + 1) − n, so it reaches m in n_u = u(P + 2) − m steps, and with b(u, n) = C(n, u)2^(−n),
h_m = [m = 0]/2 + Σ_u T_u(m), T_u(m) = b(u, n_u)(m − uP)/(2n_u),
over the u ≥ 0 with n_u ≥ max(u, 1). Proof. G_m = Σ_u b(u, n_u), and G_(m+1)'s term at u takes n_u − 1 steps; C(n − 1, u) = C(n, u)(n − u)/n gives b(u, n) − b(u, n − 1) = b(u, n)(2u − n)/n, and 2u − n_u = m − uP. The path of no steps, at m = u = 0, has no partner and gives the 1/2. At m = 0 the series reads 1 − 2h₀ = (P/(P + 2))Σ_(u≥1) b(u, u(P + 2)), about P2^(−(P+2)), its u = 1 term.
Each T_u is a bump with the sign of j = m − uP, and j ≡ m (mod P). The sawtooth's sign s (the real support) is + on the classes r < (P − 1)/2 and − above, and at r = (P − 1)/2 at odd P, so T_u carries s's sign at j in [−(P + 1)/2, (P − 1)/2) and the wrong one only where |j| ≥ (P − 1)/2. Per m, |h_m| − s_m h_m ≤ Σ_u (|T_u| − s_m T_u), so E's part over any range of m is at most
Ē = Σ b(u, n_u)|j|/n_u,
over that range's wrong-signed terms: single bumps' tails, no cancellation used. edge.py reads the series against the root sum to 3.3·10⁻¹⁶, 4.4·10⁻¹⁶, 9.2·10⁻¹⁶ over m in [−80, 40P] at d = 13, 40, 100, and 1 − 2h₀ = 7.336·10⁻⁴ against P2^(−(P+2)) = 7.324·10⁻⁴ at d = 13. Below m₁ = P³/400, the heat flow's τ < 1/400, Ē is tight: E there is 7.070·10⁻⁷, 1.503·10⁻⁸, 9.835·10⁻¹⁰ at d = 100, 200, 400, and Ē 7.070·10⁻⁷, 1.504·10⁻⁸, 9.931·10⁻¹⁰, summed over the j with j²/(2n) below about 64.
Ē has a closed bound below every m₁ = P³/c. The term b(u, n)|j|/n is the chance that the walk of ±1 steps first reaches |j| at step n (the hitting time theorem, as S_n = 2u − n = j). At fixed j the m = j + uP < m₁ take distinct n = 2u − j ≤ N = A + B|j|, A = 2m₁/P, B = 1 + 2/P, so their wrong-signed terms sum to at most the chance of reaching |j| by step N, at most 2e^(−j²/(2N)) (reflection, Hoeffding). With g(a) = a²/(2(A + Ba)), convex, and J₀ = ⌈(P − 1)/2⌉ the least wrong-signed |j|, the two signs of j summed geometrically give
Ē ≤ F = 4e^(−g(J₀))/(1 − e^(−g′(J₀))),
7.000·10⁻⁵, 1.195·10⁻⁶, 5.651·10⁻⁸ at c = 400, d = 100, 200, 400 (remainder.py). As g(J₀) → c/16 and g′(J₀) ~ c/(4P), F ~ (16P/c)e^(−c/16) at fixed c, the ratio 1.0000 at P = 10⁸: at c = 400 that reaches 0.01 at P near 1.8·10¹⁰, and past it c must grow like 16 ln P.
The heat flow
Tier: pattern (P E read at d = 199..202, 399..402; the limit derived to
first order in 1/P, the expansion not proved).
Verifier: heat.py::section_control; heat.py::section_local;
heat.py::section_constant.
Read by classes mod P, h is the sawtooth under the heat flow, and P E tends to one constant per parity of P: about 4.4570 at even P, 4.7070 at odd. For m ≥ 0, h_m = Σ_k c_k x_k^m over the P roots of x^d(x − 2) = −1 inside the unit disc, c = (x − 1)/((d + 1)x − 2d), x_k near e^(iθ_k), θ_k = 2πk/P, for k small against P. At x = e^λ, λ = iθ_k + μ, the root equation is exactly e^(Pμ) = 1/(1 − (1 − e^λ)²), so Pμ = −θ² − iθ³ + O(θ⁴, θ³/P), and at m = qP + r, with x = r/P and τ = m/P³, to first order in 1/P
h_m ≈ −P^(−2)[∂_x + (3/(2P))∂_x² + (τ/P)∂_x⁴] K(x, τ),
K the periodic heat kernel, K_τ = K_xx. The leading term's zeros, x₀ = 0 and 1/2, are the sawtooth's sign changes; the correction moves each by z(τ) = −3/2 − τK_xxxx/K_xx classes, and E is twice the mass of h on the classes it carries across the class sums' sign:
P E → C = 2∫₀^∞ Σ_(x₀) |K_xx(x₀, τ)| Φ(z(τ)) dτ,
Φ(z) the sum of |j − z| over the lattice points j strictly between the class sums' sign change s and z. At x₀ = 0 the lattice is Z and s = −1/2; at x₀ = 1/2 the same at even P, and at odd P the lattice is Z + 1/2 and s = −1, the class at (P − 1)/2 being negative. The script finds C = 1.5211 + 2.9359 at even P and 1.5211 + 3.1859 at odd P, the two terms from x₀ = 0 and 1/2; the root sum gives P E = 4.49904, 4.74645, 4.49883, 4.74625 at d = 399..402, and C + a/P fitted per parity to d = 199, 399 and 201, 401 gives 4.4571 (a = 16.68), to 200, 400 and 202, 402 4.7071 (a = 15.68, 15.69). Locally, the zero near r = 0 lies within 0.001, 0.005, 0.033, 0.091 classes of z(τ) at τ = 0.02, 0.05, 0.1, 0.2, at d = 100 and 101. The expansion is in θ small; at m of order P, where every order is O(1), it is unread, and the walk is exact there.
The parity gap is 1/4 from one kink, plus 1.5·10⁻⁵. At x₀ = 1/2, g(τ) = K_xx is positive with ∫g dτ = 1 and ∫τg′ dτ = −1, so ∫g(z − j) dτ = −(j + 1/2), and C at x₀ = 1/2 is twice Σ_(j in the lattice) Ψ(j), Ψ(j) = F(j) − (−j − 1/2)^+, F(j) = ∫g(z − j)^+ dτ, one Ψ at both parities. By Poisson, the sum over Z + 1/2 less the sum over Z is −2Σ_(n odd) Ψ̂(n), n over the odd integers of both signs. The kink of −(−j − 1/2)^+ at −1/2 gives Ψ̂(n) = −1/(4π²n²) at odd n, summing to −1/16, so C_odd − C_even = 1/4 − 4Σ_(n odd) F̂(n), F″ the density of z under g. The script's quadrature reads the gap as 0.2500150.
The carry bound
Tier: rule (verified d = 3..400, at d = 11, 12, 16, 20 by a
floating-point solver, past 100 by floating-point sums; σ's one coding
at d = 4..10).
Verifier: real_support.py::section_h; real_support.py::section_h3;
route.py::section_control; route.py::section_past;
integral.py::section_control; integral.py::section_f;
pairs.py::section_g; pairs.py::section_k; pairs.py::main.
At every d = 3..400 the largest carry and window sum over every pair of codings of a point of every P_m is C_d = max(1, ⌊(d − 1)/4⌋), attained at each d, from d = 5 by the triangle wave and at d = 3, 4 by the windows that start a pair. Three routes read it, and none assumes a bound on the carries.
By the real support a carry is at most H_x(d) = sup_t ‖g^(t)‖₁ and a window sum at most H_s(d) = sup_t ‖g^(t) − e_t‖₁, so ⌊H_x⌋, ⌊H_s⌋ ≤ C_d proves the bound at d, for every bounded path with δ in {−1, 0, 1} and first window sum 0, legal or not. The script reads h by the roots at d = 3..40 and by a discrete Fourier transform of 1/Δ at d = 21..100, agreeing to 9·10⁻¹³, and the sups at t < 81; past 81 each norm is at most its limit, L or L_s (the real support), plus 10⁻²¹dL, both limits at most the sups read, to 10⁻¹². This proves the bound at d = 3, 4, 9, 10, 13..15, 17..19 and 21..100, the least margin C_d + 1 − max(H_x, H_s) 0.0053 at d = 3 (H_s = 1.9947) and, past 20, 0.0237 at d = 24. At d = 5..8, 11, 12, 16 and 20 max(H_x, H_s) passes C_d + 1, at 2.06, 2.18, 2.32, 2.49, 3.04, 3.24, 4.11 and 5.03, and the bound needs the carries' integrality, which the third route reads at d = 5..8 and the second at 11, 12, 16 and 20.
Past 100 the first route bounds the sups by the shift norms, never reading them whole: ‖g^(t)‖₁ ≤ (1 − ε_t)L + ε_t D_(t+1) at t < 64 and ≤ L + ε₆₄L past, the window sums alike with L_s and D + 1 and past 64 ≤ L_s + ε₆₄(2L + 1) (the real support), D_s read at s ≤ 16 and above by D_(a+b) ≤ D_a + D_b and D ≤ 2L, a property. h is summed by its roots over m from −80d to P³, the tails beyond priced. Every d = 101..400 closes, the least margin 0.2038 at d = 104 and by d ≡ 0, 1, 2, 3 mod 4 0.2038, 0.9521, 0.7027, 0.4533, at d = 104, 101, 102, 103; the excess over L falls at every step, from 1.6·10⁻³ to 7.4·10⁻⁹. The shift norms are loose at small d, B_x − H_x 0.15 at d = 24, which they leave open, so to 100 the sups are read whole.
The second route puts integrality back near t on top of the real support: problems in integers ask for a carry or a window sum of C_d + 1 at t, δ integral at t − 5, …, t + 10d − 1 (at 0, …, 10d − 1 when t < 5) and real further, x integral in |x| ≤ ⌊H_x⌋ with the carry relation inside that window, the mass of each row outside its columns a slack. Taken relative to t, one problem covers every t ≥ 5, g^(t)'s β^(−t) term entering as β^(−u)w with w one real unknown, |w| ≤ β^(−5)dL/B; one per t < 5 reads g^(t) with the first window sum 0. All are infeasible, so the bound holds at the four d for every bounded integer path with δ in {−1, 0, 1} and first window sum 0, legal or not; at d = 13, target 3, every kind (t ≥ 5, carry and sum; t = 3, carry; t = 2, sum) is feasible, the wave a point of each. Integrality refutes what the reals admit: at d = 11 the problem for every t ≥ 5 at carry 3 is feasible over the reals. The verdicts are HiGHS's, in floating point, with no exact certificate.
The third route reads the pair graph, nodes (w, a, a′), a and a′ the current runs of ones of y and y′, built over the E the fibre lemma's (2) allows, which no m enters. A breadth-first search from the starts, each step kept inside that box, gives its live part: 33, 130, 463, 1566, 5117, 16402, 67875, 215218 nodes at d = 3..10, with largest carry and window sum C_d. At d = 3..8 it is the carry graph's, the windows in {−1, 0, 1}^d of sum in {−1, 0, 1} with the legal steps, reachable from the zero-sum windows and with an infinite continuation; the step with δ's sign flipped misses it by 30, 126, 458 nodes at d = 3, 4, 5. So at d = 3..8 every start of a pair lies in {−1, 0, 1}^d, and the pair theorem gives the converse.
Legality is not what holds the carries: with δ free in {−1, 0, 1}, the box holding every such bounded path from a start, the live windows reachable from the zero-sum ones are, at d = 3..8, the carry graph's and ±e₁ alone, e₁ the finite carry 0^d 1 ↔ 1^d 0, which needs d ones in a row, and at d = 9, 10 their largest carry is 2 as well.
On the pair graph's live part S^∞ has no second coding at d = 4..10, so σ is singly coded there, and A^∞ is paired from the start E₀ = −e₃.
The scaling certificate
Tier: rule (proved per pair at 47 pairs, d ≤ 10, m ≤ 12).
Verifier: bonacci.py::section_v; bonacci.py::section_w;
bonacci.py::section_x.
At d ≥ 3 the comb's identity gives 3q_k the greedy string q_(k+1) + q_k + q_(k−d), which keeps a copy at k; 1/m's expansion in base β tears ×m pair by pair instead, by digits alone, with neither the torus nor the fibre lemma. Let W be a purely periodic word with period π and no d consecutive ones, read cyclically, and let A_K = Σ_(1≤i≤K) w_i q_(K−i) be W written downward from position K − 1. Its string is greedy, and on a class K ≡ γ mod π its low digits do not move, so A_K converges. With Δ as in the real support and R(z) = Σ_(i≤π) w_i z^i, the error e_K = q_K − mA_K has generating function (1 + z + ⋯ + z^(d−1))(1 − z^π − mR)/(Δ(1 − z^π)). When Δ divides 1 − z^π − mR, which says that Σ_(i≥1) w_i β^(−i) = 1/m (Δ is irreducible, its reversal having β as its one root off the unit disc), e_K is purely periodic with period π, the quotient's numerator having degree π − 1, with one value e_γ on each class K ≡ γ mod π. The string of q_K − r (r ≥ 1) has its zeros exactly at the positions ≡ K mod d down to the least such J with q_J ≥ r, and q_J − r's greedy string below that: q_K − 1 = q_(K−1) + ⋯ + q_(K−d+1) + (q_(K−d) − 1) has those zeros, and q_J − r < q_J below J keeps the 0 at J, a legal, so greedy, string (checked where q_(K−d) > r, d = 2..8, r = 1..12, K ≤ 80). So it has d limits, one per residue of K. The class of 0 has e_0 = q_0 = 1, and meets two residues mod d when d ∤ π: there A_K converges while mA_K = q_K − 1 does not, and ×m has no continuous extension. The divisibility is a finite check, so each pair it passes with d ∤ π is proved torn.
At m = 2 the word is 0 1^(d−1) 0 at every d, since (1 + z)Δ = 1 − z^(d+1) − 2(z² + ⋯ + z^d). So e = 1, 2, …, 2, 1 over period d + 1, and every class decides: a second proof that ×2 is torn at every d, independent of the comb. At m = 3 the word is certified and decides at d = 3, 4, 5, 6, 9; at d = 3 it is 0100010110000. At d = 2, 7 and 8 it is certified with period 8, 364 and 80, which d divides, so each class sits in one residue and the certificate decides nothing. At d = 10 no word with period below 1200 was found. Of the 99 pairs d = 2..10, m = 2..12, 23 are certified and undecided and 29 have no word found. The word's period equals the state's period mod m at all 70 certificates. That the state's period divides it is proved, since e_K ≡ q_K mod m; the converse is observed.
Open fronts
Which class ×m falls in on a d-bonacci completion. Floor division and ×2 are DISCONTINUOUS at every d, and ×m is torn at all 99 pairs d = 2..10, m = 2..12. At d = 2 every ×m, m ≥ 2, is DISCONTINUOUS (OSTROWSKI: The affine maps). Open, at d ≥ 3: every m ≥ 3 at d ≥ 11, and beyond m ≤ 12 every m outside the multiples and residue classes E1 and E4 tear. An unread pair is open, not continuous. The class σ of P_4 is read singly coded only at d = 4..10, outright there (the carry bound); with its one coding at every d ≥ 4, −σ's multiple coding being proved, every ×n with n ≡ 3 mod 4 would be torn at every d ≥ 4. The carries grow with d (the triangle wave), so no window graph bounded uniformly in d reads it. Whether max(1, ⌊(d − 1)/4⌋) bounds every carry is open past 400 (the carry bound); at each d where it holds, the bound makes the pair graph's live part the legal graph's over the windows in [−C, C]^d at that C. The real support's margin at d ≡ 0 mod 4, d ≥ 8, is 1/4 + 1/(4P) − 1/P² − E less the larger sup's excess over L, H_x's at most sup_t ε_t(D_(t+1) − L)^+ and H_s's at most L_s − L + sup_t ε_t(D_(t+1) + 1 − L_s)^+ (the real support), and P E tends to about 4.46 and 4.71 by parity (the heat flow, a pattern); at d = 40, 60, 100, 96 to 97% of E lies within 3 classes of the sawtooth's two sign changes (classes.py, an observation). Below m₁ = P³/c, E ≤ Ē ≤ F, 5.7·10⁻⁸ at c = d = 400 (the walk); past m₁, |h| − sh ≤ (|φ| − sφ) + 2|h − φ|, zero where sh > 0, so E there is at most R, that sum over the m with sφ ≤ |h − φ|, φ = −P^(−2)K_x the heat flow's leading term. With h known, R is 0.0498 at d = 400 and P R is 27.3, 24.2, 19.9 at d = 100, 200, 400 (edge.py); with |h − φ| bounded per term (the walk's images against φ's below τ = 1/4, the roots against its Fourier modes from 1/64, the smaller kept), R is 0.04988 at d = 400, within 0.23% (remainder.py; both observations at fixed P, roots and binomials in floating point). Per-term majorants that hold for every P ≥ 399 at once, |φ_k|A(ξ, τ)/P per image (Stirling with Robbins' bracket) and env_k A_k(τ)/P per mode (the root by contraction), dominate the 30-digit errors at d = 400, 800 and 1600, largest ratios 0.9991 and 0.9761 at d = 400, and in R's place leave R + F = 0.0635 at d = 400 (majorant.py, an observation). Read at ten odd P from 399 to 1.8·10¹⁰, R + F is largest at 399 and below 0.06352 at each, P R near 20.71 past 10⁴, once the cut past P³ moves to T(P)P³, T = 1 + ln(P/399)/(2π²), the tail past P³ growing like P², and the images run to K of order √(ln P) (uniform.py, an observation on that grid, even P unread). The larger excess is at most X = (L_s − L) + ε_t₁ min(2L + 1 − L_s, (2/β)D₁⁺), t₁ = ⌊(L_s − 1)/D₁⁺⌋, β the root of x^d(x − 2) = −1 in (1, 2), D₁⁺ any bound on h's total variation D₁ = Σ|h_m − h_(m+1)|; D₁ − 0.968 ln P lies in [0.7778, 0.7790] (2κ = 0.96788, κ = 2/√(2πe); excess.py, an observation at d = 101, 110 to 400 by tens, and 800). One D₁⁺ serves every P ≥ 399 at once: the edge 1.5 + (2/3)^d; each bump of the walk, its variation exactly twice its peak plus twice its trough, at most K(u)/u, K(u) tending to κ (Robbins); the bumps past P²/16 by end values; the roots at most 0.1715, one per sector as fixed points of contractions of the disc, so the root in each per-mode disc above is the k-th. With it X ≤ 2.06·10⁻⁴ at every P = 399..10⁶, largest at P = 408 (variation.py, a rule over that range in floating point, terms below its resolution left out, the bump table (lgamma) in doubles; past 10⁶ X falls, by hand); R + F + X is 0.0637 at d = 400 against 0.2506 (excess.py). So R bounded at every P would close every d past a computed range. Why the multiply coded classes are whole orbits under M mod m is not proved: y ↦ 0y carries the codings of a point of κ to codings of points of Mκ, but not onto one point.