SIZE — what a residue window cannot read, and what reading it costs

The object: a finite ring R = K_1 × ⋯ × K_k read through its channels, the k projections. A map is channel-local when each channel of its value depends only on the same channel of its argument. Over Z the ring is a squarefree Z/M, an integer x ∈ [0, M) read as its residues. A window is the reading of an element at a set of places; here it is x mod W for a divisor W of M, and it is proper when W < M. Over F₂[x], F₂ the field of two elements and x there an indeterminate rather than an integer, the ring is F₂[x]/f with f squarefree, an element a of F₂[x]/f read as its residues mod the factors f_i. This page says which maps a window computes channel by channel, why size is not among them, why ∞ − k and −k read alike at every finite place once ∞ is divisible by every positive integer, how completely size hides from a proper window, what the least exact key for size costs and where a published comparator sits against it, what a labelling kept by addition can carry of it and what a monotone one allowed to err pays, and which part of all this belongs to windows and which to the archimedean place Z happens to have.

QUESTION                       ANSWER                         PRICE
what is channel-local          exactly the polynomials        none
sign, compare, overflow        channel-local at no p < M      the wall
∞ − k against −k               one value at every finite      the order, read
                                place when ∞ is divisible      at no finite
                                by all n                       place
what a window W knows of the   sign-bit bias 0 or 1/2 an      nothing
sign                           element, 0 iff M/W is even
what x mod Q knows of          no element determined until    no pair ordered
 [1, X]                         Q > X/2                        until
                                                               2Q − X ≥ 2
which relations split          equality, divisibility         order fails
 by channel                                                    maximally
the least exact key            (floor(x/m_k), x mod m_k)      all moduli
 (G(x), x mod m_j)                                             but one
a labelling by s labels        exact below x₀, then periodic  order-blind at
 on [0, N), kept by addition    (x₀ + d ≤ s)                   and above s
a monotone labelling kept by   none wrong only at saturation; wrong pairs
 addition on most pairs         at top cut c, about (3/14)c²   growing as c²
                                wrong at 3 labels; at m + 1,   at every label
                                a share κ_m of c² as c grows,  count; at m + 1
                                lim inf κ_m log m ≥ 1/4,       about κ_m c²,
                                lim sup κ_m log m ≤ 1/2        κ_m ≥ 1/(32 log
                                                               16m)
over F₂[x] instead             the same wall, zero bias,      no carries,
                                an exact-or-flagged read       no silent miss;
                                                               (read: bias from
                                                               the ultrametric
                                                               place, carries
                                                               from char 0)

A letter or term not defined above is defined in the section that answers its row, the sign-bit bias in The hiding lemma.

The locality criterion

Tier: criterion.
Verifier: proof; size.py::section_l.

On a finite product of finite fields a map R → R is channel-local iff it is a polynomial function, and the same holds in several variables.

Proof. A polynomial is evaluated channel by channel (LOGIC: The pair uses this half). Conversely the channel map K_i → K_i is a Lagrange polynomial of degree below |K_i|, and the CRT glues the channels' coefficients degree by degree into one polynomial over R. In several variables the Lagrange basis is a product of one-variable ones.

Read as dynamics, this is a decoupling. A cellular automaton on R whose rule is built from ring operations (sums, products, constants, and so every power map, the meadow inverse of LOGIC: The meadow included) is the product of k independent automata, one per channel: channel i's trajectory depends only on channel i's initial state. By the converse, every k-tuple of arbitrary per-channel rules is one such rule. A threshold inside a channel therefore comes free, and no ring rule couples two channels.

The fields are needed. Over Z/8 the maps whose value mod 2 depends only on the argument mod 2 number 2² · 4⁸ = 262,144, while the polynomial maps number 1,024 (Kempner's count, Trans. Amer. Math. Soc. 22, 1921); over F₂[x]/x³ the numbers are the same. The script counts the polynomial maps as the span of the powers: all 108 channel-local maps of Z/6 among its 46,656, exhaustively; the 16 and 1,024 of F₂[x]/(x(x + 1)) and F₂[x]/(x(x² + x + 1)) and the 1,024 of Z/8 and of F₂[x]/x³, against channel-local totals counted by hand; and it lifts seeded maps of Z/30 in one and two variables.

The size wall

Tier: theorem.
Verifier: proof; size.py::section_w.

Read x ∈ Z/M as its least residue, M any modulus, and the channel at a prime p | M as x mod p. For every prime p | M with p < M, the sign [x ≥ M/2], the comparison [x < y] and the overflow [x + y ≥ M] are not channel-local at p: none is a function of the arguments' residues mod p alone. So on a squarefree ring with at least two channels none is a polynomial, and no channel-local bijection T makes one local: sign ∘ T is channel-local at no prime p | M with p < M either.

Proof. Let b = p⌈M/(2p)⌉. Then b ≡ 0 mod p, and M/2 ≤ b ≤ M − 1 because p ≤ M/2. The sign reads 0 at 0 and 1 at b; the comparison reads 0 at (0, 0) and 1 at (0, b); the overflow reads 0 at (0, 0) and 1 at (b, b). A channel-local bijection acts by a bijection on each channel, so its inverse is channel-local, and a local sign ∘ T would make sign = (sign ∘ T) ∘ T⁻¹ local; the same holds for comparison and overflow with T applied to both arguments.

The wall is locality, not linearity: no change of coordinates inside the channels, linear or not, exposes size. At a prime M there is one channel and every map is a polynomial; the wall needs a proper window.

Infinity at a finite place

Tier: property.
Verifier: proof.

Adjoin to Z an element H above every integer, in an ordered ring A, and write ∞ − k for H − k: it lies above every integer, while −k lies below 0. A finite place of A is a ring map f into a finite ring, of characteristic m say. When H is divisible in A by every positive integer, f(H) = m·f(H/m) = 0 at every finite place, so ∞ − k and −k have one residue at every finite place at once. Over Z the places together separate every pair, Z → Ẑ being one-to-one; here they read ∞ − k and −k as one value, and the order tells them apart. The order is read at no finite place: for every x ≠ 0, x and (1 − 2m)x agree mod m and have opposite signs. Divisibility is a choice: an infinite hyperinteger can have any residue point a ∈ Ẑ. For each a the sets {n ≥ 1 : n ≡ a mod lcm(1, …, j)} are nested and infinite, so a nonprincipal ultrafilter on the positive integers holding all of them makes the hyperinteger [n] infinite with residue a at every modulus, and ∞ − k reads a − k, apart from −k at exactly the moduli where a is not 0.

The neighbours sort by which half they keep. Ẑ keeps every residue and no order: n! → 0 there, so ∞ − 1 read as the limit of n! − 1 is −1 itself. Conway's omnific integers keep the order and read only the constant term: they are the sums x = Σ b_y ω^y with b_0 ∈ Z and no negative exponent (L'Innocente, Mantova, arXiv:1710.07304, which writes ω = 2·ω/2 = 3·ω/3), so x − b_0 is n times an omnific integer and x ≡ b_0 mod n; the map to Ẑ has image Z. The hyperintegers keep both, the residues of the infinite element [n] chosen by the ultrafilter: Benci and Di Nasso's numerosity gives a cofinite set of positive integers the size α − k, and whether α is even depends on the ultrafilter (Wenmackers, arXiv:2408.03344). A computable shadow is the big-M method's a + bH, ordered by b first, with H's residues set to 0 here, since the method has none. Made finite, H = M and 0 ≤ a < M, the pair (b, a) is x in mixed radix, and an overflow of x + y, x and y in [0, M), kept as a value is the high digit ⌊(x + y)/M⌋: the overflow bit itself, which the wall puts at no channel and The least key prices as one key compare.

