# rho-decoupling - Computes `N_F(level; d)`, the number of length-`level` digit strings over a digit set `F` in base `base` whose value `sum f_j base^j` is divisible by `d`, exactly, by dynamic programming on residues mod `d` with u128 counts; the value map is injective on fixed-length strings, so this counts integers below `base^level` with padded digits in `F`. - For each family and depth the sweep over divisors `2 <= d <= D` with `(d, base) = 1` prints the worst normalized error `d |N_F(level;d) - fill^level/d| / fill^level` among `d` coprime to the digit-difference gcd, the multiplicative order of `base` at the worst `d`, the per-digit rate `worst^(1/level)`, the per-factor ceiling `gamma = max_a |sum_{f in F} e(a f / d)| / fill` at that `d`, and the slack against the proved bound `d (1 - 8/(fill^2 d^2))^level`. - The proved bound is asserted exactly at every census cell where its hypotheses hold: `d |N - fill^level/d| * (fill^2 d^2)^level <= d * fill^level * (fill^2 d^2 - 8)^level` in big integers, no floats in the claim path. - Families whose digits share a factor also print the unrestricted worst error, the wall where the count does not equidistribute. - The Type I line accumulates `sum mu(d) (N_F(level;d) - fill^level/d)` and its absolute-value trivial bound over squarefree `d <= D` coprime to `base` as exact fractions, printing both relative to `fill^level` and their ratio. - The decouple line probes the fixed divisor `d = 7` at the deepest level of each family: the per-digit error rate against the per-factor ceiling, across bases `3, 4, 5, 10, 100`, which is where the large-base decoupling is visible. - Four pinned probes read single divisors of `base^t - 1` at `base = 100` (`d = 101, 9999, 3367, 999999`, the first inside the sweep range, the rest beyond it): each line prints the rate `(|N - fill^level/d|/fill^level)^(1/level)` and the orbit-mean damping factor `mean = rate * d^(1/level)`, reading `0.106` at `d = base^2 - 1` against `fill^(-1/2) = 0.1005` and `0.237` at `d = base^3 - 1` against `fill^(-1/3) = 0.216`. - The carry DP counts `N_F(level; e)` for `e | base^t - 1` without a state per residue: the value of a length-`level` string is congruent mod `base^t - 1` to `V = sum_{i= 2` and `t <= level <= 40`, and prints per depth the exact ratio `Sigma_level/Abs_level` of the signed sum `Sigma_level = sum mu(e) T_level(e)` to the absolute sum `Abs_level = sum |T_level(e)|` over the squarefree moduli of that set, together with `Abs_level/fill^level`, the count of terms within a factor of ten of the largest, the four largest terms at `level = 40` as exact integers, and the ratio at every `level = 3..40`. - Here `T_level(e) = N_F(level; e) - fill^level/e` is an exact rational and `e T_level(e) = e N_F(level; e) - fill^level` an exact integer; the sums are formed over a common denominator, so only the printed ratios are floats. - `mu(e)` is read off a complete factorisation, never a table: `base^t - 1 = prod_{d | t} Phi_d(base)` splits first, then trial division to `10^5`, Pollard-Brent, and Miller-Rabin on the thirteen bases `2` to `41`, deterministic below `3.317 * 10^24`; a cofactor called prime above that bound is not certified, so its modulus leaves the sums and counts instead in the `unknown` column of the depth row, and at `t <= 40` both bases certify every prime factor and every `unknown` count reads zero. - The riesz module computes the even moments `S_p(level) = sum_{a mod base^level} |hat F_level(a/base^level)|^p` of the digit transform `hat F_level(y) = sum_{n in D_level} e(ny)` on the value set `D_level` of the length-`level` strings, exactly through the identity `S_p(level) = base^level E_r(level)`, `p = 2r`, where `E_r(level)` counts the `2r`-tuples of length-`level` strings with `n_1 + .. + n_r = n_{r+1} + .. + n_{2r} mod base^level`, together with the integer count `E_r^int(level)` (equality over the integers, which is `int_0^1 |hat F_level|^p`); both come from one carry DP whose state is the pair of carries of the two sides, reduced by the swap symmetry to `r(r+1)/2` states, so each sequence is C-finite of that order and `Lambda(p) = lim S_p(level)^{1/level}` is `base` times the Perron root of the transfer matrix. - For each family it prints the characteristic polynomial of that matrix in exact integers, its factorisation over `Z` (integer roots by a scan bounded by the maximal row sum, monic quadratic factors by a bounded search over the divisors of the constant term, a cofactor of degree at least four certified irreducible modulo a printed prime by the distinct-degree test), an exact two-sided bracket on the Perron root from the Collatz-Wielandt bounds at a positive rational vector on the states reachable from the zero carries, the factor holding the Perron root located by a sign change on the bracket with every other factor certified nonzero there, then `Lambda(p)`, its exponent `theta_p = log Lambda(p)/log base`, the floors `max(fill^p, base fill^{p/2})` and the ceiling `base fill^{p-1}` asserted at every depth to `level = 60`, the recurrence asserted at every depth, the ratio `E_r/E_r^int`, the share of the zero frequency in `S_p`, and the growth of the primitive part `S_p(level) - fill^p S_p(level-1)`. - The type II rows print per family the exponent `theta_4/4 + 1/4` that Holder with the fourth moment and Parseval on the bilinear side yields for a Type II sum over the digit set, its miss against `alpha = log fill/log base`, the bilinear saving `1 - alpha/2` such a route would need on the minor arcs, and the large-values threshold `eta_4 = (1 + 3 alpha - theta_4)/2` below which the fourth moment counts the frequencies near the maximum better than Parseval does; the arcs rows evaluate `|hat F_level(a/base^level)|^2` at every grid point at one or two depths per family, mark the points within `1/(d x^{3/5})` of a fraction with denominator `d <= x^{2/5}`, and print the share of the Parseval mass off those points against `(fill/base)^level`, the share below which a moment route could still work. - The riesz families are the census families with every reflection class of one excluded digit at `base = 10`; the higher moments run `p = 6, 8, 10` at `base = 3`, `F = {0,1}` and `p = 6` at four more families. - The large module reads the same grid as a complex table, `hat F_level(a/base^level)` at every `a` for `base^level <= 10^6`, asserts Parseval and the exact `S_4` on it to `10^{-10}` relative, and for six thresholds `eta` per cell (`0`, `eta_4/2`, `eta_4`, `2 eta_4`, `0.25`, `0.5`) forms the large set `A_eta = {a : |hat F_level(a/base^level)| >= fill^level x^{-eta}}`: it prints its size against the fourth-moment count `S_4 fill^{-4 level} x^{4 eta}` and the Parseval count `base^level fill^{-level} x^{2 eta}`, both asserted above the size, the least gap between two of its points in grid units, the number of maximal runs of consecutive grid points and the longest run, the floor `sum_{a in A} |hat F_level|^2/fill^level` of the set's large-sieve constant for polynomials supported on `D_level`, and that constant itself as the top eigenvalue of the Gram matrix `hat F_level((a - a')/base^level)` on the set, bracketed by the Rayleigh quotient of a power iteration below and by the least of the Gershgorin row bound, the Frobenius norm and `base^level` above, while the set has at most `1500` points, capped by `fill^{level-j} base^j` when the set lies on the level-`j` grid; every printed float is a two-sided band or rounded safe, bounds up and floors down. - Beside the set it prints the inequality chain of a large-values Type II with bounded coefficients: the small set's exponent `min(alpha + 1/2 - eta, (1 + alpha)/2)` from the threshold and Parseval on the bilinear side, the large set's exponent from the sup and the count, `alpha + log(#A)/(2 log x)`, from the set's own mass, `log(sum_{a in A} |hat F_level|^2)/(2 log x)`, and from the Parseval cap `(1 + alpha)/2`, all against Parseval on the bilinear side (the large-sieve constant of any grid subset for `base^level` consecutive frequencies is `base^level` exactly), the sup form with the fourth-moment count in place of the size, the count-based `c sup = alpha - max(small, large sup)` and the chain `c = alpha - max(small, min of the three)`, together with the `l^1` exponent `c_1 = log(sum_a |hat F_level(a/base^level)|)/log x` at the depth. - A per-cell row prints `nu_4(level)`, `eta_4`, `c_1`, the second-largest grid value over `fill^level`, which equals `max_{b != 0 mod base} |g_F(b/base)|/fill` by the last non-integer factor of the product formula, and the threshold `eta_1(level)` below which the large set is the zero frequency alone. - A witness row per cell counts, on the box `m, l in [M, 2M)` with `M = floor(x^{1/2}/2)`, the representations `R = #{(m, l) : ml in D_level}`, which is the Type II sum at `a_m = b_l = 1`, and the balanced sum at `a_m = 1_{base | m}`, `b_l = 1`, `R_base - fill^level base^{-level} M #{m : base | m}`, each against `fill^level` and as an exponent of `x`. - The menergy module computes the multiplicative energy `E_x(level) = #{(n_1, n_2, n_3, n_4) : n_i in D_level, n_i != 0, n_1 n_2 = n_3 n_4}` of the same digit column exactly, by forming the `K^2` products of the column with itself in `u128`, hashing them into as many partitions as the memory cap allows, sorting each partition and summing the squares of the run lengths, which is `sum_m r(m)^2` for `r(m)` the number of ordered factorisations of `m` inside the column; it prints `K`, `E_x(level)`, the exponent `log E_x/(level log base)` against `2 alpha`, the ratio of `E_x` to the exact diagonal count `2K^2 - K`, the largest `r(m)`, the share of the excess over the diagonal that the shift solutions explain, and the same ratio and the direct quotient for one uniform random subset of `[1, base^level)` of the same size drawn by the module's own generator. - Two bounds are asserted at every cell in exact integers: the band `2K^2 - K <= E_x(level) <= K^3` (the diagonal and the swap agree on the `K` quadruples with `n_1 = n_2`; fixing three entries determines the fourth) and `E_x(level) <= K^2 max_m r(m)`, which with `r(m) <= d(m)` pins the exponent at `2 alpha` for every digit set. - When `0` is a digit the module also asserts a third floor `E_x(level) >= 2K^2 - K + T(level)`, where `T(level)` counts the shift solutions `(base^i u, base^j v, base^{i'} u, base^{j'} v)` with `i + j = i' + j'`, `i != i'`, `u != v` and `u, v` of nonzero last digit, a closed form in `fill` and `level` alone; the printed share `(2K^2 - K + T)/E_x` says how much of the energy the diagonal and the shifts explain. - The type II rows sweep the dyadic boxes `m in [M, 2M)`, `l in [N, 2N)` with `MN` in `[x/32, x/4]` and `M, N >= 8`, and for each box count `R = #{(m, l) : ml in D_level}`, the restricted energy `E_x(M, N) = sum_m (#{l : ml in D_level})^2`, and the balanced energy `E_x^bal(M, N) = sum_{l_1, l_2} |W(l_1, l_2)|` for `W(l_1, l_2) = sum_m psi(m l_1) psi(m l_2)`, `psi = 1_{D_level} - K/base^level` with `K` the column size, whose Cauchy-Schwarz bound `(M E_x^bal)^{1/2}` is what such a route returns for a bilinear sum with bounded coefficients; the pairs with `W` off its baseline are counted by sorted keys, the rest by the histogram of the column counts, and the identity `sum_{l_1, l_2} W = sum_m (c_m - N fill^level/base^level)^2`, derived independently, is printed as a self-check. - Each cell prints the extreme boxes by the bound exponent among the boxes carrying a representation, the worst box inside the arc regime `M, N >= x^{2/5}`, the ratio of the bound to that box's trivial bound, and the margin `alpha - log bound/log x`, for the digit column and for a random column of the same density side by side. - The sigma rows draw random sign vectors for both coefficient sequences on a fixed box and assert the Cauchy-Schwarz bound at every draw, printing the largest ratio of the measured `|Sigma|` to the bound; the identity `sum_{l_1, l_2} W = sum_m (c_m - N delta)^2` printed beside them is an algebraic rearrangement of the sweep's own quantities and pins summation order, not correctness. - The signed module computes the off-diagonal correlation `Sigma_b = sum_{l_1 != l_2} b_{l_1} b_{l_2} W(l_1, l_2)` of a coefficient vector `b`, the one part of the balanced energy that keeps the coefficients' signs, for nine coefficient vectors at once: the constant `1`, the Mobius function, the Liouville function, three seeded random sign vectors, and three seeded random sign vectors supported on the squarefree integers only, which is the Mobius support with the Mobius arithmetic removed. - The identity it evaluates is `Sigma_b = sum_m V_m(b)^2 - sum_l b_l^2 W(l, l)` for `V_m(b) = sum_l b_l psi(ml)`, the full quadratic form being a sum of squares, and it is carried as the exact integer `x^2 Sigma_b = x^2 (Q - P) - 2 K x (B C - P) + M K^2 (B^2 - S_2)` in `i128`, where `Q = sum_m u_m^2`, `u_m = sum_{l, ml in D_level} b_l`, `B = sum_l b_l`, `C = sum_l b_l c'_l`, `P = sum_l b_l^2 c'_l` and `S_2 = sum_l b_l^2`; the printed `Sigma_b` is that numerator over `x^2` rounded to the nearest integer and every ratio and exponent comes from the numerator itself. - Mobius and Liouville come from one smallest-prime-factor sieve to twice the largest box side; the random vectors come from the module's own generator at fixed seeds, so the same vector is used at every family, depth and box. - The signed sweep runs the same dyadic band `MN in [x/32, x/4]` at two depths for each of four families, selecting the box that maximises `|Sigma_1|` over the band and the box that maximises it inside the arc regime `M, N >= x^{2/5}`, and repeats the deeper depth on a random column of the same size, each on its own selected box; each row prints `Sigma_1`, `Sigma_mu`, `Sigma_lambda`, their exponents `log |Sigma_b| / log x`, the ratios to `Sigma_1`, the min-max band of each triple of random draws, and the ratios to the root mean square a random sign vector reaches. - That root mean square, `(2 sum_{l_1 != l_2} W(l_1, l_2)^2)^{1/2}`, is the yardstick a signed sum is read against, and it is computed as `sum_{l_1, l_2} W^2 = sum_{m, m'} (sum_l psi(ml) psi(m'l))^2` over the pairs of the shorter side, the only float in the module and never in a claim path. - Each row also prints the min-max, over the eight signed coefficient vectors, of the full quadratic form divided by its own diagonal, and the ratio of the best possible bounded-coefficient sum `sum_m |V_m(b)|` to the Cauchy-Schwarz bound `(M sum_m V_m(b)^2)^{1/2}`, which says how much the inequality itself loses. - A separate section drives the quadratic form down by greedy single-sign flips from the all-ones vector on a `+-1` vector supported on the whole side, printing the flips used, the form, its diagonal, the resulting bound and the diagonal floor `(1 - delta)(M R)^{1/2}`; the engineered vector is built with full knowledge of the column, is available to no decomposition, and exists to show that the bound has no floor over all bounded coefficients. - A summary row counts, over the digit cells, how often the Mobius value falls below, inside and above each band, how often it is smaller in absolute value than the Liouville value, the extreme ratios to the root mean square for the Mobius vector and for the support-matched draws, the extreme values of the form over its diagonal, the extreme Cauchy-Schwarz losses, and how often the signed sums fall below the box representation count `R` while the unsigned one stays above it. - Two checks hold the signed rows: at `b = 1` the quantities `Q` and `C` are asserted equal to the `E_x(M, N)` and `R` of the box sweep, computed along a different data path, and the tests re-evaluate the definition pair by pair over `l_1 != l_2` with `W` by a direct triple loop in the same exact integers. - The signed families are `F = {0,1}` at `base = 3` and depths `12, 14`, `{0,1,2}` at `base = 4` and depths `8, 9`, `{0,1,2,3}` at `base = 5` and depths `7, 8`, and one excluded digit at `base = 10` and depths `5, 6`. - The vaughan module censuses the real coefficient sequences a Vaughan decomposition hands the bilinear sum, on the same boxes the signed module selects: `b^U_l = sum_{d | l, d <= U} mu(d)`, the `l`-side coefficient of the Type II term of Vaughan's identity for both `mu` and the von Mangoldt function, and the log-weighted variant `sum_{d | l, d <= U} mu(d) log(l/d)`, each at the two cuts `U = floor(x^(1/3))` and `U = floor(x^(2/5))`, together with the sign vector of the second. - Each sequence is built by adding `mu(d)` and `mu(d) log d` along the multiples of every squarefree `d <= U`, so the two pieces cost one pass per divisor, and the tests check both against a direct loop over the divisors of every `l` to `1200` at three cuts. - The Type II region of the identity is `m > V` and `l > U`, so the boxes that are Type II cells are those with both sides above the cut; the summary counts them and the wide boxes are printed beside them as the same sequence read where the identity does not put it. - For each box it prints the two cuts, the ratio `2N/U` that bounds the box maximum of the coefficient, the share of the box where the coefficient is nonzero, the box maximum, the full quadratic form over its own diagonal for all five sequences, the diagonal share `w = diag/((1 - delta)^2 R)` of the normalised coefficient, and its Cauchy-Schwarz bound over the diagonal floor both normalised by the box maximum and unnormalised. - The split `bound/floor = (form/diag * w)^(1/2)` is an identity in the definitions and is asserted at every box, so a small bound is attributed to cancellation, to a sparse or small coefficient, or to a large box maximum, and never to all three at once. - The summary row prints the extremes of every column over the sixteen boxes and the eighty coefficient cells, how many sit inside the band the signed module's summary prints, how many fall below one tenth, how many boxes carry a coefficient with box maximum one, and the closest any cell comes to either end of that band. - The menergy census runs the census families to the depth the `K^2` product count allows, `level = 12` at the two-digit sets of `base = 3`, `level = 8` at `base = 4`, `level = 6` and `level = 7` at `base = 5`, `level = 4` and `level = 3` at one excluded digit of `base = 10`, `level = 9` for the pair and `level = 2` for the lower half at `base = 100`, and the box sweep one to three levels deeper, to `level = 14` at `F = {0,1}`, `base = 3`, where only membership in the column is needed. - Census families: the three two-digit sets at `base = 3`; `{0,1,2}` at `base = 4`; `{0,1,2,3}` and `{0,2,4}` at `base = 5`; one excluded digit at `base = 10` and `base = 100`; the lower half `{0..49}` and the pair `{0,1}` at `base = 100`. Depths to `level = 96`, divisor ranges to `D = 500`; floats appear only in printed readouts, truncated at forty decimal digits. ## RUN - `bash scripts/cargo.sh cargo run --release -p rho-decoupling` - Under twenty seconds for the whole run, census, carry sweep, riesz moments, large values, multiplicative energy and signed correlation together; prints only, writes nothing. - `cargo test -p rho-decoupling` runs thirty-nine tests: the residue DP against brute-force string enumeration at four bases, the residue vector total against `fill^level`, the exact splitting of `N_F(level; d1 d2)` across `d1 | base`, `(d2, base) = 1` at `base = 6`, the Mobius sieve against hand values and `M(100) = 1`, and the exact bound inequality at `base = 3`, `F = {0,1}`, `level = 16`, `d <= 60`. - The riesz tests pin the moment DP against a sumset histogram at `p = 4` on every family and at `p = 6, 8` on four, the exact `S_4` against direct evaluation of the product formula on the grid and `E_2^int` against the `2 base^level`-point quadrature at `level <= 6`, the factoriser and the irreducibility test on known polynomials, the scaling identities of `{0,2}` and `{1,2}` against `{0,1}` at `base = 3`, every fourth-moment bracket against the growth ratio at `level = 40`, the rendered algebra, value and type II rows of seven families, the minimal polynomials of seven higher moments, and the arcs counts at `base = 3`, `level = 12`. - The large tests pin the complex grid against a direct sum over every string at four families, the large set at five thresholds against the same direct values, the Gram eigenvalue at `{0}` (`fill^level`), at the `base^2`-grid (`fill^{level-2} base^2`, the witness set of the sparse large sieve) and at the full grid (`base^level`), the run statistics on hand sets, and the witness counts against an enumeration of the column. - The menergy tests pin the partitioned energy against a four-fold brute-force enumeration of the solutions at six families, against itself at three partition caps, the band and the divisor ceiling at four families, the scaling identity `E_x(cF) = E_x(F)` at `{0,2}` against `{0,1}` and `{0,2,4}` against `{0,1,2}` together with the failure of translation invariance at `{1,2}`, the restricted and balanced energies of a box against a direct triple loop over the box, the shift count against an enumeration of the shift solutions themselves, and the Cauchy-Schwarz bound against sixty random sign draws on three boxes. - The signed tests pin the Mobius and Liouville sieves against their first twelve values, the exact identity against a pair-by-pair evaluation of the definition at four families and all nine coefficient vectors, the unsigned quantities against the box sweep at three families, and the collapse of the unsigned correlation on a random column of the same size. - The vaughan tests pin both pieces against a direct divisor sum at three cuts, the form and the diagonal against a pair-by-pair evaluation of the definition with the kernel by a direct triple loop, and the form of the integer piece against the exact integer `sum_m (x u_m - K B)^2` over the box. - The carry tests pin the carry DP against brute-force enumeration at `base = 3, 5, 10` over every `t <= level` and every `g | base - 1`, against the residue DP at every reachable `e <= 30000` at `level = 8` and `level = 12` in both carry families with zero mismatches, the certification of every cofactor of `base^t - 1` at `t <= 40` in both bases, and as rendered strings the depth rows, the four largest terms at `level = 40`, the ratio sequence `level = 3..40`, the `mu` tables and seven factorisations; one more test pins the digit-vector helpers. ## WITNESSES - mobius.md digit strings across divisors, the uniform equidistribution bound `|N_F(level;d) - fill^level/d| <= fill^level (1 - 8/(fill^2 d^2))^level` for `(d, base) = 1` with `d` coprime to every digit difference: asserted exactly at every census cell. - mobius.md digit strings across divisors, the worst divisors are the pinned ones: at every family's deepest level the sweep argmax `d` has `ord_d(base) <= 8`, so `d | base^t - 1` with `t <= 8`, e.g. `d = 164` at `base = 3`, `d = 143` at `base = 10`, `d = 101, 303` at `base = 100`; shallow levels can stray (`d = 199`, `ord = 99`, at `base = 10`, `level = 6`). - mobius.md digit strings across divisors, the decoupling: at `d = 7` the per-digit error rate falls `0.49, 0.33, 0.25, 0.11, 0.017` along `base = 3, 4, 5, 10, 100` with one digit excluded, but stays `0.50` for `F = {0,1}` at `base = 100`: the gain is carried by the fill, not the base alone. - mobius.md digit strings across divisors, a signed pinned sum against its absolute sum: over the moduli `e = (base^t - 1)/g` with `g | base - 1`, `e >= 2`, `t <= level`, squarefree, the ratio `Sigma_level/Abs_level` of the Mobius-signed sum of `T_level(e)` to the sum of `|T_level(e)|` is verified at `-0.211, -0.123, +0.069, -0.498` for `level = 10, 20, 30, 40` at `base = 3`, `F = {0,1}` and at `+0.812, -0.495, -0.127, -0.192` for `base = 10` with one digit excluded, while `Abs_level/fill^level` falls from `4.7e-2` to `2.1e-4` and from `1.1e-5` to `3.9e-12`. - mobius.md digit strings across divisors, no cancellation trend to depth `40`: the ratio is printed at every `level = 3..40` on both families and shows no decay toward zero with depth, swinging across the band and reading `-0.50` at `level = 40` in base three and `-0.99` at `level = 29` in base ten, so the sign of `mu(e)` buys no extra saving over the trivial absolute bound on this modulus set at these depths. - mobius.md digit strings across divisors, few terms carry the sum: at `level = 40` the terms within a factor of ten of the largest count `6` at `base = 3` out of `29` and `4` at `base = 10` out of `60`, the four largest sitting at `t = 7, 9` in base three and `t = 5, 7, 8, 10` in base ten, each printed as the exact integer `e T_level(e)`. - mobius.md the meter and its yardstick, the fourth moment: `sum_{a mod base^level} |hat F_level(a/base^level)|^4 = base^level E(level)` with `E(level)` the additive energy of the strings modulo `base^level`, counted by the carry DP; `Lambda(4) = 18` at `base = 3` for all three two-digit sets, `2(23 + sqrt 353)` at `base = 4`, `F = {0,1,2}`, `(275 + 5 sqrt 2369)/2` at `base = 5`, `F = {0,1,2,3}`, `95` at `F = {0,2,4}`, five quadratic irrationals across the excluded digit at `base = 10`, from `6566.412229970` (digit `5` excluded) to `6567.410368845` (digit `0` or `9` excluded), `8335000` for the lower half and `600` for `{0,1}` at `base = 100`, each inside `[max(fill^4, base fill^2), base fill^3]` and strictly above `fill^4`. - mobius.md the meter and its yardstick, the large-values route to Type II: splitting the grid at `|hat F_level| >= fill^level x^{-eta}`, bounding the large set by the fourth-moment count and Parseval and the rest by the threshold and Parseval gives the exponent `max(min(alpha + 1/2 - eta, (1 + alpha)/2), min((1 + alpha)/2, log(sum_{a in A_eta} |hat F_level|^2)/(2 log x)))`, read at `66` cells over six families and equal to `(1 + alpha)/2`, the `l^2` route, at every one of them; at `{0,1}` base 3, `level = 12`, `eta = eta_4`, the large set holds `407` adjacent-or-isolated grid points in `331` runs against the fourth-moment count `4096`, and its large-sieve constant `1.06009e5..2.13280e5` sits nearly at its own `l^2` floor `1.05611e5`. - mobius.md the meter and its yardstick, the witnesses: at `a_m = b_l = 1` the Type II sum on the box `M = N = floor(x^{1/2}/2)` is the representation count `R`, which reads `0.38 fill^level` at `{0,1}` base 3 `level = 12` and `0.26 fill^level` at one excluded digit of base 10 `level = 6`, and the balanced sum at `a_m = 1_{base | m}`, `b_l = 1` reads `0.10 fill^level` and `0.0044 fill^level` there, so no bound `x^{alpha - c}` uniform over bounded coefficients holds for either sum at the nine dense cells; the two sparse cells are void at that box. - mobius.md the meter and its yardstick, the moment route to Type II: with Parseval on the bilinear side the Holder exponent `theta_4/4 + 1/4` misses `alpha` by at least `0.250000` (one digit excluded at `base = 100`) and by `0.446753` at `base = 100`, `F = {0,1}`, and any pointwise bilinear input would have to beat `x^{1 - alpha/2}` on the minor arcs, below the root mean square of the bilinear sum, at every family. - mobius.md the meter and its yardstick, the multiplicative energy of a digit column has no exponent of its own: `2K^2 - K <= E_x(level) <= K^2 max_m r(m)` with `r(m) <= d(m)` forces `E_x(level) = fill^{2 level} x^{o(1)}` for every digit set, and the census reads the exponent falling `1.475642, 1.410978, 1.356938` at `level = 4, 8, 12` for `F = {0,1}` at `base = 3` toward `2 alpha = 1.261860`, with `max_m r(m) = 56` at `level = 12`. - mobius.md the meter and its yardstick, the excess over the diagonal is shift structure: `E_x/(2K^2 - K)` reads `1.7523` for `{0,1}` at `base = 3` and `level = 12` against `1.0004` for a random column of the same size, and the closed-form shift count `T(level) = 11144220` brings the explained share to `0.7603`; at `{1,2}`, where no digit is zero and `T = 0`, the ratio is `1.0006` and the share `0.9994`. - mobius.md the meter and its yardstick, the type II route through the multiplicative energy: `|Sigma|^2 <= M E_x(M, N)` and `E_x(M, N) <= 2N E_x(level)^{1/2} x^{o(1)}` give `|Sigma| <= (2MN)^{1/2} x^{alpha/2 + o(1)}`, above the trivial `x^{alpha}` by `(1 - alpha)/2` for every digit set with `alpha < 1`, the same miss as square-root cancellation on the fourth-moment route. - mobius.md the meter and its yardstick, the Mobius signs cancel the correlation no better than unstructured signs on the same support: over sixteen boxes across four families at two depths each, `|Sigma_mu|` divided by the random-sign root mean square stays in `[0.0913, 0.7178]` while the three support-matched draws stay in `[0.0359, 1.5048]`, and both signed sums fall below the box representation count `R` at all sixteen while the unsigned `Sigma_1` stays above it at all sixteen. - mobius.md the meter and its yardstick, the apparent advantage of the Mobius function is its support: against three plain random sign vectors it sits below the band at eight cells, inside at seven and above at one, but against three random sign vectors on the squarefree integers it sits below at three, inside at nine and above at four, chi-square `0.375` against the uniform-rank null `4, 8, 4`; `|Sigma_mu| < |Sigma_lambda|` at fifteen of sixteen cells and the support-matched control removes the whole gap. Sixteen cells against three draws exclude a large effect and nothing smaller: a true below-rate of `0.41` still gives three or fewer at probability `0.0556`. - mobius.md the meter and its yardstick, the bound has no floor over all bounded coefficients: a `+-1` vector built by greedy single-sign flips against a known column drives the full quadratic form to `0.0006` of its own diagonal at `F = {0,1,2,3}`, `base = 5`, `level = 7`, `M = 8`, `N = 2048`, and the Cauchy-Schwarz bound to `0.0265` of the diagonal floor `(1 - delta)(M R)^{1/2}`, reaching `0.4909` of that floor inside the arc regime at `M = N = 128`; the diagonal is sign-blind but the off-diagonal can cancel it, so no floor statement holds beyond the coefficient vectors actually swept. - mobius.md the meter and its yardstick, the off-diagonal correlation is a pure structure statistic: its expectation over a random column of the same density is zero at every coefficient vector, and the measured `Sigma_1` falls from `67382` to `349` at `F = {0,1}`, `base = 3`, `level = 14`, from `41590` to `122` at `base = 4`, from `72359` to `-27` at `base = 5` and from `823318` to `-2746` at one excluded digit of `base = 10`. - mobius.md the meter and its yardstick, the balanced route returns the trivial box bound: inside the arc regime `M, N >= x^{2/5}` the margin `alpha - log bound/log x` for `{0,1}` at `base = 3` falls `0.035675` at `level = 12` to `0.027009` at `level = 14` while the ratio of the bound to the box's own trivial bound rises `1.0134` to `1.0730`, and over all admissible boxes the margin is already negative at `level = 12`; the random column of the same density beats the digit column at every cell. - mobius.md the meter and its yardstick, the coefficient a real decomposition hands the method is not the coefficient the method would need: at the eight swept boxes with both sides above `x^(2/5)`, the boxes the identity produces and where the box sits within a factor `8.73` of the cut, the Type II coefficient of Vaughan's identity takes values in `{-1, 0, 1}` at seven of the eight and its quadratic form stays between `0.6929` and `1.2045` of its own diagonal, where a sign vector engineered against the column reads `0.2043` on such a box, and no one of the eighty coefficient cells of the census falls below `0.3138`. - mobius.md digit strings across divisors, the fixed-`fill` wall: for `F = {0,1}` at `base = 100` the worst normalized error over `d <= 500` still reads `7.2` at `level = 96`, decaying by factor `0.9929` per digit, pinned at `d = 303 | base^2 - 1`.