---
title: The zeta function of a digit design
lead: The design's own zeta function: an explicit zero-free half plane and the census it closes, a residue comb whose teeth are Rouche-certified one by one, a second family that is no critical line and obeys no counting, symmetry, contraction or gain law, the ordinate shadow as a constant-free Newton step from each zeta zero, the multiplicativity wall with the three products that stand where the Euler product does not, and the identity zeta_F N_F = 1 whose Mertens function runs the wrong way.
figure: research-zeta
slug: zeta
---

Fix a base at least 2 and a digit set `F` inside `{0..base-1}` with `fill = card F >= 2`, and let `S_F` be the positive integers whose digits all lie in `F`. A design is a set of integers, so it has a Dirichlet series, `zeta_F(s) = sum_(n in S_F) n^(-s)`, and that series is a zeta function with an abscissa, a meromorphic continuation and a lattice of poles. The full digit set gives [Riemann's](/wiki/riemann-zeta-function/). Every other digit set gives an object carrying the same machinery and none of the same theorems. The [critical line demo](../../site/demos/zeta/) walks Riemann's own object at `s = 1/2 + it`, through the origin once per zero, and folds the zeros one at a time into [the prime staircase](/wiki/prime-counting-function/). This page is the zeros of that object, and what the two faces of the Riemann hypothesis become on a design once the Euler product that glues them is taken away: the zeros of `zeta_F` on one side, the [Mobius](/wiki/mobius-function/) meter of [mobius](mobius.md) on the other, and no route running between them.

Tags as everywhere in this tree: **Proved** means derived here from definitions, **Verified** means recomputed exactly and checked against an independent path, **Conjecture** is labelled belief, **Refuted** means shown false.

## THE SPINE

- The abscissa of absolute convergence is `alpha = log_base(fill)`, the design's own mass exponent, and the series continues meromorphically to the whole plane with simple poles confined to the lattice `s_(m,j) = alpha - m + 2 pi i j / log base`. All of that is built territory: the abscissa is [Kohler and Spilker 2009](https://doi.org/10.1007/s00591-009-0059-5), with position-varying digit rules in [Nathanson 2021](https://arxiv.org/abs/2010.06295); the continuation is the automatic-series mechanism of [Allouche, Mendes France and Peyriere 2000](https://doi.org/10.1006/jnth.1999.2487), carried out for missing digits in [Burnol 2026](https://arxiv.org/abs/2602.19727) and unified in [Allouche, Shallit and Stipulanti 2025](https://arxiv.org/abs/2401.13524). The object of this page is Burnol's `K(s)` and is not new. **Verified** against the sources in [REFS](../REFS.md).
- The continuation is one digit recursion and nothing more. An element of more than one digit is `base m + a` with `m in S_F` and `a in F`, so expanding `(base m + a)^(-s)` binomially and summing the digit moments `gamma_l = sum_(a in F) a^l` gives `(1 - fill base^(-s)) zeta_F(s) = E_1(s) + sum_(l >= 1) binom(-s,l) base^(-s-l) gamma_l zeta_F(s+l)` with `E_1(s) = sum_(a in F, a != 0) a^(-s)`, the shift to `s + l` moving the argument into faster convergence. That is Burnol's Proposition 4.1, and the peeled form of it that carries the small tail `G_P` directly instead of as a difference of two large numbers is the engine of [lab/py/design-zeta](../lab/py/design-zeta/), where every printed value carries a propagated truncation bound. **Verified** against the source.
- The pole lattice is the same object [dimensions](dimensions.md) calls the complex dimensions of the design, one vertical line of period `2 pi / log base` per `m >= 0`, and it is what makes every counting function on a design log-periodic rather than asymptotic to a constant. The off-real poles at `m = 0` are genuine and not artefacts of the continuation: at base 3 with `F = {0,1}` the residue is enclosed in exact interval arithmetic and tied to the Fourier coefficients of the log-periodic profile of `A_F(x)`, certified in [dimensions](dimensions.md) by [lab/py/burnol-residue](../lab/py/burnol-residue/). **Proved**, computer-assisted.
- One factor carries that whole lattice on its own, and dividing it out is what makes the zeros readable. `1/(1 - fill base^(-s))` has poles exactly at `s = alpha + 2 pi i m / log base` and no zeros, so the cofactor `Z(s) = zeta_F(s) (1 - fill base^(-s))` is analytic on `Re s > alpha - 1`: the `m = 0` line is cancelled and no other, the poles of `Z` are the `s_(m,j)` with `m >= 1` at which `zeta_F` has a nonvanishing residue, and on a full digit set `Z` is entire, being `zeta(s)(1 - base^(1-s))`. One peel level gives it in closed form, `Z(s) = E_1(s) + sum_(l >= 1) binom(-s,l) base^(-s-l) gamma_l zeta_F(s+l)`, checked against brute-force digit summation to `1.6e-14` with and without `0` in `F`, and `Z(s) a_min^s -> 1` to the right, `a_min` the least nonzero digit. The transfer runs one way without exception and the other way with one: a zero of `zeta_F` right of `alpha - 1` is always a zero of `Z`, and a zero of `Z` is a zero of `zeta_F` except at a pole `s_(0,j)` whose residue vanishes, where `Z` vanishes and `zeta_F` is regular. At `s_(0,j)` one has `fill base^(-s_(0,j)) = 1` exactly for every `j`, so with `u = s - s_(0,j)` and `lambda = log base` the periodic factor is `1 - base^(-u)` with no `j` dependence and `zeta_F(s) = Z(s)(1/(lambda u) + 1/2 + lambda u/12 - lambda^3 u^3/720 + ...)`, which reads the residue, the regular part and its derivative off the Taylor coefficients of `Z` alone. **Proved** ([lab/py/zeta-locus](../lab/py/zeta-locus/), [lab/py/design-zeta](../lab/py/design-zeta/), [lab/py/burnol-residue](../lab/py/burnol-residue/)).
- What the spine buys is machinery and not a hypothesis. The abscissa, the continuation, the lattice, the positivity at `alpha` and the residue formula are all cited above and none of them says where `zeta_F` vanishes. The rest of this page is the zero set, the products that do and do not stand where the Euler product stands on the integers, and what each of them decides about the design's own Mobius meter. The same spine over a memory rule, where the scalar `fill base^(-s)` becomes [a transfer matrix](/wiki/transfer-matrix/) and the one pole lattice becomes one comb per eigenvalue, is [beneath](beneath.md), `### The memory zeta`.

## THE ZEROS

- The census runs on the cofactor `Z`, on one strip, `alpha - 0.92 < Re s < alpha + 3.02` and `0.02 < Im s < 60`, split at `Re s = alpha` exactly. Base 3 with `F = {0,1}`, `alpha = log_3 2`, carries 3 zeros right of the abscissa and 20 left of it; base 10 with the digit `9` missing, `alpha = log_10 9`, carries 13 right and 25 left; base 3 with `F = {0,2}` carries 3 right, in the same three boxes as `{0,1}`. The largest surviving phase step on any census contour is `0.9896` and the largest propagated bound met at any census evaluation is `9.99e-11`, both printed beside every count. A count is resolved and not certified unless a Rouche margin backs it, and eleven of the comb's teeth now are. **Verified** ([lab/py/design-zeta](../lab/py/design-zeta/)).
- Three of those zeros sit inside the design's own half-plane of absolute convergence, where `zeta_F` is a convergent sum of positive terms and the census uses no continuation at all, the ladder only rearranging it. The integers forbid that: at the base 2 full digit set the same census reads `0` zeros in `alpha + 0.02 < Re s < alpha + 3.02`, computed and not quoted, and the Euler product is the reason. The claim is this object and not a principle, since absolute convergence of a positive-term series is no zero-free region in general either: `1 + 2^(-s)` has abscissa of absolute convergence `-infinity` and zeros at `(2m+1) pi i / log 2`. What the census shows is that an infinite design, whose series is the same shape as Riemann's and whose abscissa is a positive number, does the same thing. **Verified** ([lab/py/design-zeta](../lab/py/design-zeta/)).
- Scaled digit columns share a zero set exactly. For a positive integer `a` with `a max F <= base - 1`, so that `aF` stays inside `{0..base-1}`, the carry-free bijection `m -> a m` gives `zeta_(aF)(s) = a^(-s) zeta_F(s)`, an exponential factor with no zeros and no poles, so the two designs have the same zeros and residues in the ratio `a^(-s_(m,j))`, and the proof uses `0 in F` nowhere. Base 3 `{0,2}` against `{0,1}` agrees to `5.6e-43` at three points, and on what was censused the two agree box for box: winding one in `Im [22.01, 24.01]`, in `Im [28.01, 30.01]` and in `Im [56.00, 58.00]` for both, and winding zero in every other box. Left of the abscissa `{0,2}` is not censused and is inferred from the theorem. On the meter side the same bijection twists by a sign ([mobius](mobius.md)), so the transfer is exact on both faces and trivial on one of them. **Proved** ([lab/py/design-zeta](../lab/py/design-zeta/)).
- Near the abscissa the zeros are a comb, one tooth per pole, and the residue puts each tooth where it is. A zero near `s_(0,j)` solves `u(R_j + R'_j u + ...) = -r_j` with `r_j` the residue and `R_j` the regular part, first order `u_1 = -r_j/R_j` and second order the near root of `R'_j u^2 + R_j u + r_j = 0`, both built from Laurent data with nothing fitted. Over 20 designs to `Im s = 40` one radius `0.45` keeps the pole discs from overlapping, the smallest period in the sweep being `2.2662`, and it is not defended by the tooth law, which says nothing past `abs(u) = 0.3`, so every count below is conditional on it: 164 poles carry one zero of `Z`, 40 none and 8 two, of which 21 are the residue-null pole centres of the three full-set columns, leaving 143 poles with one zero of `zeta_F`, 61 with none and 8 with two. Every located tooth is found by a polar grid and not by the prediction, so no tooth is selected by the law it tests. Comparing afterwards, `miss2/miss1` has median `0.1637` with `miss2 < miss1` at 147 of the 151, and the accuracy is conditional on the tooth being close: the 43 teeth at `abs(u) < 0.1` have largest first-order miss `0.01446` and largest second-order miss `0.00164`, the 84 at `abs(u) < 0.2` have `0.10815` and `0.01526`, while the 31 at `abs(u) >= 0.3` reach `1.64614` and the prediction says nothing. The densest column is the sharpest: base 10 missing `9` at `fill/base = 0.9` locates 15 teeth to a largest first-order miss of `0.013602` and a median of `0.000841`. **Verified** ([lab/py/zeta-locus](../lab/py/zeta-locus/)).
- The full digit set is the column where that comb is empty and what is left is the critical line. `zeta` has one pole, `s = 1 = alpha`, so it is regular at every `s_(0,j)` with `j != 0` and the residue there vanishes as a one-line consequence rather than a measurement, the engine reading `1e-26` to `1e-33` there as its own control. The winding over `alpha - 0.92 < Re s < alpha + 3.02`, `0.02 < Im s < 40` then splits exactly as six zeros of `zeta` plus `floor(40 log base/2 pi)` cofactor-only teeth, those teeth being the zeros of `1 - base^(1-s)` on `Re s = 1` by exact arithmetic: `10 = 6 + 4` at base 2, `12 = 6 + 6` at base 3 and `14 = 6 + 8` at base 4. The six survivors read `Re s = 0.5` at `Im s = 14.1347251417, 21.0220396388, 25.0108575801, 30.4248761259, 32.9350615877, 37.5861781588` at all three bases, which share that zero set to `1e-26` because they are one arithmetic object. On a design the same split leaves a second family that is not a line at `alpha/2`: real parts run `-0.273079611` to `0.391038600` over the 7 zeros below `Im 40` at base 3 `{0,1}` against `alpha/2 = 0.3154648768`, `-0.30495894` to `0.28101268` over 6 zeros at base 4 `{0,1}` against `0.25`, and `0.060261843` to `0.97363028` over 5 zeros at base 16 `{0,1,2,3}` against `0.25`. The spread is the witness and no per-design mean is claimed. **Verified** ([lab/py/zeta-locus](../lab/py/zeta-locus/)).
- Which comb is stripped does not change what is left, and the next pole line's comb is forced by the first one's residues. For `m >= 1` the cofactor `Z_m(s) = zeta_F(s) prod_(i <= m)(1 - fill base^(-(s+i)))` has exactly the zeros of `Z` inside `alpha - 1 < Re s < alpha + 3.02`, since each extra factor vanishes only on `Re s = alpha - i` with `i >= 1`, so the survivors are one set under every comb. What `Z_m` adds is the level-`i` comb, and the level-one Laurent data is forced: `Z` is singular at `s_(1,j) = alpha - 1 + 2 pi i j/log base` through its `l = 1` term alone, and with `base^(-s_(1,j)-1) = 1/fill` and `1 - fill base^(-s_(1,j)) = 1 - base` the residue there is `r_(1,j) = s_(1,j) gamma_1 r_(0,j)/(fill(base-1))`, so the level-one comb is empty wherever the level-zero comb is, and at the full digit set `s_(1,0) = alpha - 1 = 0` kills it, which is `zeta` having no pole at `s = 0`; the generator prints `abs r_(1,0) = 0.0` with its null flag set and `abs r_(1,1) = 8.89623e-29` at the base 2 full set. **Proved** ([lab/py/zeta-family](../lab/py/zeta-family/), [lab/py/zeta-locus](../lab/py/zeta-locus/)).
- Stripping both combs at `rho = 0.45` over twenty-two designs gives 377 zeros wound by the argument principle, 351 located, 171 teeth of which 9 are level-one teeth, 19 cofactor-only zeros at null-residue poles and 161 second-family zeros, each design censused to its own printed height, `40` except the four base 3 designs at `42.894`, base 9 `{0,1,2}` at `41.464` and base 10 missing two at `25.923`. There is no gap at `rho` on a design: the distance from a second-family zero to the nearest live pole has minimum `0.45510938` at base 4 `{2,3}`, `0.45909168` at base 3 `{0,1}`, `0.48696667` at base 4 `{0,1,2}` and `0.50481072` at base 4 `{1,3}`, with base 4 `{2,3}` putting five of its eight inside `0.45 < abs(u) < 0.6`, so every count falls as `rho` rises, `N_2` reading `8, 7, 13, 9, 14` at `rho = 0.45` against `7, 6, 12, 8, 7` at `rho = 0.6`. The full digit set is where the gap exists: at base 2 the nearest live pole to a second-family zero is `14.143566` away and no radius below `0.9` moves any count. Where the located count falls short of the winding, base 4 `{2,3}` at 12 of 18 being the worst, `N_2` is a lower bound. **Verified** ([lab/py/zeta-family](../lab/py/zeta-family/), verb `tests`).
- The census needs no hand-chosen right edge, because a design zeta has an explicit zero-free half plane. With `a_min` the least nonzero digit, hence the least element of `S_F`, any real `sigma > alpha` with `a_min^sigma zeta_F(sigma) < 2` puts no zero in `Re s >= sigma`: the coefficients are nonnegative, so `abs(a_min^s zeta_F(s) - 1) <= a_min^sigma zeta_F(sigma) - 1 < 1` for every `Re s >= sigma`, and the hypothesis `sigma > alpha` is load bearing. On the grid `alpha + 0.05 n` the edge `sigma_1` reads `0.5` at base 4 `{1}` to `1.75` at the three full digit sets over twenty-four designs, `a_min^sigma zeta_F(sigma)` landing in `[1.8635, 1.9995]` with largest `sigma_1 - alpha` equal to `0.95`, so the `alpha + 3.02` strip of the locus sweep is three times wider than the zeros need. One real evaluation, carrying the ladder's own error bound. **Proved** ([lab/py/transport-census](../lab/py/transport-census/), verb `census`).
- Between the abscissa and that edge every proper design carries zeros and the full digit set carries none. On `alpha + 1e-6 < Re s < sigma_1` the argument principle counts `157` zeros below `Im s = 40` over twenty-three designs, all `157` located, plus `2` at base 50 missing one digit below `Im s = 4`; twenty-one of the twenty-four designs carry one, and the three that do not are the base 2, 3 and 4 full digit sets, whose windings read `-1.97e-33`, `1.73e-33` and `1.53e-33`. The count is exact on the box and a lower bound for the half plane, the sliver `alpha < Re s <= alpha + 1e-6`, the band `0 < Im s < 0.02`, everything above the height and the conjugate half plane all uncounted. Each rightmost carries the height it is read below, since the level-zero teeth drift right with the pole index: base 20 missing one digit reads `1.000285484146` at `Im s = 2.0988`, `1.000549674321` at `4.1971` and `1.002685494779` at `14.6920`. Below `Im s = 40` the rightmost real parts run `0.441505537191` at base 5 `{0,1}` to `1.002685494780` at base 20 missing one digit, each certified by a winding `1` box of half width `5e-5` whose sampled contour minimum, `1.2e-4` to `6.1e-3`, beats the engine's bound by at least eight orders of magnitude and whose distance to the pole lattice is at least `0.00517845`, one hundred box half widths, base 20 missing one digit standing off at `0.0223021` and four hundred of them. **Verified** ([lab/py/transport-census](../lab/py/transport-census/), verb `census`).
- A positive Rouche margin turns a resolved tooth into a proved one, with every input bounded from the digit recursion itself. At a pole `s_0` of nonvanishing residue write `Z(s_0+u) = P(u) + T(u)`, `P` entire with Taylor coefficients the exact finite sums `sum_n n^(-s_0)(-log n)^m/m!` convolved against those of `1 - e^(-lambda u)`, and `T` the `l >= 1` part of the ladder numerator, bounded on `abs(u) <= R_2` by `B_T = sum_(l >= 1) binom(abs(s_0)+R_2+l-1, l) base^(-sigma-l) gamma_l G(sigma+l)` at `sigma = Re s_0 - R_2`. That `l` sum is closed by a majorant ratio and not an observed one, the term ratio not being monotone: `gamma_(l+1)/gamma_l <= a_max` and `G(sigma+l+1)/G(sigma+l) <= base^(-(P-1))` because every string in the pools is at least `base^(P-1)`, so the term ratio is at most `R_l = ((abs(s_0)+R_2+l)/(l+1)) a_max base^(-P)`, decreasing in `l` once `abs(s_0)+R_2 >= 1` and below `a_max base^(-P)` otherwise, and stopping at the first `l` with `R_l < 1` and adding `term_l R_l/(1-R_l)` is a proof. Then on `abs(u) = rho`, with `tau = rho/R_2`, `abs(Z - (Z_0 + Z_1 u)) <= sum_(m >= 2) abs(P_m) rho^m + B_T tau^2/(1-tau)` against `abs(Z_0 + Z_1 u) >= abs(Z_1) rho - abs(Z_0)`; strict inequality gives `Z` the linear model's zero count, and that count is one because the same inequality forces `abs(Z_0/Z_1) < rho`. No step uses a differenced quantity, `Z_1` being the first Fourier mode of `T` on a circle of radius `R < R_2` with aliasing at most `(B_T/R_2)(R/R_2)^N/(1-(R/R_2)^N)`. **Proved** ([lab/py/zeta-locus](../lab/py/zeta-locus/), [lab/py/design-zeta](../lab/py/design-zeta/)).
- Run with the peel depth raised at each pole until the certificate fires or the string pool caps, that margin certifies exactly one zero at eleven poles of 106 at base 3, base 5, base 9, base 16 and base 10 missing `9` to `Im s = 40` inside a fifteen minute budget: 11 certified, 60 failed, 7 residue-null and excluded because there the model's zero is the pole centre, and 28 skipped on budget. The eleven, with depth, margin and radius: base 3 `{0,1}` `j = 2` at `P = 7`, `0.13418242`, `rho = 0.205`; `j = 5` at `P = 7`, `0.028140545`, `0.16`; `j = 7` at `P = 9`, `0.00082974181`, `0.175`; base 5 `{0,1}` `j = 4` at `P = 7`, `0.15035818`, `0.2775`; `j = 5` at `P = 7`, `0.12269904`, `0.295`; base 9 `{0,1,2}` `j = 5` at `P = 5`, `0.038456894`, `0.26`; and base 10 missing `9` at `j = 1, 2, 3, 4, 7`, all at `P = 3`, margins `0.047105507`, `0.030062806`, `0.045802462`, `0.043508323`, `0.046292701` at radii `0.1275, 0.105, 0.1025, 0.09, 0.0725`, each on 24 contour samples. Every certified disc agrees with the argument principle's count of one and none disagrees; of the 19 poles carrying zero or two zeros in `abs(u) < 0.45` that the budget reached, none certifies, the two double poles reached both failing. The lever is peeling and not a sharper majorant: at base 10 the automatic depth `P = 2` gives `B_T` from `1.08` to `38.1`, and `P = 3` gives `0.2096` to `1.2010`. Proximity is no threshold, the certified `abs(Z_0/Z_1)` running `0.0282669` to `0.149708` while base 3 `{0,1}` `j = 7` at `0.104443` fails at `P = 7` and certifies at `P = 9`. The margins are evaluated in high precision and not in ball arithmetic, which is the one step short of Proved. **Verified** ([lab/py/zeta-locus](../lab/py/zeta-locus/), verb `rouche`).
- The locus obeys no law in the design's coarse invariants. There is no curve `Re s = f(Im s)` shared by designs of equal `alpha`: base 4 `{1,2}` and base 16 `{0,1,2,3}`, both `alpha = 1/2`, hold zeros `0.015058` apart in `Im s` near `Im s = 4.72` and `0.817047` apart in `Re s`, and equality of `fill/base` as well fixes nothing, base 4 `{0,1}` against `{2,3}` giving `0.0136014` against `0.719693` near `Im s = 17.64`. Within one design the worst real-part gap between two zeros of equal `frac(Im s log q/2 pi)` runs `0.077591803` at base 10 missing `9` to `0.65632474` at base 3 `{0,1}`, so the fractional part fixes nothing either. The single exception is `alpha = 1`, where the full digit sets at bases 2, 3 and 4 are one arithmetic object and do share every zero. **Refuted** ([lab/py/zeta-locus](../lab/py/zeta-locus/)).
- The pole lattice does not force the zeros either, so the vertical period of the poles is no symmetry of the function. At base 3 `{0,1}` the two polished zeros right of the abscissa sit at `0.665639628004 + 23.0347504431 i` and `0.720787601477 + 28.6056765649 i`, an ordinate gap of `5.5709261` against the pole period `2 pi/log 3 = 5.7192017`, short by `0.148`. The factor `1 - fill base^(-s)` is exactly `2 pi i/log base` periodic, and so is `E_1` at a design whose only nonzero digit is `1`, but the shifted terms `sum_(l >= 1) binom(-s,l) base^(-s-l) gamma_l zeta_F(s+l)` are not, so `zeta_F` is not periodic and its zeros carry what the lattice cannot. **Refuted** ([lab/py/zeta-locus](../lab/py/zeta-locus/), verb `census`).
- There is no counting law for the second family in `alpha` or in the fill, at either radius. The four base 4 two-digit designs share `alpha = 1/2` and `fill/base = 1/2` exactly and give `N_2(40) = 7, 13, 9, 14` at `rho = 0.45` and `6, 12, 8, 7` at `rho = 0.6`, with `N_2(80) = 20, 30, 22, 29` and `17, 26, 21, 20`: a factor of two at one `alpha` and one `fill/base` at both radii, so the refutation is radius-robust even though the integers are not. What spreads is comb occupancy and not the second family, base 4 `{0,1}` and `{2,3}` differing by 29 percent in total winding, 14 against 18, and by a factor of two in `N_2` because 7 of 8 poles are occupied against 4 of 8. Read as `N_2(T) = c_F T log T + d_F T` from the two heights, `c_F` at `alpha = 1/2` is `0.10820213, 0.072134752, 0.072134752, 0.018033688`, spread `0.09016844`, against the base 3 and base 4 full-set controls `0.15486803` and `0.16230319`, the classical `1/(2 pi) = 0.15915494` and a control spread of `0.0074351582`. Every winding is the nearest integer to a numerically integrated phase whose largest surviving step runs `0.9205` to `0.9998` against a cap of `1`, so the counts are measured and not certified. **Refuted** ([lab/py/zeta-family](../lab/py/zeta-family/), verbs `tests` and `count`).
- The second family is not symmetric about any vertical line `Re s = c_F` either. Reading `c_F` as the midpoint of the real parts of the two second-family zeros of least `Im s` and testing the rest, no second-family zero in any design has a reflection partner: the reflection branch needs two zeros within the `0.05` test tolerance in `Im s` and the smallest ordinate gap inside a design is far above that, so the branch cannot fire. Every pair the sweep records is a self-pair, and self-pairs occur below the chance rate: over ten recensused designs the tally is 8 self-pairs and 0 reflection partners of 47 zeros tested, a rate of `0.170213` against the `0.229904` that drawing each real part uniformly from that design's own observed band predicts, and 22 of 117 over the full sweep. The three full-set controls pair 13 of 13 at `c_F = 1/2` to `1e-22`, where the functional equation makes every zero its own partner. `c_F` is not a quantity either: `c_F - alpha/2` runs `-0.28413232` to `+0.47788515` and `c_F - 1/2` runs `-0.78413232` to `+0.28664994`, so it is not `alpha/2`, not `theta(F)` and not `1/2`. **Refuted** ([lab/py/zeta-family](../lab/py/zeta-family/), verb `symmetry`).
- Nor do the real parts contract to `alpha/2` as a design fills, so the critical line is not the `alpha -> 1` limit of this tree. Undivided, `max abs(Re s - alpha/2)` stays flat along the ladder carrying `alpha` toward 1, reading `0.2275679549` at base 5 `{0,1}`, `0.5549589411` at base 4 `{0,1}`, `0.5885444877` at base 3 `{0,1}`, `0.4233198337` at base 4 `{0,1,2}`, `0.5365616661` at base 5 `{0,1,2,3}` and `0.3151426744` at base 10 missing two, then collapsing to `1.43e-22`, `1.10e-21` and `1.76e-22` at the base 2, 3 and 4 full sets. At base 10 missing `9` the second family reads `0.216084781875` to `0.70401657869` about `alpha/2 = 0.477121255`, a band of width `0.488` against `1 - alpha = 0.0458`. Divided by `1 - alpha` the statistic runs `0.39971647` to `5.7047812` with no monotone in `alpha`, falling from `3.8699872` to `3.2519104` on the last two rungs, so the refutation rests on the undivided spread and not on the ratio. **Refuted** ([lab/py/zeta-family](../lab/py/zeta-family/), verb `limit`).
- One law does survive the fill, and it is about the heights rather than the real parts. Against the derived null of a quarter of the mean gap between consecutive `zeta` ordinates in the range, the exact expectation for an equally spaced ordinate set of the same density and conservative for one with gap variance, the mean distance from a second-family ordinate to the nearest `zeta` ordinate divided by that null falls monotonically in `alpha` over seven rungs: `2.0495374` at base 5 `{0,1}` with `alpha = 0.430676558`, `1.8953371` at base 4 `{0,1}` with `0.5`, `0.75419266` at base 3 `{0,1}` with `0.630929754`, `0.51648744` at base 4 `{0,1,2}` with `0.792481250`, `0.32356636` at base 5 `{0,1,2,3}` with `0.861353116`, `0.090501352` at base 10 missing two with `0.903089987` and `1.0429899e-23` at the base 2 full set. The base and fill confounds are dead: the fall is monotone at fixed base, `2.0495374` to `0.32356636` inside base 5 and `1.8953371` to `0.51648744` inside base 4, and at fixed fill 2 across bases; the nulls move only `1.0425839` to `1.3595166` across the ladder while the raw mean distance falls `2.4032315` to `0.12303809`, so the denominator does not drive it. Over the same designs `mean abs(Re s - 1/2)` reads `0.36482392, 0.39426128, 0.3901396, 0.25540269, 0.31452367, 0.20473972` and `2.4065966e-23` and does not fall monotonically: at `alpha = 0.903` the heights are pinned to `2.3` percent of the mean gap while the real parts are still `0.20` off `1/2`. A filling design finds `zeta`'s ordinates before its real parts find `1/2`. `alpha` is a trend and not a function, the four base 4 two-digit designs at one `alpha = 1/2` spreading `0.79050661` to `2.8404536`, and the matching is nearest-ordinate and not injective, 3 distinct ordinates for 4 design zeros at base 10 missing two. **Verified** ([lab/py/zeta-family](../lab/py/zeta-family/), verb `limit`).
- That shadow is a first-order perturbation and its constant-free form is a Newton step. The discrete position identity `1_(D_level)(n) = base^(-level) sum_(a mod base^level) G_level(a/base^level) e(-n a/base^level)` on `0 <= n < base^level` gives `zeta_(F,level)(s) = base^(-level) sum_(a mod base^level) G_level(a/base^level) S_level(s, a/base^level)`, reproduced from the transform to `1.236e-37` at `level = 2` over ten designs, and since `G_level(0) = fill^level` the `a = 0` fibre carries the weight `(fill/base)^level` exactly against the partial sum of `zeta` to `base^level`, with no arc and no limit. That splits a polynomial at level `level` against a TRUNCATED zeta while the object is the continued `zeta_F` against the full one, and `(fill/base)^level` falls to `0` with `level` while both series tend to `1` on the right, so no level is forced and `c = fill/base` is the `level = 1` reading and a definition. For any `c` the split `zeta_F = c zeta + E_F` gives `E_F(rho_0) = zeta_F(rho_0)` at a zero `rho_0` of `zeta`, an identity carrying nothing about `c`, and a first-order zero of `zeta_F` at `rho_0 - zeta_F(rho_0)/(c zeta'(rho_0))`; reading `c zeta'(rho_0)` as `zeta_F'(rho_0)` removes the constant and leaves `rho_0 - zeta_F(rho_0)/zeta_F'(rho_0)`, Taylor at a simple zero. The continuous form, the mass of `G_level` on `abs(t) < 1/(2 base^level)`, is the exact sinc sum `1/base^level + sum_(n in D_level, n > 0) sin(pi n/base^level)/(pi n)` and equals `kappa_level(F) (fill/base)^level` with `kappa_level` running `0.6015221` to `0.96774464` at `level = 1, 2, 3`, so it adds no constant the fibre does not give. **Proved** ([lab/py/zeta-shadow](../lab/py/zeta-shadow/) verb `mass`, [lab/py/mrly-euler](../lab/py/mrly-euler/) verb `position`).
- The constant-free step predicts the design zero attached to each zeta zero, and it sharpens as the offset shrinks. Over nine designs at twelve zeta zeros to `Im s = 56.4462476971`, six to `Im s = 37.5861781588` at the two densest so the rungs do not share one height, both predictions come from `zeta_F(rho_0)`, `zeta_F'(rho_0)`, `zeta'(rho_0)` and the digit density alone and the zero is located afterwards by Newton, accepted only at `abs(zeta_F) < 1e-16`, within `1.5` of `rho_0` and `0.02` clear of the pole lattice, largest ladder bound `9.001e-23`. The step's median ratio reads `1.3843088, 1.284225, 1.2481449, 1.2060106, 1.2042502, 0.89075541, 1.0195598, 1.005076, 0.99741809` at `alpha = 0.430676558` up to `0.994835739`, largest `abs(ratio - 1)` being `0.14041` at base 20 missing one digit and `0.01734` at base 50 missing one digit, bands `[0.94875, 1.14041]` and `[0.98266, 1.01144]`; pooled, that largest deviation runs `0.01734, 0.0508884, 0.193158, 0.83912, 3.32327` over the buckets `abs off < 0.05, < 0.1, < 0.2, < 0.4` and above, on `7, 4, 14, 18, 44` zeros. The `level = 1` reading `c = fill/base` is the looser column, median ratio `1.4129353, 1.2842149, 1.0955991, 1.1806066, 1.1372453, 1.276577, 1.1347487, 1.0320127, 1.0507079`, largest `abs(ratio - 1)` `0.24964` and `0.0821168` at the two dense rungs, five times looser at base 50, and the coupling does not select it either, `median abs(coupling - fill/base)` reading `0.24057225` and `0.08291158` against `median abs(coupling - 1)` `0.27619434` and `0.079335871`, a flip between two rungs whose candidates differ by `0.05` and `0.02`. Nine zeros at the three sparsest designs have no located zero inside the trust region, predicted offsets `0.95618855` to `3.0967393`, so those medians are conditioned on Newton succeeding; the base 2 full set is the exact control, `abs(zeta_F(rho_0))` between `1.85e-34` and `1.329e-25` at all twelve zeros. **Verified** ([lab/py/zeta-shadow](../lab/py/zeta-shadow/), verb `predict`).
- The paired offset carries its exponent in the missing-digit density and not in `1 - alpha`. The median paired offset over `m/base = 1 - fill/base`, with `m` the number of missing digits, reads `1.6463532, 1.2495026, 1.8345578, 1.5731321, 2.2102406, 1.6634381, 2.2424916, 1.8779239, 1.051349` across the nine rungs and over `1 - alpha` reads `1.7350628, 1.2495026, 1.6569184, 1.8951686, 3.1883019, 3.432954, 4.9008186, 5.4839111, 4.0716338`; a least squares in the logs, a fit and not a theorem, gives `(m/base)^1.04544` at `R2 0.957842` against `(1-alpha)^0.71691` at `R2 0.944011`, the first column spanning `2.13297` and the second `4.38888`, so `m/base` carries the exponent by a factor of `2.05764` inside the `4.28797` that `(1-alpha)/(m/base)` itself spans, which is the whole discrimination these two normalisations admit. The two new rungs are base 20 missing its top digit at `alpha = 0.9828778777` and base 50 missing its top digit at `0.9948357391`, all six zeros located at each, median `abs(E_F(rho_0))` `0.11830158` and `0.028066806` and median offset `0.093896196` and `0.021026979`. Read in the family row's form the mean distance over a quarter of the mean gap gives `0.81218635, 0.57141859, 0.50488757, 0.37447728, 0.20954319, 0.29197634, 0.14794812, 0.052888241, 0.011098646` and `0` at the full set; the pairing is zeta-zero-first where the family row is design-zero-first, so this is a parallel ladder and not that row recomputed, it bounds no maximum over the second family and touches no jump clause. **Verified** ([lab/py/zeta-shadow](../lab/py/zeta-shadow/), verb `rungs`).
- What it does not do is explain why the ordinates converge before the real parts, because at the zeros it pairs it separates neither. The first-order offset is one complex number, so a paired zero moves isotropically and the ordinate offset and the real-part offset are one quantity with no preferred phase: per zero `abs(Im off)/abs(Re off)` spans `0.137681` to `6.11895` at base 20 missing its top digit and `0.14167` to `18.7749` at base 50, and rung by rung `median abs(Im off)` against `median abs(Re s - 1/2)` reads `0.55734029/0.43095421, 0.49670656/0.28603903, 0.48081533/0.22535435, 0.30633741/0.16748977, 0.12823995/0.36138728, 0.25093621/0.12181102, 0.11574693/0.19332005, 0.058239278/0.049215607, 0.011954894/0.010995712`, the ordinate offset larger on seven rungs and smaller on two, at rungs 5 and 7, with both falling broadly and neither monotone. The law binds only the zeros Newton reaches from a `zeta` zero inside `1.5` of it and enumerates no design zero, so the ordinate shadow of the family row is what a PAIRED zero does and the unpartnered second family is the surplus; the two are consistent with a mixture that approaches in both coordinates on the partnered zeros and not at all on the rest, and that mixture has no witness until the unpartnered count is measured. **Refuted** ([lab/py/zeta-shadow](../lab/py/zeta-shadow/) verb `rungs`, [lab/py/zeta-family](../lab/py/zeta-family/) verb `limit`).
- The one statistic the transport theorem reads obeys no law either: the gain of a design's rightmost zero over its abscissa is not a function of `alpha` and `fill/base`. Four equal-key families, one base and one digit count each so both agree exactly and not to a rounding, read unequal gains: at `alpha = 1/2`, `fill/base = 1/2` the four base 4 two-digit designs give `0.0853043873, 0.4400124317, 0.2706238545, 0.3439264581`, a spread of `0.35470804`; base 5 at `alpha = 0.4306766`, `fill/base = 0.4` spreads `0.37474232`; base 3 two-digit at `alpha = 0.6309298` spreads `0.17605693`; base 4 three-digit at `alpha = 0.7924813` spreads `0.060972003`, still six hundred box widths. The two columns disagree in direction, the gain being largest at the sparsest designs, `0.5291214025` and `0.4485242462` at `alpha = 0`, where the rightmost real part itself is smallest. What rises with `alpha` is the floor: the least rightmost real part per rung reads `0.4485242462, 0.4415055372, 0.5853043873, 0.7207876015, 0.9126562295, 0.9897481059, 1.0015143877, 1.0015892753, 1.0026854948, 1.0000614750` up ten rungs, rising at every step but the first and the last, the last being where the census height drops from `40` to `4`; one design per rung above `alpha = 0.86` against six at `alpha = 0.5`, and no fit is taken. **Refuted** ([lab/py/transport-census](../lab/py/transport-census/), verb `law`).

## THE WALL AND THE PRODUCTS

- The indicator of `S_F` is multiplicative exactly at the full digit set, and the wall is constructed rather than described. `1 in F` is forced by `f(1) = 1`; if a digit `c >= 2` is missing take the least, and `R_c R_(c+1)` has no carry because its `base^m` coefficient is `min(m+1, c, 2c-m) <= base-1`, so its digit set is exactly `{1..c}` while `gcd(R_c, R_(c+1)) = R_1 = 1`; if only `0` is missing then an odd base gives the coprime pair `(2, (base^2+1)/2)` and an even base the coprime odd pair `(base^2-1, base^2+1)`, whose products leave the set. Over all 8177 sets with `2 <= base <= 12` the constructed witness is asserted at each of the 4083 sets that pass `f(1) = 1` and are not full, and an independent search finds a minimal witness for every one, hardest base 12, `F = {1}`, pair `(5, 377)`. No design outside the full set carries an Euler product over primes. **Proved** ([lab/py/mrly-euler](../lab/py/mrly-euler/), verb `wall`).
- The polynomial model does not transport Weil's theorem, and the wall's first case is exactly where it breaks. Evaluation `P -> P(base)` carries the polynomials with coefficients in `{0..base-1}`, the model `F_base[t]` at prime `base`, bijectively onto the nonnegative integers and adds correctly only where no carry occurs: a coefficient of the polynomial product `P R` reaches `(base-1)^2 (min(deg P, deg R) + 1)`, far above the digit cap `base - 1`, so the digit string of an integer product is the carry reduction of the polynomial product and not that product, and `R_c R_(c+1)` is that failure made minimal, the shortest coprime pair whose carry-free product shows the missing digit `c`. Multiplication in `F_base[t]` reduces its coefficients mod `base` and never carries while the integer product does, so the Riemann hypothesis proved over a function field reaches `zeta_F` along no evaluation bridge, and no other route is spoken to; the density side of the same substitution is [coprime](coprime.md). **Proved** ([lab/py/mrly-euler](../lab/py/mrly-euler/), verb `wall`).
- What stands in its place is a product over digit positions rather than over primes. With `G_level(t) = prod_(i<level) sum_(d in F) e(d base^i t)`, one factor per position, uniqueness of the base expansion gives `int_0^1 G_level(t) e(-nt) dt = 1_(D_level)(n)` for every integer `n`, hence `sum_(n in D_level, n >= 1) a(n) n^(-s) = int_0^1 G_level(t) A(s,t) dt` with `A(s,t) = sum_(n >= 1) a(n) e(-nt) n^(-s)`, for every absolutely convergent Dirichlet series at once. Taking `a = 1` returns `zeta_F` against the periodic zeta of [DLMF 25.13](https://dlmf.nist.gov/25.13); taking `a = mu` returns the design's Mobius series against the Lerch-Mobius series. The set enters through the digit positions and the arithmetic sits entirely in the kernel; they meet only under the integral. Checked to `1.95e-16` and `2.04e-16` at base 10 missing `9`, `level = 3, 4`, and `2.9e-16` at base 3 `{0,1}`, `level = 3, 4, 5`. **Proved** ([lab/py/mrly-euler](../lab/py/mrly-euler/), verb `position`).
- Read at `x = base^level` the pairing is exact on a finite grid, `M_F(base^level) = base^(-level) sum_(a mod base^level) G_level(a/base^level) S_level(a/base^level)`, both factors trigonometric polynomials of degree below `base^level`, and its `l^1` mass decomposes level by level as `C_level = sum_(j=0)^level fill^(level-j) c_j`. The floor `C_j >= base C_(j-1)` forces the top-level share `c_level/C_level >= 1 - fill/base` at every base and digit set, measured `0.485846, 0.602606, 0.687994, 0.510055` against floors `0.333333, 0.500000, 0.600000, 0.100000`, with the levels `j >= level/2` carrying `0.995116, 0.996061, 0.997043, 0.942350` of it. So weighting the Mobius input per denominator saves exactly `log_base(C_level/c_level)/level`, a constant factor capped by `base/m`, the numerator reading `0.657068` at base 3 `{0,1}` identically at every `level = 6..14`: the mass is where the method cannot spend it. **Proved** ([lab/py/mrly-pairing](../lab/py/mrly-pairing/), verb `split`).
- The large sieve does not rescue that split on the major arcs of any design below the full set, and the exact second moment prices it. Writing `a = base^v a'` with `base` not dividing `a'` and `j = level - v`, the `l^2` mass of the grid pairing over the levels `j <= J` is exactly `fill^(2 level - J) base^J`, since `G_level(a/base^level) = fill^(level-j) G_j(a'/base^j)` and Parseval on `Z/base^J` gives `sum_(a mod base^J) abs(G_J(a/base^J))^2 = base^J fill^J`. Those `base^J` points are `base^(-J)` spaced, so the spacing form of [Montgomery and Vaughan 1973](https://doi.org/10.1112/S0025579300004708) applies at every base, including the composite ones where an `a'` not divisible by `base` need not be coprime to it and the coprime-residue form misses the point, and it gives `sum_(j <= J) sum_(a') abs(S_level)^2 << (base^level + base^J) base^level`. With `x = base^level` the levels below `J = u level` then cost `x^(alpha + u(1-alpha)/2)`, which under the hypothesis `alpha < 1` is strictly above `alpha` at every `u > 0`, equals `alpha` only at `u = 0`, and returns the whole-grid value `(alpha + 1)/2` at `u = 1`; at `alpha = 1` it is `alpha` at every `u`, so the full digit sets witness nothing here. **Proved** ([lab/py/mrly-pairing](../lab/py/mrly-pairing/), verb `split`).
- The principal fibre of that grid is [the classical Mertens function](/wiki/mertens-function/) and it is asymptotically too small. The `a = 0` term is `base^(-level) fill^level M(base^level)`, of exponent `alpha - 1/2` under RH, and `alpha - 1/2 < alpha/2` for every `alpha < 1`, so in the limit `M` cannot carry the conjectured size of the design meter. At finite depth it carries a great deal: shares `-0.028961, 0.018555, -0.006583, 0.408208` at base 3 `{0,1}` at `level = 14`, base 4 `{0,1}` at `level = 11`, base 5 `{0,1}` at `level = 9` and base 10 missing `9` at `level = 6`, and exactly all of the meter on the two full-set controls. The exponent gap at base 10 missing `9` is `0.454243` against `0.477121`, and a factor of `10` between them needs `x = 10^44`. **Proved** ([lab/py/mrly-pairing](../lab/py/mrly-pairing/), verb `split`).
- The design does carry an exact Euler product, and it is the one with nothing in it. On the free monoid over `F` with norm `N(w) = base^(abs(w))`, `sum_w N(w)^(-s) = 1/(1 - fill base^(-s)) = prod_(level>=1) (1 - base^(-level s))^(-c_fill(level))` with `c_fill(level)` the Lyndon count, by Chen-Fox-Lyndon: every word factors uniquely as a non-increasing product of Lyndon words, so the free monoid on `F` is equinumerous by norm with the free abelian monoid on Lyndon words and is not equal to it. Its primes are the Lyndon words, it is zero free, its Mobius is supported on the empty word and the letters so its Mertens is `1 - fill` beyond norm `1`, and its poles are exactly the design pole lattice. All RH content of `zeta_F` therefore sits in the cofactor `Z`, which is what the census reads. Expansion verified through `u^16` at `fill = 2, 3, 4, 9, 10`, `c_2(level)` being [A001037](https://oeis.org/A001037). **Proved** ([lab/py/mrly-euler](../lab/py/mrly-euler/), verb `word`).
- Inside the design there is a third product, genuinely over primes, and it lives on a different set: the free semigroup `N_F` on [the primes](/wiki/prime-numbers/) that lie in `S_F`, a Beurling system with its own Mobius and its own RH-shaped question. It is blind to whole columns. If `gcd(F) = a > 1` then every element of `S_F` is a multiple of `a`, so when `a` is prime the design's primes are `{a}`, `N_F` is the powers of `a` and `M_B(x) = 0` for `x >= a`, and when `a` is composite the design holds no prime at all, `N_F = {1}` and `M_B` is identically `1`, witness base 10, `F = {0,4,8}`. The eight scaled census families of [mobius](mobius.md) are exactly the columns the Beurling route cannot see and the scaling transfer reads exactly. **Proved** ([lab/py/mrly-euler](../lab/py/mrly-euler/), verb `beurling`).
- The Beurling census to `x = 10^6` says the same thing in numbers, and it reads a level rather than a trend. Base 3 `{0,2}` has the single prime `2` and `M_B` identically zero past it; base 3 `{0,1}` has `525` primes, `N_F(920483) = 2198`, running `max abs(M_B) = 98` and exponent `0.3339` against `alpha/2 = 0.3155`; base 10 missing `9` has `35139` primes, `N_F(10^6) = 488864` against `x^alpha = 531441`, `M_B(10^6) = 1860`, running max `1866`, and `log(running max)/log x` reading `0.4203, 0.4882, 0.5452` at `10^4, 10^5, 10^6` against `alpha/2 = 0.4771`, where full base 10 as control reads `0.4084, 0.4241, 0.4276` against its own `alpha/2 = 0.5`. That is `+0.068` over `alpha/2` for the design against `-0.072` for the control, with a running maximum climbing in both: there is cancellation, `0.545` against the trivial `alpha = 0.954`, and it sits above `alpha/2`, so the census supports cancellation on `N_F` and does not support the design's own square-root shape. `N_F` is not `S_F`. Full base 10 reproduces `-23, -48, 212`, [A084237](https://oeis.org/A084237). **Verified** ([lab/py/mrly-euler](../lab/py/mrly-euler/), verb `beurling`).

## THE IDENTITY

- One identity does survive the wall, and it is not `zeta M = 1`. For every base and `F` with `1 in F` the indicator of `S_F` has a Dirichlet inverse `nu_F`, given by `nu_F(1) = 1` and `nu_F(n) = -sum_(d divides n, d > 1, d in S_F) nu_F(n/d)`, so `zeta_F(s) N_F(s) = 1` with `N_F(s) = sum nu_F(n) n^(-s)`, and `nu_F` is `mu` exactly at the full digit set, where the classical identity is the special case. The support of `nu_F` lies inside the multiplicative semigroup generated by `S_F` and strictly inside it: `9`, `27` and `36` lie in the semigroup with `nu_F = 0` while `16`, `48` and `52` lie in the semigroup and outside `S_F`. So a design carries four sets, not two: `S_F`, the Beurling integers on the primes of the design, the semigroup, and the support of `nu_F`. Checked against `mu` term for term to `n = 131072` at base 2 and `n = 177147` at base 3. **Proved** ([lab/py/mrly-pairing](../lab/py/mrly-pairing/) verb `inverse`, [lab/py/design-zeta](../lab/py/design-zeta/)).
- That identity is a one-way bridge from the zeros to the design's own Mertens function, and it runs the wrong way for the hypothesis. If `rho` is a zero of `zeta_F` with `Re rho > alpha` then `sigma_c(N_F) >= Re rho`, by the identity theorem on the connected pole-free half plane `Re s > max(sigma_c(N_F), alpha)`, so `sum_(n <= x) nu_F(n)` is not `O(x^(Re rho - eps))` for any `eps > 0`; the converse bound `sigma_c(N_F) <= sup Re rho` is not claimed. The partial sums of `N_F(sigma)` meet `1/zeta_F(sigma)` to `1.60e-3` at `sigma = 0.8008` and `1.96e-4` at `sigma = 0.9208` at base 3 `{0,1}`, and to `1.72e-2` at `sigma = 1.0816` and `2.39e-3` at `sigma = 1.2016` at base 10 missing `9`, both offsets sitting above `Re rho`. **Proved** ([lab/py/mrly-pairing](../lab/py/mrly-pairing/) verb `inverse`).
- Two of the censused zeros are certified by winding, and they turn that bridge into anti-cancellation. The argument principle gives winding `1` on `Re in [0.72074, 0.72084]`, `Im in [28.60563, 28.60573]` at base 3 `{0,1}`, contour minimum `abs(zeta_F) = 8.298e-4` against the engine bound `6.284e-30`, and winding `1` on `Re in [1.00150, 1.00168]`, `Im in [2.73915, 2.73925]` at base 10 missing `9`, contour minimum `6.865e-4` against `2.798e-23`, while the control rectangle `Re in [0.99900, 1.00050]`, `Im in [2.73810, 2.74030]` there returns winding `0`. Both boxes lie strictly right of `alpha = 0.6309297536` and `0.9542425094`, so `sum_(n <= x) nu_F(n)` is not `O(x^(0.72074 - eps))` and not `O(x^(1.00150 - eps))` respectively: the limsup of the design's own Mertens function exceeds the design's own mass, and at base 10 missing `9` exceeds `x` itself, the box lying right of `Re s = 1`. **Proved** ([lab/py/mrly-pairing](../lab/py/mrly-pairing/) verbs `box` and `inverse`, [lab/py/design-zeta](../lab/py/design-zeta/)).
- The square-root shape is therefore false for `nu_F`, and the census is far below both limsups at every depth reached, which is what a limsup statement allows: `max/A_F = 0.0738` at base 3, `level = 16` and `max/x = 0.0847` at base 10, `level = 7`, the running maximum of `sum nu_F(n)` growing by `9.4474, 11.5000, 10.2220, 10.0354` per level at base 10 missing `9`, `level = 4..7`, against `base^(Re rho) = 10.036661` and the trivial fill 9, only the last of the four landing on the predicted rate, with `max/A_F(base^level)` rising `0.1043, 0.1094, 0.1398, 0.1588, 0.1771`; at base 3 `{0,1}` the geometric mean of the four steps `level = 12..16` is `2.059` against `2.207512` and `2` while the arithmetic mean of the five printed level ratios is `1.9972`, a census too short to separate them. **Proved** ([lab/py/mrly-pairing](../lab/py/mrly-pairing/) verbs `box` and `inverse`).
- One certified zero right of the abscissa refutes every square-root-shaped bound for the design's own Mobius, and the digit `1` is the hypothesis that bites. Let `1 in F`, let `rho` be a zero of `zeta_F` certified by a winding `1` box with left edge `x_0 > alpha` containing no pole. Transport gives `sigma_c(N_F) >= Re rho >= x_0 > alpha`, so `sum_(n <= x) nu_F(n)` is not `O(x^(x_0 - eps))` for any `eps > 0`; since `A_F(x)` has exponent `alpha` the conjectured exponent is `alpha/2 <= alpha < x_0`, so `nu_F` misses even the trivial `O(x^(alpha - eps))`, the first inequality failing to be strict only at the two designs with `alpha = 0`, where `A_F(x)` grows like `log x`. Nineteen of the twenty-four designs censused meet all three hypotheses and get a bound, seventeen of the twenty-two the locus and family sweeps carry, running `theta(nu_F) >= 0.4414555` at base 5 `{0,1}` to `theta(nu_F) >= 1.0026354` at base 20 missing one digit. Four have `Re rho > 1`, so their own Mobius outruns the count of ALL integers below `x`: base 10 missing two digits, base 10 missing `9`, base 20 missing one digit and base 50 missing one digit, at `fill/base = 0.8, 0.9, 0.95, 0.98`, three censused to `Im s = 40` and base 50 to `Im s = 4`, and only the SIGN of `Re rho - 1` is read and never its size. It is not a `k/q` effect: base 5 `{0,1,2,3}` at the same `fill/base = 0.8` has rightmost `0.989748105861`. Two designs carry a zero right of `alpha` and no bound, base 4 `{2,3}` and base 4 `{0,2,3}`, which omit the digit `1`, so the indicator vanishes at `1` and `nu_F` does not exist. **Proved** ([lab/py/transport-census](../lab/py/transport-census/), verb `law`).
- So the design's own Mobius is not the object the hypothesis is about. The square-root shape on a design can only be carried by `mu` restricted to `S_F`, the meter of [mobius](mobius.md), and the decoupling is what protects it: `zeta M = 1` on the full set, `S_F` is not multiplicatively closed for any proper `F`, and `zeta_F M_F` is not `1`, so no known route runs from a zero of `zeta_F` to the meter's exponent and the zero census carries no bound on it. What survives is not the zeros but the position product, which pairs `a = 1` and `a = mu` alike. [Coons 2010](https://doi.org/10.5802/jtnb.718) Theorem 2.3, that `mu` is not `k`-automatic for any `k`, rules out the automatic-continuation route to the Mobius series and nothing wider. **Proved** ([mobius](mobius.md), [lab/py/design-zeta](../lab/py/design-zeta/), [lab/py/mrly-euler](../lab/py/mrly-euler/)).
- The obvious repair, gluing the two series anyway and calling the remainder small, gains nothing: writing `zeta_F M_F = 1 + D_F`, the abscissa of `D_F` is exactly `alpha`. Absolute convergence of `zeta_F^2` puts `sigma_a(D_F) <= alpha`, and if `sigma_c(D_F)` were below `alpha` then `M_F(sigma)` would tend to `0` as `sigma -> alpha+`, since `zeta_F` has nonnegative coefficients and is singular at its abscissa by Landau; that half rests on a measurement, unconditional in shape since `sigma_c(D_F) < alpha` would force `P(x) = o(x^alpha)`, and `P(x)/x^alpha` reads `0.493767, 0.699235, 0.758519, 0.587055` at four sampling phases at base 3 `{0,1}`, the four phases being needed because the ratio is log-periodic and sampling only at `x = base^level` aliases every Fourier mode onto one number. Since `M_F = (1 + D_F) N_F` and `sigma_c(N_F) > alpha`, the glue is not neutral but lossy. **Verified** ([lab/py/mrly-pairing](../lab/py/mrly-pairing/), verb `glue`).

## THE METER

- The design's Mobius meter does oscillate at the zeta ordinates, and not at the design's own pole lattice. Read `M_F(x)/x^(alpha/2)` uniformly in `log x`, Hann-windowed, against a local-median floor and a null of rigid shifts of each candidate list: at base 10 with the digit `9` missing all six strongest peaks sit within one bin of a nontrivial zeta zero, offsets `0.068` to `0.216`, with the full-set control at the same depth reading ten of ten, offsets `0.018` to `0.196`. Thirteen zeta ordinates are reachable in the band `4 < gamma < 60`, so a peak lands within one bin of one by chance with probability `0.159` and six of six is `P = 1.6e-5`. The pole lattice `2 pi j / log base` scores `-0.592`, `-0.640`, `-0.734` at base 3 `{0,1}`, base 3 `{0,2}` and base 5 `{0,1}`, below its own null, while the counting function over the identical elements scores `3.602`, `3.764` and `3.973`: the pipeline would have seen a lattice and there is none. **Verified** ([lab/py/design-meter](../lab/py/design-meter/), verb `spectrum`, and the [echo demo](../../site/demos/echo/)).
- The echo is a mean field and not a signature, and its size is a theorem. `M_F(x) = sum_(n <= x) mu(n) A_F(n)/n + R_F(x)` defines `R_F` at every base and digit set, and partial summation gives `sum_(n <= x) mu(n) A_F(n)/n = A_F(x) H(x) - sum_(m in S_F, m <= x) H(m-1)` with `H(y) = sum_(n <= y) mu(n)/n`, which is `O(y^(-1/2 + eps))` under RH; so the echo is `O(x^(alpha - 1/2 + eps))` when `alpha > 1/2`, while for `alpha < 1/2` the second sum converges absolutely and the echo tends to a nonzero constant, base 16 `{0,1}` reading `-0.0937, -0.1330, -0.1242, -0.1051, -0.1099` at `10^3` to `10^7` against `x^(alpha - 1/2)` falling `0.1778` to `0.0178`, and base 10 `{0,1}` reading `-0.0500` at `10^7` against `0.0405`. Against the square-root bar `x^(alpha/2)` the echo dies at `x^(-min(alpha, 1 - alpha)/2)`, equal to `1` only at `alpha = 1`. **Proved** ([lab/py/design-meter](../lab/py/design-meter/), [mobius](mobius.md)).
- The split separates the two by hand and the frequencies follow the echo. At base 10 missing `9` the echo carries six of six top peaks at zeta zeros and the residual none of the two it has, the echo being `0.1342` of the meter in root mean square against `0.6476`, and the echo's share of the meter falls `0.356028, 0.242495, 0.207229` there and `0.208549, 0.099001, 0.047902` at base 3 `{0,1}`, share over prediction reading `1.0000, 0.7387, 0.6846` and `1.0000, 0.9219, 0.8663`, each design decaying at least as fast as its own rate. So the zeta zeros neither obstruct nor help the design's square-root shape, which is a statement about `R_F` alone. **Proved** ([lab/py/design-meter](../lab/py/design-meter/), verb `spectrum`).
- There is no family law behind the frequencies, and the obvious one is dead. The frequency set is not a function of `(q, alpha)`: base 3 `{0,1}` and base 9 `{0,1,2,3}` share `alpha = 0.630930`, element count `1048575` and log range to within `1.4%`, and their meters split ten peaks against none, where support-matched random-sign meters reach `0` to `4` peaks on the first support and `0` to `2` on the second over eight draws each, so the ten sit above their own null and the none does not; base 9 `{0,1,2,3}` and base 9 `{0,1,3,4}` share base and `alpha` and split the same way, the second being base 3 `{0,1}` element for element since its digits are the base-3 pairs `00, 01, 10, 11`. The scaled pair base 3 `{0,1}` and `{0,2}` shares eight of ten peaks, so the scaling transfer carries into the spectrum where no `(q, alpha)` law does. **Refuted** ([lab/py/design-meter](../lab/py/design-meter/), verb `family`, [mobius](mobius.md)).
- The arcs are not a frequency family the meter carries. The primitive quadratic Dirichlet `L`-zeros of conductor `3`, `4` or `5`, the quadratic conductor each base carries, separate from their shift null at no design over the eleven censused: the largest score is `0.372` against a null of `0.341` at base 4 `{0,1,2}` and the widest gap over a null is `0.371` against `0.290` at base 3 `{1,2}`, while the zeta ordinates on the same meters reach `1.130` against `0.392` at base 10 missing `9` and `0.742` against `0.291` at base 3 `{0,1}`, so the pipeline would have seen an arc family and there is none. The wider prediction, over arcs of denominator `base^j`, is untestable by this spectrum rather than false, the generator carrying `L`-zeros at the three quadratic conductors alone, and it is not claimed here. **Refuted** ([lab/py/design-meter](../lab/py/design-meter/), verb `spectrum`).

## WHERE THE REST LIVES

- The other face of the Riemann hypothesis on a design is the Mobius meter `M_F`, and it has its own page: the exact transfer between scaled columns, the 47-column cancellation census, the power saving under GRH at large base, the pair route with its `l^1` threshold, and the open exponent are [mobius](mobius.md).
- The bar that route has to clear is arithmetic about the digit set rather than about `mu`, and the certified bases that clear it, the least base below the quarter threshold at one and at two missing digits and where each family closes, are [coprime](coprime.md).
- The poles themselves, the certified residue at the off-real lattice points and what they say about Minkowski measurability are [dimensions](dimensions.md); the design's counting function, its log-periodic ripple and the checkpoint identities are [mobius](mobius.md).
- The verbs of [lab/py/mrly-euler](../lab/py/mrly-euler/) this page does not print: the disjunction that replaces `zeta_F M_F = 1` and the least `n` where the product leaves `1`, the Holder reading of the position identity that recovers the pair route's exponent, the Lerch-Mobius fibres written as inverse Dirichlet L-functions of modulus dividing the denominator, and Hurwitz's formula rebuilt so that the reflection moves the kernel and not the design.
- The per-design tables behind the census and the shadow, which this page reads only in aggregate, are [lab/py/transport-census](../lab/py/transport-census/) for `sigma_1`, the strip, the winding and the certified box of every design, and [lab/py/zeta-shadow](../lab/py/zeta-shadow/) for the remainder, the coupling and both predictions at every zeta zero of every rung.
- The per-design cells of the family sweep live in [lab/py/zeta-family](../lab/py/zeta-family/): the counts, real parts and rightmost Mertens reading of every design at both assignment radii, the level-one residue table with its null flags, and the residue of each zero's ordinate against `2 pi/log base`.
- The verb of [lab/py/mrly-pairing](../lab/py/mrly-pairing/) this page does not print: the one-step constant of the digit transform against its triangle-split bound, strict at every family measured beyond `level = 1`.
- Every finding on a tagged line: [DISCOVERIES](/research/discoveries/). Every source resolved: [REFS](../REFS.md).

## GENERATORS

- [lab/py/design-zeta](../lab/py/design-zeta/) is the ladder, the contour engine and the census: `uv run python research/lab/py/design-zeta/design_zeta.py`, and `--full` runs the census to `Im s = 60` and adds the base-10 columns. Every printed value carries a propagated truncation bound and the ladder raises rather than returns when the tolerance is not met.
- [lab/py/zeta-locus](../lab/py/zeta-locus/) imports that engine and adds the cofactor, the Laurent data, the comb law and the falsification sweep: `uv run python research/lab/py/zeta-locus/zeta_locus.py shadow 40 all` for the law at every design and `census 40 all` for the strip census, `N_F(T)` and one row per zero, and `rouche 40 rou` for the certificate at every pole of the nine designs the census counts, with its margin, radii, `B_T` and depth.
- [lab/py/transport-census](../lab/py/transport-census/) prints the zero-free edge, the census right of the abscissa and the bound each design proves: `uv run python research/lab/py/transport-census/transport_census.py census 40 locus`, and the verb `law`; the third argument selects `locus`, `rungs`, `b20`, `b50`, `ctl` or `all`, and `all` is the twenty-two of the two sweeps, base 20 and base 50 being their own runs.
- [lab/py/zeta-shadow](../lab/py/zeta-shadow/) prints the position identity, the fibre weight and the constant-free step against its `fill/base` rival: `uv run python research/lab/py/zeta-shadow/zeta_shadow.py mass ladder`, and the verbs `predict` and `rungs`; the second argument selects `ladder`, `old` or `new`.
- [lab/py/zeta-family](../lab/py/zeta-family/) splits the second family from the combs and runs the three derived tests: `uv run python research/lab/py/zeta-family/zeta_family.py family 40 all`, and the verbs `symmetry`, `count`, `limit` and `tests`, the second argument the height and the third a design family.
- [lab/py/mrly-euler](../lab/py/mrly-euler/) prints the wall, the position identity and the three products: `uv run python research/lab/py/mrly-euler/euler.py wall`, and the verbs `pair`, `position`, `dual`, `fibre`, `word` and `beurling`.
- [lab/py/mrly-pairing](../lab/py/mrly-pairing/) prints the identity, the winding boxes, the glue and the grid split: `uv run python research/lab/py/mrly-pairing/pairing.py split`, and the verbs `glue`, `inverse` and `box`.
- [lab/py/design-meter](../lab/py/design-meter/) prints the meter's spectrum, its echo and the equal-`alpha` comparison: `uv run python research/lab/py/design-meter/design_meter.py spectrum`, and the verbs `sieve` and `family`.
- [lab/py/burnol-residue](../lab/py/burnol-residue/) certifies the residues at the off-real poles in interval arithmetic: `uv run python research/lab/py/burnol-residue/burnol_residue.py`.