The hiding lemma

Tier: theorem.
Verifier: proof; size.py::section_h.

Let M be any modulus, W a proper divisor and c = M/W. In every fiber of the window W the sign-bit bias, the number of the fiber's points at or above M/2 less half the fiber's size, is exactly 0 when c is even and exactly half an element in absolute value when c is odd. The cyclic orientation of every triple of distinct points, the way round Z/M they lie, is undetermined by the window.

Proof. The fiber of r mod W is the ladder r + jW, j < c. For even c exactly c/2 points lie at or above M/2 = (c/2)W. For odd c the points j ≥ (c + 1)/2 always do, and the point j = (c − 1)/2 does iff r ≥ W/2, so the count is (c ± 1)/2. For orientation, translate the triple's base point to 0; orientation becomes comparison of the other two on (0, M). Each ladder holds a nonzero element at most W and one at least (c − 1)W ≥ W, so pairing the extremes both ways gives both orientations, unless both ladders' nonzero parts are {W} at c = 2, where no distinct triple exists.

Neither squarefreeness nor a product is used; the hiding is a fact about coarsening a cyclic group. On a rung Z/p_k# (TOWER: The rung) the bias is exactly 0 as soon as the channel 2 is unread. The script checks every fiber of every proper window up to M = 240 and every orientation class with its base point at 0, every triple a translate of such a one, up to M = 60.

The half-coverage law

Tier: theorem.
Verifier: proof; size.py::section_c.

Read x ∈ [1, X] through x mod Q, for any Q ≤ X. Exactly max(0, 2Q − X) elements are determined, and some pair is ordered with certainty iff 2Q − X ≥ 2. So at or below half coverage, Q ≤ X/2, no element is determined and no pair is ordered, whether or not Q divides X; a coarser fact can still be certain, as residue 0 certifies x ≥ Q. When Q divides X the best guess of [a < b] from the residues is right on exactly X(X + Q − 2)/2 of the X(X − 1) ordered pairs.

Proof. The fiber of x has one lift iff x − Q < 1 and x + Q > X, which holds for the 2Q − X elements of [X − Q + 1, Q]. Every fiber's least lift is at most Q and its greatest exceeds X − Q, so two fibers are ordered only if X − Q + 1 ≤ a < b ≤ Q for their lifts, which needs 2Q − X ≥ 2; then X − Q + 1 and X − Q + 2 are both determined. At Q | X each fiber is a ladder of c = X/Q points. Two different fibers compare one way on c(c + 1)/2 of their c² pairs, and a fiber with itself splits its c(c − 1) ordered pairs evenly. Summed, the correct guesses are X(X + Q − 2)/2.

A proper window of Z/M has W ≤ M/2, so it never passes half coverage. At Q | X the guess is right with probability 1/2 + (Q − 1)/(2(X − 1)): order leaks from the first nontrivial window, Q = 2, while certainty waits for half.

The conjunctive split

Tier: theorem.
Verifier: proof; size.py::section_r.

Call a relation on Z/M conjunctive when it equals the conjunction of its projections to the channels. On a squarefree ring equality and divisibility are conjunctive; with two channels or more the order x ≤ y fails maximally, every projection being all of F_p × F_p. A nonempty relation is conjunctive iff at every split of one channel against the rest it is a rectangle, of Boolean rank 1.

Proof. Divisibility x | y means y = xz for some z, which by the CRT holds iff y mod p = 0 wherever x mod p = 0, channel by channel. For the order, the pairs with x < p ≤ y ≤ 2p − 1 < M all have x < y, and their residues at channel p run over every pair, so the conjunction is everything. For the criterion, a conjunction of channel relations is a rectangle at every split. Conversely a nonempty set that at every coordinate is the product of its projection and its co-projection contains every point whose coordinates lie in the projections: start from a point of the set and replace one coordinate at a time.

Cyclic betweenness, the ternary relation on distinct a, b, w that holds when (b − a) mod M < (w − a) mod M, so that b comes before w on the way up from a around the cycle, is not conjunctive either. The slice of a conjunctive relation at a fixed argument is a conjunction of channel relations, hence conjunctive. At base point a = 0 betweenness slices to 0 < b < w, which is not: at every channel p the pair (1, 1) is realized by (b, w) = (1, 1 + p), so the conjunction of projections holds (1, 1), which the slice does not. The script checks the three binary relations exhaustively at Z/210, betweenness as a ternary relation at Z/6 and Z/30, and the rank criterion at Z/30 on equality, divisibility and order.

The least comparator

Tier: known.
Source: Babenko, Piestrak, Chervyakov, Deryabin, Electronics 10 (2021) 1041; Dimauro, Impedovo, Pirlo, IEEE Trans. Comput. 42 (1993) 608.

For pairwise coprime moduli m_1 < ⋯ < m_k with product M, a key is a map sending each x ∈ [0, M) to a tuple of integers, its values are ordered lexicographically, and a key compares exactly when that order agrees with the order of x on [0, M). The key (⌊x/m_k⌋, x mod m_k) compares exactly. The 2021 paper works with core functions, weighted sums of the quotients ⌊x/m_i⌋. It names ⌊x/m_k⌋ the minimum-range monotonic core function, shows that the diagonal function D(x) = Σ ⌊x/m_i⌋ of 1993 is the core function with every weight equal to 1, and argues that no core function of smaller range compares.

The least key

Tier: theorem.
Verifier: proof; size.py::section_q; size.py::section_d; size.py::section_k.

Write x_i = x mod m_i for the residue at the modulus m_i, prime or not, the moduli ordered m_1 < ⋯ < m_k as above, and keys compared as in The least comparator; among the keys (G(x), x mod m_j) that compare exactly, over all G and all j, call one a least key when its first coordinate takes the fewest values. For each j, whatever G is, G takes at least M/m_j values, since the M/m_j elements of one class mod m_j need distinct values. ⌊x/m_k⌋ attains that count, M/m_k values against the largest modulus m_k, and it is one dot product of the residues modulo M/m_k: it equals (B − x_k)·m_k⁻¹ there, B the CRT value of the other residues. Since x = m_k⌊x/m_k⌋ + (x mod m_k), the key is x itself in mixed radix. Its first coordinate is that dot product, one reconstruction modulo M/m_k (the product of every modulus but the largest), and no exactly comparing key (G(x), x mod m_j) has a first coordinate with fewer than M/m_k values. Sign is one key compare against ⌈M/2⌉, and the overflow of x + y is the compare key(z) < key(x) for z = x + y mod M. The key is handed over as size.py's least_key(residues, moduli) and compare(a, b, moduli), residue words in and the verdict out.

The diagonal is never the least for k ≥ 2, since D rises at every multiple of m_1 and so takes at least M/m_1 > M/m_k values. Paired with any residue it still keys exactly. D(x + 1) − D(x) counts the moduli dividing x + 1, so inside a run of constant D every residue climbs without wrapping, and (D(x), x mod m_j) is exact for every j. With S = Σ M/m_i, gcd(M, S) = 1 and D < S, so D is one dot product mod S, D ≡ −M⁻¹ Σ (M/m_i) x_i. It is narrower than a full reconstruction mod M iff Σ 1/m_i < 1, which no rung Z/p_k# (TOWER: The rung) from Z/30 on meets, and it is never narrower than ⌊x/m_k⌋. The script checks the dot product for ⌊x/m_k⌋ at every x of four sets, Z/510510 among them, where M/m_k = 30,030 against S = 716,167, D's dot product at 2,000 seeded x of each, and the rung sums Σ 1/p_i from k = 1 to 10.

A published comparator against the least key

Tier: rule (proved from the pseudocode; no mismatch at 118,485 pairs).
Verifier: rns_compare.py::section_price; rns_compare.py::section_exact; rns_compare.py::section_controls.

Didier, El Mrabet, Glandus and Robert (arXiv:2605.18415, 2026) compare two residue numbers at any pairwise coprime moduli with one redundant modulus m_a coprime to M. They convert the residues of (x − y) mod M to mixed radix, reduce that value mod m_a, and answer x ≥ y iff it matches the redundant channel's (x − y) mod m_a. If x < y the converted value is x − y + M and differs from the redundant reading by M mod m_a, never 0. So the redundant channel tests which way the difference wrapped and computes nothing of it.

Against the least key, the method reconstructs once per compared pair. It computes all n mixed-radix digits of the difference, n the number of moduli without m_a; that digit map is one-to-one on [0, M), so it carries log2 M bits. The least key instead reconstructs each operand once, modulo every modulus but the largest, and is reused across every comparison that operand enters; for a single comparison it reconstructs twice, each modulo the product of n − 1 moduli, against the method's one conversion over n: a count of reconstructions, not of multiplications, which the script prices for the method alone. Implemented from its Algorithms 1 to 3 it costs n(n − 1)/2 + (n − 1) modular multiplications: 5, 27 and 35 at n = 3, 7 and 8. That is one under the paper's Table 1, whose Algorithm 3 loop runs from the second digit while its text counts n. The conversion it presents finishes in n − 1 rounds even with its digits computed in parallel, each digit's steps in turn and each step as soon as the digit it reads is final; the table's O(log n) parallel time rests on a conversion the paper cites and does not present.

The script runs the method against integer comparison at every pair of {3, 5, 7} and {4, 9, 5} (m_a = 11 and 7) and at random pairs with a corner list (equal values, differences of m_a and 2m_a, the ends of the range) at the primes 2 to 17, at {15, 77, 221} with m_a = 4, and at eight primes above 2¹⁶: no mismatch at 11,025 and 32,400 pairs exhaustively and 50,020, 20,020 and 5,020 at random with the corners. Its controls, a comparator that always answers ≥ and the method with m_a = 15 dividing M = 105, each fail at all 5460 pairs with x < y.

The additive labelling law

Tier: theorem.
Verifier: proof; size.py::section_a.

Carry size beside the residues in one small labelling: a map μ from [0, N) into a set of s < N labels, not all of which need be used, that addition keeps current, μ(x + y) a function of μ(x) and μ(y) whenever x + y < N, say μ(x + y) = A(μ(x), μ(y)). Then μ(x + 1) = A(μ(x), μ(1)), so μ is one point's orbit under the self-map A(·, μ(1)) of an s-set: exact on a prefix [0, x₀) and periodic with period d after it, x₀ + d ≤ s. Each such pair is a congruence of ([0, N), +), its quotient the cyclic monoid of index x₀ and period d, so up to relabelling there are exactly s(s + 1)/2 such labellings once N > s, and multiplication keeps each of them current for free. Every label appears below x₀ + d, so a value below x₀ is read exactly off its label, while at or above x₀ a label names a value only up to a multiple of d, and two values u < v at or above s are never ordered by their labels: v's label already labels a value below x₀ + d ≤ s ≤ u. A labelling that orders the values 0 to h carries more than h labels, and one way out for a labelling addition keeps is a label map allowed to be wrong somewhere on the range. On Z/M with wraparound, a labelling addition keeps exactly has a group congruence for fibers, the cosets of a subgroup, so it is reduction mod some m | M, which multiplication keeps too: one more residue. A depth-first search over every labelling at N = 8, 10, 12, 14 and s from 2 to 5, assuming no shape, finds exactly the 136 the count predicts.

The F₂[x] control

Tier: theorem.
Verifier: proof; size.py::section_f.

Over F₂[x]/f, f squarefree with at least two irreducible factors, read a as its representative of degree below deg f. The locality criterion holds as stated, and the top degree bit [deg a = deg f − 1] is channel-local at no channel, so the wall's core is unchanged. Three things the Z side has are gone:

Proof. The wall: for f_i ≠ f, 0 and f_i x^(deg f − 1 − deg f_i) agree mod f_i. The bias: a fiber of the proper window g | f is a coset r + g·P, P running over the polynomials of degree below e = deg f − deg g ≥ 1, and the top bit is 1 exactly where P's coefficient at x^(e − 1) is set, on half the coset. The degree: F₂[x] is a domain, and leading coefficients multiply. The read: write a/f = Σ b_i/f_i in partial fractions, deg b_i < deg f_i; a sum of proper fractions is proper, so the integer parts of the b_i x^t/f_i add without carries to (a x^t) div f, whose degree is deg a + t − deg f when that is nonnegative, and which is 0 otherwise.

Which difference owns what, as a reading of the proofs rather than a further theorem. Z and F₂[x] differ twice: Z has an archimedean place and F₂(x) does not, since degree reads its place at infinity, and Z has characteristic 0 where F₂[x] has 2. The zero bias is the place's. Over every F_q[x], deg(r + g·P) = deg g + deg P for P ≠ 0 and every r of degree below deg g, which is the ultrametric inequality at infinity. So at every degree from deg g up, every fiber of a proper window has the same degree profile, the whole ring's share at each degree, and a window reads nothing of a degree there. Over Z the absolute value is not ultrametric, r + jW exceeding max(r, jW) once both are nonzero, and the share moves by half an element at odd M/W. Carries go with the characteristic instead: the 2-adic integers carry with no archimedean place, and the silent miss rides on the carries. The information wall of COORDINATES, no channel-local read deciding size, needs neither. The script checks all 31 proper windows, every a and every t from 1 to deg f = 10 at f = x(x + 1)(x² + x + 1)(x³ + x + 1)(x³ + x² + 1), the degree profile at all 15 proper windows of x(x + 1)(x² + 1)(x² + x + 2) over F₃, and finds the Z wrap at y = 1 at Z/510510 with 16 bits.

The erring labelling

Tier: theorem.
Verifier: proof; erring_label.py::section_zero; erring_label.py::section_two; erring_label.py::section_nfree; erring_label.py::section_three; erring_label.py::section_kappa.

The escape the additive labelling law leaves, priced for a label that respects size. Let μ be nondecreasing from [0, N) onto s labels, cut at 0 = c₀ < c₁ < ⋯ < c_s = N, and let addition keep it on most pairs: A(a, b) is a most frequent label of x + y over the pairs (x, y) with μ(x) = a, μ(y) = b and x + y < N, the error E counts the pairs where μ(x + y) ≠ A(μ(x), μ(y)), and the reach R counts the pairs x < y with μ(x) < μ(y). The front is the least error at reach at least r. Write c = c_{s−1} for the top cut and T(n) = n(n + 1)/2. For 1 < s < N:

Proof. Zero error makes μ(x + y) a function of μ(x) and μ(y), the law's hypothesis, so μ is exact on [0, x₀) and periodic after; a periodic nondecreasing tail is constant and an exact monotone prefix is x ↦ x, so μ is saturation, which keeps addition: min(x + y, s − 1) = min(min(x, s − 1) + min(y, s − 1), s − 1). A pair with a summand at or above c sums into the top label, so only the pairs in [0, c)² can err; they sum below 2c − 1 ≤ N, none truncated, and land by the cuts up to c. At s = 2 only the cell [0, c)² errs: T(c) of its c² sums fall below c, the other C(c, 2) at the top. For c > N/2, d = N − c, the sums in [c, N) number d(2c − 1 − d)/2, fewer than T(c), so that is the error, above d's C(d, 2) by d(c − d) at the same reach c(N − c); on c ≤ ⌊N/2⌋ reach and error both rise strictly. At s = 3 put β = c − α. If β ≥ α the four cells below c err C(α, 2) three times (in [0, α) × [0, β) the pairs i + j ≥ β number C(α, 2)) and T(β − α) once, the sums of [α, c)² below c, fewer than β²/2. If β < α they err C(α, 2), T(β), T(β) and 0, and twice the excess over the swap α' = β, which errs at most 3C(β, 2) + T(α − β), is at least 2(3β − 1) > 0. With α = ac the error over c² tends to 3a²/2 + (1 − 2a)²/2, least at a = 2/7, where it is 3/14.

The script finds saturation the only zero-error cut set at 100 cells (s, N), s = 2 to 6, N up to 24; the s = 2 front at N = 3 to 60, with the count at all 870 cut sets c > N/2; the same error at N and N + 7 at 4740 cut sets; e₂(c) equal to the minimum at c = 2 to 120 (0.2125 c² at c = 120); and the β < α count and its swap at 1560 cut sets, c up to 80.

Rounding's carry at many labels

Tier: property.
Verifier: proof; erring_label.py::section_round; erring_label.py::section_kappa; erring_label.py::section_far.

Fill [0, c) with m intervals below one overflow label [c, 2c − 1), call e_m(c) the least error and κ_m the limsup over c of e_m(c)/c². By The erring labelling e_m(c) is the least error of m + 1 labels at top cut c on every N ≥ 2c − 1, whose reach is c(N − c) plus at most C(c, 2), so at reach r small against N² the front costs about κ_m(r/N)². κ₁ = 1/2 and κ₂ = 3/14; the construction below holds κ_m to 1/10 + O(1/m), and The rate of the least error puts κ_m at order 1/log m.

The construction: label x below uc by round(x/w) and [uc, c) by one top label. Pairs summing below uc spread over a triangle of width 2w against cuts spaced w and miss their cell's label on a quarter of the pairs, over an area u²c²/2. A fine summand near ξ and a top summand overflow c with probability ξ/((1 − u)c) up to ξ = (1 − u)c, so each order of the mixed pairs errs on the smaller side, (1 − u)²c²/4 pairs. Every other pair errs only in the cells cut by x + y = uc or x + y = c, O(cw) pairs. So as c grows at fixed w/c, E/c² tends to u²/8 + (1 − u)²/2 + O(w/c), least at u = 4/5, where it is 1/10, and w can be chosen to give every m. At c = 2000 the script prints 0.1301, 0.1149, 0.1077 and 0.1028 at w = 100, 50, 25 and 10 (m = 18, 34, 66, 162); at m = 18 it prints 0.1299, 0.1301 and 0.1302 at c = 1000, 2000 and 4000. A local search over the cuts at c = 300, m = 2 to 10, prints only upper bounds (0.1218 at m = 10) and found this shape unprompted: at m = 9, cuts near (k + 1/2)·28.5 and one wide top interval [216, 300).

The construction is a renamed operation: round(x/w) is the high digit of x in radix w, rounded, the approximate form of the first coordinate of The least key, and its error is the carry the dropped low digit would have sent. Results here are the constants, 3/14 the front's at three labels and 1/10 rounding's limit, not the label.

Doubling cuts against the front

Tier: rule (verified s = 3, N = 60, t = 1..29; s = 4, N = 40, t = 1..9).
Verifier: erring_label.py::section_geo.

Cuts in ratio 2, t, 2t, 4t, …, with the most frequent label as the sum table, are the floating-point exponent of a sum. At s = 3, N = 60 they sit on the front at t = 1, 2, 3 and 20 (saturation, the two smallest scales, and the uniform cuts) and above it at the other 25 scales; at s = 4, N = 40 on it at t = 1 alone and above at t = 2 to 9. The gap reaches 4.8 times: 516 against 108 at s = 3, t = 29. At these two ranges, past its smallest scales and but for the uniform cuts, the exponent is not the least-error label at its reach.

Growing widths

Tier: observation (the limits computed at m = 162, 400, 406, 1000 and 1100); pattern (the readings at c = 2000 to 64000, m = 34 to 1000, p = 1 to 3).
Verifier: erring_zones.py::section_limits; erring_zones.py::section_controls; erring_lower.py::section_exp; erring_widths.py::section_profiles; erring_widths.py::section_scale.

Rounding's labels share one width, so a cell of two of them sums over twice a label's width and splits at a cut. A label whose widths grow with position puts wider labels where the sums land: cuts at t ↦ t + max(1, round(g c (t/c)^p)) up to a top cut uc, then [uc, c) as one top label, g tuned to give m intervals. These are a companding quantizer's steps, 1/G′(t) for a compressor G, p = 1 the logarithmic compressor of μ-law: the label is that operation renamed, and only the constants below are results.

At c = 4000, over m = 34, 66, 162 and 400, a profile beats rounding's best top cut at the same m at m = 66 (p = 1, top 0.8: 0.1034 against 0.1068), not at m = 34 (0.1362 against 0.1120), and prints below 1/10 at m = 162 (0.0905 against 0.1028) and 400. At m = 400, p = 2 with top 0.8 prints 0.0785 and p = 1 0.0852, rounding 0.1022; at m = 1000, c = 10000, p = 2 with top 0.9 prints 0.0723. At m = 400, p = 3 spends 299 labels on singletons near 0 and prints 0.1005.

A cut set bounds κ_m by its continuum error, its limit as the set is scaled (The rate of the least error, step 1), never by a set re-tuned at another c (re-tuned at c/2 the profiles print 1.8 to 9.6% lower). The limits print 0.09054 at m = 162 (p = 1, top 0.8), 0.08572 and 0.08000 at m = 400 (p = 1 and 2, top 0.8), all three built at c = 4000, and 0.07380 at m = 1000 (p = 2, top 0.9, built at c = 10000). So κ₁₆₂ < 0.0906, κ₄₀₀ < 0.0801 and κ₁₀₀₀ < 0.0739, where rounding's limit is 1/10 + O(1/m) (0.1030 at m = 162). Exponential widths, cuts t ↦ t + εe^(K(t − 1)) from 0 and no top label, print below every profile at nearby m: 0.07247 at m = 406 (K = 6, ε = 1/6) and 0.05978 at m = 1100 (K = 7, ε = 1/7), so κ₁₁₀₀ < 0.0598. The profiles' scaled readings approach from below: 0.0785 to 0.0799 at m = 400, p = 2, x1 to x16; 0.0723 to 0.0734 at m = 1000, x1 to x4.

The rate of the least error

Tier: theorem; observation (the readings at m up to 7673, F₂ log m in closed form beyond).
Verifier: proof; erring_lower.py::section_bound; erring_lower.py::section_discrete; erring_lower.py::section_constant; erring_zones.py::section_zones.

κ_m is the limit of e_m(c)/c², the infimum E*_m of the continuum error below. It is nonincreasing in m, at least 1/(32 log 16m) at every m, and of order 1/log m (log natural here and below):

1/4 ≤ lim inf κ_m log m ≤ lim sup κ_m log m ≤ 1/2.

Proof. (1) For a partition P of [0, 1) into m intervals, overflow [1, 2), let E(P) be its continuum error, each cell's area less its largest label area, and E*_m its infimum over P. Round cP to integers and keep in each cell the continuum's best label as reference: each count moves by O(c), so e_m(c) ≤ c²E(P) + O(m²c) and κ_m ≤ E*_m. Conversely a cut set at c scaled by 1/c is such a P; in a cell, for each integer x the count of a label's y is the length of an integer interval, 1-Lipschitz in x, so each label count is within O(c) of c² times its area and the cell's count is exact: e_m(c) ≥ c²E*_m − O(m²c). So e_m(c)/c² tends to E*_m, which is κ_m. (2) Once c > m some interval [u, v) has v − u ≥ 2; split it at v − 1. A split cell errs no more than the whole, since its parts' largest classes hold at least the whole's, and only the sums equal to v − 1 change label, at most c pairs, so e_{m+1}(c) ≤ e_m(c) + c and κ_{m+1} ≤ κ_m. (3) The lower bound. Let P have intervals I_a of widths w_a and put LB(P) = (1/8)Σ_a w_a² + (1/4)Σ_{a<j} w_a min(w_a, w_j). Then E(P) ≥ LB(P): the cell I_a × I_b errs at least the integral over y in I_b of e_a(y), the length of I_a less its largest label class once shifted by y, since the cell's largest label is one label at every y. A label boundary β strictly inside I_a + y leaves every class on one side of it, so e_a(y) ≥ w_a/2 − |β − t|, t the midpoint of I_a + y. As y runs over [0, 1), t runs over an interval of length 1 starting at I_a's midpoint, so it covers each later interval I_j, both of whose ends are boundaries, where the integral is at least w_a min(w_a, w_j)/4, and [1, 1 + w_a/2), past the boundary 1, where it is w_a²/8. Each pair term w_a min(w_a, w_j) is at least min(w_a, w_j)², equal when the widths increase, and with v the widths sorted increasing and S_j = v₁² + ⋯ + v_j² the squared minima sum to Σ_i v_i²(m − i) = S₁ + ⋯ + S_(m−1), whatever the order. So LB ≥ G = S_m/8 + (S₁ + ⋯ + S_(m−1))/4 ≥ R/8, R = S₁ + ⋯ + S_m (a sum here, not a reach). Fix a mass δ in (0, 1), let j₀ be the last index with v₁ + ⋯ + v_j₀ ≤ δ and A that sum; j₀ < m as the widths sum to 1. If A < δ/2, every later width exceeds δ − A > δ/2 and they sum past 1 − δ/2, so R ≥ S_m > δ(2 − δ)/4. Else S_j₀ ≥ A²/j₀ ≥ δ²/(4m); with D_j = log(S_j/S_{j−1}), v_j² ≤ S_j D_j since log(1 + x) ≥ x/(1 + x), and Cauchy–Schwarz gives (1 − δ)² ≤ (Σ_{j>j₀} v_j)² ≤ R log(S_m/S_j₀) ≤ R log(4m/δ²), as S_m ≤ 1. So R ≥ F(δ) = min(δ(2 − δ)/4, (1 − δ)²/log(4m/δ²)) at every δ. At δ = 1/2, as 3/16 > 1/(4 log 16), E(P) ≥ LB(P) ≥ R/8 ≥ 1/(32 log 16m) for every P, and κ_m = E*_m is at least the same. For the limit fix also η > 0 with δ + η < 1. If A < δ/2, G ≥ S_m/8 > δ(2 − δ)/32; else if v_m ≥ η, G ≥ η²/8; else the widths strictly between j₀ and m sum past 1 − δ − η, and Cauchy–Schwarz over them alone gives (1 − δ − η)² ≤ (S₁ + ⋯ + S_(m−1)) log(4m/δ²). So G ≥ F₂(δ, η) = min(δ(2 − δ)/32, η²/8, (1 − δ − η)²/(4 log(4m/δ²))); at δ = 8/log m, η = (log m)^(−1/3) its terms are (1 − o(1))/(2 log m), (log m)^(−2/3)/8 and (1 − o(1))/(4 log m), so κ_m ≥ (1 − o(1))/(4 log m). (4) The upper bound. Take [0, t₀) as one interval and cut [t₀, 1) into n_z zones of width Δ ≤ t₀, zone k a grid of width w_k = εf(z_k), z_k its start and f nondecreasing, at a phase uniform on [0, w_k), the phases independent, zone ends cuts, and w_max = max w_k. A cell errs on at most its pairs whose sum leaves the label of the cell's midpoint sum σ. Put aside a pair with a summand below t₀ (area at most 2t₀), a summand within w_max of a zone end (4(n_z + 1)w_max) or its sum within w_max of a zone end (2(n_z + 1)w_max, 1 among the ends). In a remaining pair (x, y), x in zone a and y in zone b, each summand lies in a full grid interval at an offset uniform under its zone's phase, so E|x − m_I| = w_a/4 for I its interval, and |x + y − σ| ≤ (w_a + w_b)/2. A sum at or above 1 + w_max shares the overflow label with σ. Otherwise the sum lies in a zone d, later than a and b since y ≥ t₀ ≥ Δ carries x + y past x's zone, so w_d ≥ w_a, w_b; given the phases of a and b, which fix σ, the phase of d is uniform and independent of them, and a cut separates x + y from σ with chance |x + y − σ|/w_d. Averaged over the phases the pair errs with chance at most (w_a + w_b)/(4w_d), so some choice of phases errs at most B, the integral of (w(x) + w(y))/(4w(x + y)) over x, y ≥ t₀, x + y < 1, plus 2t₀ + 6(n_z + 1)w_max, with at most m* = 1 + Σ_k (⌈Δ/w_k⌉ + 2) intervals, and by (1) and (2) κ_m ≤ B for every m ≥ m*. Take f(t) = e^(K(t − 1)): as z_d > x + y − Δ, the integrand is at most (e^(K(Δ − y)) + e^(K(Δ − x)))/4, whose integral is at most e^(K(Δ − t₀))/(2K). With t₀ = Δ = K^(−3/2) and ε = K^(−3), n_z + 1 ≤ 1/Δ + 2 and w_max ≤ ε, so B ≤ 1/(2K) + 2K^(−3/2) + 6(K^(3/2) + 2)K^(−3) = (1/2 + O(K^(−1/2)))/K, the O about 8/√K, while m* = K²e^K(1 + o(1)), Σ_k Δ/w_k lying within a factor e^(KΔ) → 1 of the integral of 1/(εf) over [t₀, 1). Given m, some K with m*(K) ≤ m has K = log m − O(log(log m)), and by (2) κ_m ≤ B there: so κ_m ≤ (1/2 + o(1))/log m.

The bound 1/(32 log 16m) holds at every m. Both constants are limits no run reaches: F₂(8/log m, (log m)^(−1/3)) log m tends to 1/4 and reads 0.2111 at m = 10^1024, the best F₂ log m on a grid at most 0.0531 up to m = 7673; K·B ≤ 1/2 + 8/√K + 12/K², about 3.8 at K = 7. The chain E ≥ LB ≥ R/8 ≥ 1/(32 log 16m) prints no ratio above 1 over 1186 partitions (five width laws at m = 2 to 60, the growing-width profiles, rounding), E/LB from 1.20 to 4.00, the last step loose by 6 or more; over these and ten exponential cut sets F(δ) ≤ R at δ = 1/2, 1/4 and 0.1 (F/R at most 0.3806), G ≤ LB, and F₂(δ, η) ≤ G at the same δ and η in {1/4, 1/8, (log m)^(−1/3)}, δ + η < 1 (F₂/G at most 0.1924). The zone construction, run with f(t) = t^p only, errs above rounding at the m a run reaches, over 8 phase seeds each: a mean of 0.2285 at m near 575 (p = 1, ε = 0.005, Δ = t₀ = 0.1), 0.1684 at m near 1438 (p = 1, ε = 0.0025, Δ = t₀ = 0.05), and 0.2074 and 0.2094 at m near 1550 and 3090 (p = 2, Δ = t₀ = 0.1, ε = 0.01 and 0.005).

The cell tent bound

Tier: theorem (over nondecreasing widths; the error and G₂ on the half-shifted grid; E ≥ G₂(sort P) at every P with m ≤ 3, by an exact case split); property (LB₂ ≤ LB₃ ≤ E, LB_low ≤ LB₃); rule (LB₃ ≥ G₂(sort P) at integer widths, verified over every composition of N ≤ 12 and of at most five parts to N = 20); observation (the readings at m up to 2984, the bound's constant in closed form beyond, LB₃ at the few real partitions named).
Verifier: proof; erring_cells.py::section_controls; erring_cells.py::section_chain; erring_cells.py::section_rise; erring_cells.py::section_rearrange; erring_cells.py::section_sorted; erring_cells.py::section_lb3; erring_cells.py::section_lattice; cell_exact.py::section_controls; cell_exact.py::section_m2; cell_exact.py::section_m3.

Step (3) of The rate of the least error charges the cell I_a × I_b, at each shift, one label boundary inside the shifted I_a. Let h_a(t) be the largest such charge, (w_a/2 − |t − β|)₊ over the boundaries β, and T_ab the integral of h_a(mid_a + y) over y in I_b: the cell errs at least T_ab. The cells (a, b) and (b, a) hold the same sums, so each errs at least the larger direction:

E(P) ≥ LB₂(P) = Σ over ordered pairs (a, b) of max(T_ab, T_ba) ≥ LB(P).

On the exponential cuts E/LB₂ is 1.029 to 1.105 at m = 21 to 2418, where E/LB is 1.633 to 1.905. Over nondecreasing widths the bound meets the upper side's constant:

E(P) ≥ (1 − o(1))/(2 log m) for every P with w₁ ≤ ⋯ ≤ w_m.

Proof. Put c_j = w₁ + ⋯ + w_j and S_j = w₁² + ⋯ + w_j². (i) LB₂ ≥ G₂ = Σ_a T_aa + (1/2)Σ_j S′_j, S′_j the sum of w_b² over b ≤ j with c_(b−1) ≥ c_j/2: for a < b the pair's max, counted once in each order, is at least T_ba, and Σ_(a<b) T_ba integrates I_b's tent, radius r = w_b/2, over t in [mid_b, 2c_(b−1) + r), where each boundary c_j, j ≥ b, c_j ≤ 2c_(b−1), carries a whole tent of area w_b²/4, the tents disjoint as later gaps are at least w_b. (ii) Let J be the j with w_j ≤ c_(j−1), where S′_j ≥ w_j². A j outside J is wider than all earlier widths together, so those past any point sum below twice the last of them. (iii) For j in J, S_j − S′_j ≤ (3/4)S_j: S_j − S′_j = S_i for i the least index with c_i ≥ c_j/2, and i < j since w_j ≤ c_(j−1); S_i ≤ w_i c_i and S′_j ≥ w_i(c_j − c_i), so S_i/S_j ≤ c_i/c_j, and c_j − c_i ≥ max(w_i, c_j/2 − w_i) ≥ c_j/4. (iv) If c_j > δ for every j > j₀ ≥ 1, then Λ, the sum of w_j²/S′_j over j in J, j₀ < j < m, is at most log(S_(m−1)/S_j₀) + 8⌈log₂(1/δ)⌉: by (iii), w²/S′ ≤ w²/S + 4w²(S − S′)/S²; the first part telescopes, and the second sums to at most 8 over the j with c_j in a window (U/2, U], since S − S′ there is at most S at the window's first index. (v) Let j₀ be the last j with c_j ≤ δ and A = c_j₀. If A < δ/2 or w_m ≥ η, E ≥ LB ≥ S_m/8 gives δ(2 − δ)/32 or η²/8. Else S_j₀ ≥ δ²/(4m), the widths in J strictly between j₀ and m sum past 1 − δ − 3η by (ii), and Cauchy–Schwarz against Λ gives G₂ ≥ max(0, 1 − δ − 3η)²/(2 log(4m/δ²) + 16⌈log₂(1/δ)⌉). At δ = 8/log m and η = 2/√(log m) all three terms are (1 − o(1))/(2 log m).

The least of the three times log m tends to 1/2 and reads 0 at m = 10^8 and 10^16 (1 − δ − 3η ≤ 0 there), then 0.0772, 0.2458 and 0.3679 at m = 10^64, 10^256 and 10^1024. Over 511 increasing partitions (m up to 2984) each step's ratio stays within its bound, every check fired first by a planted break: G₂/LB₂ at most 1.000000, (S_j − S′_j)/S_j at most 0.7497, Λ against its bound at most 0.2988, the widths outside J at most 0.8818 of twice the last, and the J widths' sum at least 0.1783 past 1 − δ − 3η. The theorem does not pass to κ_m by sorting: the same widths sorted increasing err more than rounding's own order (E(P)/E(sort P) down to 0.5706), while sorted decreasing they never err less than sorted increasing over the 1200 partitions read (at least 1.0002).

E(P) ≥ G₂(sort P) at every P, sort P the widths sorted increasing, would carry the theorem to every partition. It is sharp if true. On the half-shifted grid H_n, widths 1/2, 1, …, 1, 1/2 scaled to sum 1 (m = n + 1, w = 1/n), each cell's sums lie on a tent or a trapezoid whose split by the boundaries is read off directly, and

E(H_n) = (n² + 3n − 1)/(8n²), G₂(sort H_n) = (n² + n − 1/2)/(8n²) for every n ≥ 2.

Proof. Number H_n's intervals I₀ = [0, w/2), I_a = [(a − 1/2)w, (a + 1/2)w) for a = 1, …, n − 1 and I_n = [(n − 1/2)w, 1); the boundaries are (a + 1/2)w, a = 0, …, n − 1, and 1 = nw. Two full intervals I_a, I_b put their sums on a tent over [(a + b − 1)w, (a + b + 1)w): for a + b ≤ n − 1 the boundaries (a + b ∓ 1/2)w leave 3/4 in the middle label, error w²/4, at (n − 1)(n − 2)/2 cells; for a + b = n half the tent overflows, error w²/2, at n − 1 cells; past n everything overflows. The first half interval with a full one, in either order, makes a trapezoid of mass w²/2 with 3w²/8 below the boundary (b + 1/2)w, error w²/8 at 2(n − 1) cells; the last with a full one overflows; the half-half cells err w²/8 three times (split at w/2 or at 1) and 0 once: (w²/8)((n − 1)(n − 2) + 4(n − 1) + 2(n − 1) + 3) in all. Sorted, the intervals are numbered 1, …, m with c₁ = w/2 and c_j = (j − 1)w for j ≥ 2. S′₁ = 0, S′₂ = w²/4 (the tie c₁ = c₂/2), and for j ≥ 3 the b counted are b ≥ (j + 3)/2, so S′_j = w²⌊(j − 1)/2⌋, with a tie at each odd j ≥ 3 (ties out, G₂ is smaller); the S′ sum to w²(⌊n²/4⌋ + 1/4). T₁₁ = w²/16, the boundary w/2 at the middle of mid₁ + I₁; T₂₂ = 0, mid₂ + I₂ = [5w/4, 7w/4) keeping w/4 from w and 2w; and for a ≥ 3, mid_a + I_a centres on the boundary (2a − 3)w while 2a − 3 ≤ n, a whole tent w²/4, at ⌊(n − 1)/2⌋ intervals, and none past. At n = 2k and 2k + 1 the sum is w²(n² + n − 1/2)/8.

So E/G₂(sort H_n) = 1 + 2/m + O(1/m²) and no constant above 1 fits in front of G₂. On the scaled grid, H_n scaled onto [0, 1/2) beside one interval [1/2, 1), the ratio is 1 + 0.402/m at n = 800 (m times the excess 0.414 to 0.402 over n = 100 to 800). The tents do not carry it: LB₂(P)/G₂(sort P) is 0.960165 at a seven-interval P with a narrow interval just after one 17 times its width, where E/G₂(sort P) is 1.1515, while on both grids LB₂ stays above G₂(sort P) (m times the excess 0.499 on H_800, 0.100 on the scaled grid).

Charging the cell at each shift its longest piece, not one tent, holds it there. Let e_a(y) be w_a less the longest piece of I_a + y cut at the boundaries, U_ab its integral over y in I_b, and LB₃(P) the sum over ordered pairs of max(U_ab, U_ba). The cell's one label holds at most the longest piece at each y, and e_a(y) is at least the tent h_a(mid_a + y), so LB₂ ≤ LB₃ ≤ E. LB₃/G₂(sort P) is 1.015148 at the seven-interval P, and m times its excess is 0.980 and 0.995 on H_50 and H_200 and 0.201 on the scaled grid at n = 200, twice LB₂'s. At the unsorted (2, 4, 2, 5)/13 both sides are 27/169 by hand: U, in units of 1/169, has rows (1, 1, 1, 1), (2, 6, 1/2, 7/2), (1, 1/2, 1/2, 0), (2, 17/4, 0, 0), each pair's max falls on its wider interval, and sorted, the diagonal tents (1, 0, 7/2, 0) and the S′ (0, 4, 16, 25), both ties c_(b−1) = c_j/2 in, give the same 27. A ratio over G₂ can be least on its ties, where G₂ jumps (LB₃'s is, at (2, 4, 2, 5); LB₂'s least read is not), and integer widths put every tie of small denominator on the lattice exactly: over every composition of N ≤ 12 and every one of at most five parts to N = 20 (24209 compositions) LB₃/G₂(sort P) reads no less than 1 − 10⁻⁹ in floating point, and the unsorted primitive points where it reads 1 to within 10⁻⁹ are (2, 4, 2, 5) and its first 2 split, (1, 1, 4, 2, 5). So LB₃ ≥ G₂(sort P), if true, is tight at an unsorted P. It does not pass through sorting: LB₃(P)/LB₃(sort P) is 0.945197 at the widths 0.0821, 0.3561, 0.2057, 0.3561.

At m ≤ 3 it holds at every real P, and so does E(P) ≥ G₂(sort P), ties in. Charge each pair once, at its wider interval: LB_low(P) is Σ_a U_aa plus twice the sum over pairs of U at (the wider interval, the narrower), read at its least over the orders of equal widths, and LB_low ≤ LB₃ term by term. Proof. At m = 1, U₁₁ = T₁₁ = G₂ = 1/4. At m = 2 and 3 every quantity in U, the tents and G₂ is built from the free cuts by affine maps, comparisons of affine forms and products of two affine forms. Carried exactly, each LB_π − G₂, π an order of the tied widths, is one quadratic on any face over which no compared form changes sign, and splitting on those forms' lines covers the simplex: 5 open segments and their cuts at m = 2; 116 open polygons, 179 open segments and 64 vertices at m = 3, every order of tied widths read. A quadratic's least on a closed face is exact (the vertices, each edge's critical point, the interior one when the Hessian is positive definite), and no least is below 0. At m = 2, with s the narrower width, G₂ is (1 − s)²/4 − s²/4 for s ≤ 1/3 and s²/4 + (1 − 2s)²/2 for 1/3 < s < 1/2, and LB_low − G₂ is s² (s ≤ 1/3) or 3s − 7s²/2 − 1/2 (1/3 ≤ s < 1/2) with the narrower interval first, s/2 + s²/2 (s ≤ 1/4) or 5s/2 − 7s²/2 − 1/4 (1/4 ≤ s < 1/2) with it second, and 0 at s = 1/2, both sides 3/16. At m = 3 the zeros in the open simplex are exactly the widths (t, t, 1 − 2t), 1/4 ≤ t ≤ 1/3, either order of the tie, each on G₂'s tie c₁ = c₂/2.

Open fronts

The erring labelling's constant. lim inf κ_m log m ≥ 1/4 and lim sup κ_m log m ≤ 1/2 (The rate of the least error); over nondecreasing widths the error is at least (1 − o(1))/(2 log m) (The cell tent bound). Open is whether widths out of order can err below (1 − o(1))/(2 log m). Sorting can raise E, so the bound does not pass by rearranging E; it passes if E(P) ≥ (1 − o(1))G₂(sort P) at every P, which with E ≥ S_m/8 would give lim κ_m log m = 1/2. The exact form holds over the 1200 partitions read (at least 1.0066) and is sharp on the half-shifted grid (The cell tent bound); LB₂ falls below it, and LB₃, which charges each shift its longest piece, holds it at every partition it is read at in The cell tent bound, an integer lattice among them, and at every P with m ≤ 3, and meets it at the unsorted (2, 4, 2, 5)/13 with ties in. Paying each sorted interval's share of G₂ (T_bb, plus w_b²/2 for each j ≥ b with c_j ≤ 2c_(b−1)) out of LB_low's row at the same rank (U_aa plus twice U_ab over each narrower b) fails at m = 3: the rows fall short at ranks 1 and 2, ranked from the narrowest (cell_exact.py::section_shares). Moving the surplus does not rescue it one way: over the simplex at m = 3 it flows from wider rows to narrower, and at m = 4 it flows the other way at (1, 3, 2, 4)/10, where the tail of the two widest rows falls short (cell_exact.py::section_suffix). The charging route reopens on a charge that moves shares both ways in rank, or on a lower bound other than G₂(sort P) that reaches (1 − o(1))/(2 log m) at unsorted widths. Open too: whether an explicit cut set, with no chosen phases, meets O(1/log m). The exponential cuts t ↦ t + εe^(K(t − 1)) print E log m from 0.373 to 0.479 (erring_lower.py's probe) at the nine cut sets erring_cells.py reads at m = 21 to 2418, neither flat nor falling in K.