---
title: The algebra of the stack
lead: The algebra of the stack: stacking is Dirichlet convolution and the group knows nothing new, the exact spun stack is a Gaussian Farey whose Fourier `L^2` discrepancy obeys Franel's identity one field up and is equivalent to the Riemann hypothesis for `zeta(s) L(s, chi_-4)`, its hexagonal twin puts `L(2, chi_-3)` in a proved node constant, the layers are a dilation system whose symbol is `zeta(1 + s)` so no reweighting moves the line, and the lean is the operation outside the Dirichlet group that still lands a closed form.
figure: research-stack
slug: stack
---

Lay a periodic pattern on the unit square at every scale `n = 1..N` at once, drop the opacity, and add the layers: that is the stack, and everything about it is a weight on the scales. [The Farey page](farey.md) says what the plain stack lights - [the Farey fractions](/wiki/farey-sequence/), `phi(n)` new nodes per scale, a genuinely RH-equivalent object rendered exactly and with no route to a proof. This page is the algebra of the stack itself: what happens when stacks are stacked inside one another, spun, restricted to a chosen set of scales, or built from a different design or a deeper level of the same one, and which of those operations leave the arithmetic of `zeta`. Three of them stay inside one abelian group whose series is a ratio of [zetas](/wiki/riemann-zeta-function/), and the ones that leave it are the only place a new theorem can live.

Every claim below carries a tag. **Proved** means derived here from definitions or restated from a proof given here. **Verified** means recomputed from scratch by the study named, or read at source in the published literature. **Conjecture** means checked on a finite domain with no derivation. **Refuted** means killed, with the witness beside it.

## Stacking the stacks

Give scale `n` the weight `w(n)`. The node `a/b` in lowest terms collects the scales divisible by `b`, so its brightness is `sum_{k <= N/b} w(kb)`, which is `floor(N/b)` at `w = 1` and a [Mertens-type sum](/wiki/mertens-function/) at `w = mu`. Now stack a stack. The `v`-weighted stack is itself a picture on the unit interval, so laying it down at scale `k` places `k` shrunken copies of it, its line at `j/n` inside copy `i` landing at `((i-1)n + j)/(kn)`, and the pairs `(i, j)` biject with `1 <= m <= kn`. Layer `k` of the outer stack is therefore the plain grid at scale `kn` carrying weight `u(k) v(n)`, so `W(m) = sum_{kn = m} u(k) v(n) = (u * v)(m)`: the `u`-stack of the `v`-stack is the `(u * v)`-stack. **Proved.**

The cut is part of the statement. Under the hyperbolic cut `kn <= N` the identity holds at every scale `m <= N` and the two pictures agree node for node; under a rectangular cut `k <= K`, `n <= M` it is guaranteed only for `m <= min(K, M)`, the composite carrying extra scales above that. **Proved**, and **Verified** by literal double stacking at `N = 60` in exact rationals by three routes sharing no inner loop - explicit copy placement, the hyperbolic composite, and the node formula `sum_{k <= N/b} (u * v)(kb)` - on `u = v = 1`, `u = 1, v = mu`, `u = mu, v = mu` and `u = 1, v = n^-1`, with zero mismatches on all 974 to 1102 nodes of each, while the rectangular cut `24 x 40` is exact at every `m <= 24` and differs at some scales above it, 10 of its 16 scales from 25 to 40 for `mu * mu` (`lab/py/stack-algebra`).

Three readings follow at once. The plain stack is `zeta`, its weight being the constant `1`. The stack of stacks is `zeta^2`, since `1 * 1 = d` draws scale `n` exactly `d(n)` times, the first ten multiplicities reading `1, 2, 2, 3, 2, 4, 2, 4, 3, 4`. The [Mobius](/wiki/mobius-function/) stack is the group inverse, and `1 * mu = e` collapses the Mobius stack of the plain stack to a single layer, weight 1 at scale 1 and nothing anywhere else. **Proved**, and **Verified** at `N = 60` by the same three routes (`lab/py/stack-algebra`).

Weight scale `n` by `n^-s` instead and the weight is completely multiplicative, so the node factors: `a/b` reads `b^-s H_s(floor(N/b))` and tends to `zeta(s)/b^s`. Denominator `b` carries `phi(b)` nodes in `(0,1]`, so the total node mass is `sum_b phi(b) zeta(s) b^-s = zeta(s) zeta(s-1)/zeta(s) = zeta(s-1)`, converging for `s > 2`. **Proved**, and **Verified** at `N = 16000` reading `1.644872`, `1.202057` and `1.082323` for `s = 3, 4, 5` against `zeta(2) = 1.644934`, `zeta(3) = 1.202057` and `zeta(4) = 1.082323` (`lab/py/stack-algebra`).

At `s = 1` the mass diverges and the stack must be renormalised, and the renormalisation is already in the literature. With the sawtooth `((y)) = {y} - 1/2` off the integers, `sum_{n >= 1} mu(n)/n ((nx)) = -sin(2 pi x)/pi`: the renormalised `s = 1` Mobius stack of the sawtooth is a single pure sine, every layer above the first cancelling exactly. **Proved**, in one line from Davenport's expansion `sum_n a(n)/n ({nx} - 1/2) = -(1/pi) sum_n A(n)/n sin(2 pi n x)` with `A = a * 1`, since `A = e` collapses the right side to its first term. That expansion is **Verified** through the secondary source quoting it, equation (1.1) of [arXiv:2005.08279](https://arxiv.org/abs/2005.08279), which carries the citation to H. Davenport, *On some infinite series involving arithmetical functions*, Quarterly Journal of Mathematics 8 (1937), 8-13; the 1937 article is paywalled and is not read here. The convergence is Mertens-slow, which is the honest reason the identity buys nothing: truncated over five rational `x` its maximum error falls only from `5.49e-03` to `2.08e-04` between cuts `10^3` and `10^5`, and the `{nx}` form differs from the sawtooth form by `(1/2) sum mu(n)/n`, whose vanishing is equivalent to the prime number theorem and which the same generator reads as `-0.00048723` at `n <= 10^5`. **Verified** (`lab/py/stack-algebra`).

Weights with `w(1) != 0` form an abelian group under Dirichlet convolution and the stacks inherit it: composition is the group law, the one-layer stack is the identity, every stack has an inverse stack. **Proved.** The structure carries no RH content on its own, being the group of formal Dirichlet series restated, true even for weights whose series continues nowhere. RH enters at exactly one element, the inverse of `1`, whose node at `b = 1` is `M(N)`. So the group form of "everything inside the Dirichlet group is closed form" is false, and its failure is the point: the group holds `zeta` and `1/zeta` alike and membership buys nothing. **Refuted.** What separates the easy stacks from the hard one is the arithmetic of the weight, never the algebra it sits in.

## Selecting the scales

A selection is the indicator weight of a set of scales, and each of the five natural ones has a closed-form node. Write `N` for the top scale and `a/b` for a reduced node.

| selection | node `a/b` |
|---|---|
| evens | `floor(N / lcm(2, b))` |
| odds | `0` at even `b`, else `ceil(floor(N/b) / 2)` |
| primes | `pi(N)` at `b = 1`, `1` at prime `b <= N`, else `0` |
| squarefree | `0` unless `b` squarefree, else `sum_{d^2 <= N/b, gcd(d,b) = 1} mu(d) sum_{e | b} mu(e) floor(N/(b d^2 e))` |
| prime powers | `sum_p floor(log_p N)` at `b = 1`, `floor(log_p N) - i + 1` at `b = p^i <= N`, else `0` |

**Proved**, each by splitting `w(kb)` on the arithmetic of `b`, and **Verified** by literal stacking against every `b <= N` at `N = 30, 61, 200, 501` with zero mismatches (`lab/py/stack-algebra`). The evens stack is the plain stack rescaled by 2, exactly as the `lcm` in its node says, and the odds stack lights odd denominators only. The [primes](/wiki/prime-numbers/) stack is the extreme case: away from the integers it lights only the prime denominators, each at brightness exactly 1, because `kb` prime forces `b = 1` or `k = 1`, and at `N = 501` it lights 96 denominators, `b = 1` and the 95 primes. **Verified**, same generator.

The selection that matters is on [the carpet](/wiki/sierpinski-carpet/). Layer `n` of the carpet stack is `C_n(u,v) = chi_n(u) chi_n(v)`, the layers are the odd scales, and the gcd correlation law of the [moire-correlation-laws](https://github.com/carlomitchener/carlomitchener/tree/main/research/moire-correlation-laws) lane gives covariance zero at every coprime pair. Distinct odd primes are coprime, so every layer pair of the primes-only carpet stack has covariance exactly zero. **Proved.** Zero pairwise covariance is all a second moment needs: writing `L` for the layer count and `p != q` for two of its primes, `Var(mean) = (1/L^2)[sum_p Var(C_p) + sum_{p != q} Cov(C_p, C_q)]` loses its cross terms entirely, so the `L^2` fading ratio of the primes-only carpet stack to independent layers is exactly `1` at every layer count, identically and not asymptotically. **Proved**, and **Verified** in exact rationals at `L = 5, 10, 100, 1000`, where `L * Var` climbs `0.1429334753`, `0.1595579958`, `0.1833424270`, `0.1869968711` (`lab/py/stack-algebra`).

The constant is exact. Layer `n` has mean `((n-1)/(2n))^2` and variance `q^2 - q^4` with `q = (n-1)/(2n)`, so `16 p^4 Var_p = 3p^4 - 4p^3 - 2p^2 + 4p - 1`, with no breach over the first 1000 odd primes (`lab/py/stack-algebra`). **Verified.** Since `Var_p -> 3/16` the Cesaro mean converges and `c^2 = lim L * Var = 3/16`, so `c = sqrt(3)/4 = 0.4330127`, approached from below at rate `(1/4L) sum_{i <= L} 1/p_i`, which is `O(log log p_L / L)`. **Proved.** Under the identical estimator the tree's full odd stack reads `L * Var = 0.2708541` at `L = 4000` with `c` factor `1.202738`, climbing toward the `1.2054` of the same shelf lane: the tree's stack fades a fixed factor slower than noise and this one fades at exactly the noise rate. What "fades like noise" means stays narrow, being a second-moment statement about the RMS contrast `c/sqrt(L)` of the `L`-layer mean; it says nothing about the sup norm and nothing about independence beyond pairs.

Primality is not what buys it. The criterion is pairwise coprimality, and any pairwise-coprime selection of odd scales has ratio `1` by the same two lines; mapping each layer to its least prime factor is injective on such a selection, so no pairwise-coprime set of odd scales `>= 3` is denser than the odd primes, which are the densest uncorrelated selection rather than the only one. **Proved.** The squarefree-odd stack is the natural rival and it fails, `15` and `21` sharing `3`: `Cov(C_15, C_21) = 284/99225 = 0.0028621819` with Pearson `0.0165610084`, **Verified** by exact rational integration on the lcm grid, and over its first 1000 layers 64087 pairs share a factor and the ratio to independent reads `1.308596` (`lab/py/stack-algebra`). The carpet stack is defined on odd layers throughout this tree, so the primes above are the odd primes; layer 2 is uncorrelated with every odd layer and has variance exactly `3/16`, so admitting it changes no number here. **Proved.**

## Spinning the stack

Rotate every layer. Layer `n` at angle `theta` draws the lattice `(1/n) R_theta Z^2` instead of lines at `x = k/n`, and the question the whole stack rests on - which layers agree at a point - becomes a question about the relative angle alone. Two layers `(m, alpha)` and `(n, beta)` share a node other than the origin exactly when `cos(alpha - beta)` and `sin(alpha - beta)` are both rational. **Proved**, in four lines: a shared point gives `R_phi (nv) = mw` for nonzero integer vectors `v, w` and `phi = alpha - beta`, and the two inner products of `V = nv` with `W = mw` read `cos phi = (V.W)/|V|^2` and `sin phi = (V_1 W_2 - V_2 W_1)/|V|^2`; conversely `cos phi = p/r`, `sin phi = s/r` make `R_phi (r, 0) = (p, s)` an integer vector.

Niven's theorem decides the whole-degree case: `{cos(r pi) : r rational} intersect Q = {0, +-1, +-1/2}` (Niven, *Irrational Numbers*, Carus Monograph 11, 1956, the statement read in the abstract of [arXiv:2508.06415](https://arxiv.org/abs/2508.06415) and on the MathWorld entry rather than in the monograph) puts rational cosine at eight whole degrees and rational sine at eight others, with the multiples of 90 as the intersection. **The dead-spin theorem.** At whole degrees, layers `(m, alpha)` and `(n, beta)` share a node other than the origin if and only if `alpha` and `beta` are congruent modulo 90, and the shared set is then exactly `R_alpha (1/gcd(m,n)) Z^2`. **Proved**, a multiple of 90 degrees being a symmetry of `Z^2` with `(1/m)Z^2 intersect (1/n)Z^2 = (1/gcd(m,n)) Z^2`; **Verified** by a route that never uses Niven, reducing `2 cos(d deg) = z^d + z^-d` and `2 sin(d deg) = z^(90-d) - z^(90+d)` modulo the cyclotomic polynomial `Phi_360` and asking whether the remainder is constant, which returns exactly `0, 90, 180, 270` of the 360 whole degrees (`lab/py/spun-stack`). A spun stack whose angles are distinct modulo 90 is `N` grids agreeing nowhere but the corner.

The simplest schedule gives every layer the same extra turn, and the dead-spin theorem settles it as a corollary. Layer `k` sits at `k theta`, so layers `j` and `k` share an exact lattice exactly when `(j - k) theta` is a multiple of 90; writing `theta/90 = p/q` in lowest terms the whole condition is `q | j - k`, the layers fall into exactly `q` angle classes modulo 90, sharing happens inside a class and never across one, and the number of sharing pairs is `sum_classes C(size, 2)`. At irrational `theta/90` no pair shares at all and the stack is dead everywhere but the origin. **Proved**, three lines from the dead-spin theorem. A fixed-increment stack therefore lines up exactly at the Farey fractions of a quarter turn, and the Farey denominator `q` is the number of eyes the picture opens: over the 28 odd scales `1..55` the sharing-pair count reads `378` at `theta = 0`, `182` at `45`, `117` at `30` and at `60`, `84` at `22.5` and at `67.5`, `65` at `18` and at `36`, `52` at `15`, `36` at `11.25`, `30` at `10`, and `0` at `theta = 90(sqrt 2 - 1)`. **Verified**, every row landed by three routes sharing no argument, the class formula, the pairwise exact test `(j - k) theta/90 in Z`, and at the eight whole-degree increments the Niven-free cyclotomic test on the relative angle (`lab/py/spun-stack`, `increment_classes`). Turning the dial past a rational multiple of a quarter turn is the only thing that switches [the moire](/wiki/moire/) on.

Distinct angles are not enough, and the prime-degree schedule is the witness. Give layer `k` the angle `0, 2, 3, 5, 7, 11, ...`; of the 435 pairs among the first 30 layers, 5 share a node off the origin, each a pair whose angles differ by exactly 90 degrees: layers 5 and 26 at 7 and 97 degrees, layers 6 and 27 at 11 and 101, layers 7 and 28 at 13 and 103, layers 8 and 29 at 17 and 107, layers 9 and 30 at 19 and 109. **Refuted**, the expectation that a whole-degree schedule of distinct angles leaves nothing but the origin. What each pair shares is the full lattice `R_alpha (1/g) Z^2` with `g = gcd(m,n)`, whose density is exactly `g^2` per unit area. **Proved.** How many of those points land in a fixed unit square depends on the angle and is not `g^2` in general; counted in the open unit square with the origin excluded, the five pairs read `1, 9, 49, 1, 9`, which is `g^2` at these five angles. **Verified** (`lab/py/spun-stack`). The other 430 pairs are dead by theorem and dead by margin, the closest any rotated node coming to a coincidence over the box of side 6 being `0.003390` (`lab/py/spun-stack`).

The rotations that keep a stack exact form a group, Gaussian but not in the shape a first guess suggests. It is not `z/|z|` for `z` in `Z[i]`, rational only when `N(z)` is a perfect square, `(1+i)/sqrt(2)` being the standing counterexample. **The rational rotations are exactly `w/conj(w) = w^2/N(w)` for nonzero `w` in `Z[i]`. Proved**, by the rational parametrisation of the circle, `w = a + bi` giving `(cos, sin) = ((a^2 - b^2)/(a^2 + b^2), 2ab/(a^2 + b^2))`; **Verified**, all 68 rational points of the unit circle with denominator at most 60 being `w^2/N(w)` for a Gaussian `w` in the box of side 12 (`lab/py/spun-stack`). Rotation alone is the wrong handle: what the square lattice admits is rotation paired with a scale, which is multiplication by [a Gaussian integer](/wiki/gaussian-integers/).

So the exact spun stack is the Gaussian Farey stack. Index the layers by the associate classes of `Z[i]` with the zero class excluded and the four units counted once, one class per layer since `z^-1 Z[i]` depends only on `z` up to units, let layer `z` be the grid `z^-1 Z[i]` - scale `|z|` and rotation `-arg z` in one multiplication - and stack the classes of norm at most `N` on the unit square, a fundamental domain of `C/Z[i]`. The lit set is exactly the Gaussian Farey fractions `u/z` read modulo `Z[i]`; a node with reduced denominator `d` is lit by exactly the layers `z` that `d` divides, so its brightness is the count of classes `y` with `N(y) <= N/N(d)`, a Gauss circle count. Writing `g(t)` for the number of nonzero associate classes of norm at most `t`, Jacobi's two-square identity makes it the floor sum `g(t) = sum_{j >= 0} (floor(t/(4j+1)) - floor(t/(4j+3)))`, and the brightness law is `B_N(w) = g(floor(N/N(d)))`: the exact Gaussian twin of `floor(N/b)`, a floor sum in place of a single floor, one dimension up. **Proved**, and **Verified** two ways, the Jacobi form against direct lattice enumeration for every `t` from 0 to 400 with first twelve values `1, 2, 2, 3, 5, 5, 5, 6, 7, 9, 9, 9`, and the closed form against literal stacking of all 40 layers at norm bound 50 in exact rational arithmetic on all 672 nodes with 0 mismatches, the origin reading 40 (`lab/py/spun-stack`). The node count is the Gaussian totient sum, the nodes of reduced denominator class `[d]` being the `u` mod `d` coprime to `d`: the lit set has `sum_{[d], N(d) <= N} Phi(d)` points, twin of `|F_Q| = sum_{b <= Q} phi(b)`, reading 672, 10608 and 168088 at norm bounds 50, 200 and 800. **Proved**, and **Verified** at norm bound 50 against literal stacking (`lab/py/spun-stack`).

The constant in that node count is a theorem rather than a reading. For an imaginary quadratic field `K` with class number `h`, `w` units and discriminant `D_K`, writing `Phi(a)` for the order of the unit group of `O_K/a` and `rho_K = 2 pi h/(w sqrt |D_K|)` for the density of ideals by norm, the ideal totient sum is `sum_{N(a) <= N} Phi(a) = (rho_K/(2 zeta_K(2))) N^2 + O(N^(3/2))`. **Proved**, for every imaginary quadratic field, by Dirichlet convolution and Abel summation in three elementary steps: `Phi = N * mu_K` on ideals gives `sum_a Phi(a) N(a)^-s = zeta_K(s-1)/zeta_K(s)`; the ideal count comes from the lattice one ideal class at a time, since `O_K` sits in `C` at covolume `sqrt |D_K|/2` with its fundamental cells trapped between two concentric discs and the free unit action dividing out, while fixing an ideal `a` in `C^-1` turns the class `C` into the nonzero elements of `a` of norm at most `t N(a)` up to units, a lattice of covolume `N(a) sqrt |D_K|/2`, so every class has the same density and the `h` classes sum to `rho_K t`; and Abel summation gives `sum_{N(c) <= X} N(c) = (rho_K/2) X^2 + O(X^(3/2))` while the sum over the Mobius layer converges to `1/zeta_K(2)` with its error controlled by `zeta_K(3/2)`. Class number one is a hypothesis of nothing here except the identification of ideals with associate classes, which is the layer index of this stack. At `K = Q(i)`, with `h = 1`, `w = 4`, `|D_K| = 4` and `zeta_K(2) = zeta(2) G`, the constant is `pi/(8 zeta(2) G) = 0.260634696495` with `G` Catalan's constant, and for a general number field the same two steps are an implication from any ideal count `A(t) = rho_K t + O(t^theta)` with `0 < theta < 1`, the lower bound needed because `theta = 0` calls on the divergent `zeta_K(1)` (`lab/py/totient-constant`, `main`). **Verified** by an independent recount reading 672, 10608, 168088, 372872, 1045088, 2663864, 42663808, 683283504 and 2732257376 at norm bounds 50, 200, 800, 1200, 2000, 3200, 12800, 51200 and 102400, agreeing with the counts above wherever the two overlap, the ratio `count/(c N^2)` moving from `1.031329` at 50 to `0.999746` at 102400 and oscillating about 1 rather than settling from one side, with the deviation scaled by the derived error `N^(3/2)` peaking at `0.064563` over that column, and a second recount by norm alone, with no lattice, agreeing at every bound and carrying the general case, `D_K = -20` at `h = 2` reading constant `0.378582556790` and count 3969730264 at norm bound 102400 for ratio `1.000001116781` with the scaled deviation peaking at `0.434287` at norm bound 50, `D_K = -23` at `h = 3` reading `0.425700255391` and 4463281160 for ratio `0.999885848149` with its own peak `0.197281` (`lab/py/totient-constant`, `totient_sum`, `norm_totient_sum` and `main`).

One convention has to be fixed before that constant is quoted against the literature. Counting denominators as ideals gives `rho_K/(2 zeta_K(2))`; counting them as elements gives `pi/(sqrt |D_K| zeta_K(2))`, exactly `w` times larger. The complex Farey set of [arXiv:2407.04380](https://arxiv.org/abs/2407.04380) is this node set, and its printed constant counts element denominators: enumerating that set directly, as the deduplicated union of the lattices `q^-1 O_K` modulo `O_K`, returns 672, 10608 and 168088 at norm bounds 50, 200 and 800, equal to the ideal totient sum at every one, so the set convention is the ideal one and the factor 4 between the two constants is the unit group, inherited there from the counting theorem that paper cites. **Verified** (`lab/py/totient-constant`, `farey_set`).

Fix the rotation and the scale together, once per layer, and the picture changes kind: the layers are `c^-k Z[i]` for a fixed complex `c`, two consecutive layers meet off the origin if and only if `c` lies in `Q(i)`, and the layers nest if and only if `c` lies in `Z[i]`. **Proved**, since `x` and `cx` both in `Z[i]` forces `c = (cx)/x`, and nesting is `c Z[i]` inside `Z[i]`. At a Gaussian-integer `c` the stack stops being a moire and becomes a numeration tree: layer `k` refines layer `k-1` by index `N(c)` and brightness is `depth + 1 - address`, the address being the first layer carrying the node, so there is no interference at all. **Verified** by nesting `c = 1 + i` to depth 8 and `c = 2 + i` to depth 4 with 0 mismatches on all 256 and 625 deepest nodes, and on the boundary by a sweep over the box of side 10 where `1 + i` puts all 440 nonzero points in the coarser layer, `3/2 + i/2` puts 220 and `sqrt(2) e^i` none (`lab/py/spun-stack`). These are the classical complex bases, `-1 + i` the twindragon.

Which rotations the square lattice admits at all is settled in the literature, and it lands inside the same algebra. Read at source in [arXiv:math/0605222](https://arxiv.org/abs/math/0605222), the coincidence rotations of `Z^2 = Z[i]` have index `Sigma(R) = prod_{p = 1 (4)} p^|n_p|`, the coincidence site lattices of index `m` number `2^a` with `a` the count of distinct prime divisors when `m` is a product of basic indices and 0 otherwise, and the generating series is `Phi(s) = prod_{p = 1 (4)} (1 + p^-s)/(1 - p^-s) = (1 + 2^-s)^-1 zeta_{Q(i)}(s)/zeta(2s)`. **Verified** at source, and re-derived here by the Euler product with the primes `3 mod 4` cancelling exactly. The spun stack's layer census is still a ratio of zetas, and its inverse `zeta(2s)/zeta_{Q(i)}(s)` is where a Gaussian Mertens function would live.

The equivalence one field up follows, and the section below writes it. The nearest source read is [arXiv:2407.04380](https://arxiv.org/abs/2407.04380), which works in exactly the right space, the Gaussian Farey sequence inside `C/Z[i]` equidistributing weak-* toward Haar measure with an absolutely continuous limiting gap distribution on `[1, infinity)`, and which mentions neither Franel, nor Landau, nor discrepancy, nor the Riemann hypothesis, its equidistribution carrying no rate because homogeneous dynamics is ineffective by construction. Its complex Farey set is this one, the set equality being the convention settled above: letting `q` run over `Z[i]` with `0 < |q| <= T` and `p` over all of `Z[i]` produces each torus point exactly once, so the two sets are equal at `N = T^2`. What has to be replaced is the functional and not the set. Franel and Landau are built on the rank map: the nodes of `F_Q` are linearly ordered on `[0,1]`, `delta_j = rho_j - j/m` needs that order, and the plane has none, so a Gaussian twin must name a different functional and inherit no threshold. Naming it and re-deriving the threshold is the whole of the next section.

Where the rational template of that identity is published is worth stating precisely, because the field is `Q` in every printing of it. Lemma (10) on p. 283 of [Huxley 1971](https://web.archive.org/web/2020id_/http://matwbn.icm.edu.pl/ksiazki/aa/aa18/aa18130.pdf) is the Fourier `L^2` functional with the Mobius gcd kernel over `Q`, `int_0^1 |E(a)|^2 da = (1/12) sum_{m <= Q} sum_{k | m} (mu(k)/k^2) |L(m)|^2`, and Theorem 1 on p. 133 of [Huxley 2012](https://www.mathnet.ru/php/archive.phtml?wshow=paper&jrnid=tm&paperid=3374&option_lang=eng) is the general weighted form over the same field; the axis the sources read generalise along is the weight, Dirichlet characters and Kubert functions, and the range, short intervals, never the field. Part I announces on p. 283 that "In the second part of this paper we shall discuss a definition of a Farey sequence for an algebraic number field", and the 2012 paper reports on p. 134 that "The planned second part of [6] was abandoned when Theorem 1 had been extended but not Theorem 2". The Gaussian identity of the next section is not found in the sources read, which are those two papers, Kanemitsu and Yoshimoto's Acta Arith. 75 paper of 1996, the Cobeli and Zaharescu survey of 2003, and arXiv:2407.04380. **Verified**, as a statement of what was read.

## Franel one field up

The functional is a choice and gets named as one. Write `G_N` for the Gaussian Farey set of the section above, the nodes `u/d` in lowest terms with the denominator one per associate class of norm at most `N` and the numerator running over the reduced residues mod `d`, read in the unit square, `m = sum_{[d], N(d) <= N} Phi(d)` of them. Pair the dual by `<lambda, w> = Re(lambda w)`, which is `p x - q y` at `lambda = p + qi` and `w = x + iy`; it is `Z[i]`-periodic in `w`, so `lambda -> e(<lambda, w>)` is an isomorphism of `Z[i]` onto the characters of `C/Z[i]`, and a character is trivial on `(1/d) Z[i] / Z[i]` exactly when `d | lambda`. With `S_N(lambda) = sum_{w in G_N} e(<lambda, w>)` the functional is

```
D_2(N)^2 = (1/m^2) sum_{lambda != 0} |S_N(lambda)|^2 / N(lambda)^2
```

and it is the honest twin for four reasons rather than one. It is the squared `L^2` norm of the deviation measure convolved with the kernel whose transform is `N(lambda)^{-1}`, so `D_2(N)` is `4 pi^2` times the `L^2` norm of the periodic Newtonian potential of the deviation; it is invariant under translation and under the four units, where an anchored box discrepancy is invariant under neither; it needs no fundamental domain and no order; and it metrises weak-* convergence, so it is Weyl's criterion in `L^2`. **Proved.** Its classical shadow is not a new object either: with the sawtooth `B1bar`, `int_0^1 (sum_{rho in F_Q} B1bar(u + rho))^2 du = (1/(4 pi^2)) sum_{k != 0} |S(k)|^2/k^2`, so the classical `m^2 D_2^2` is `4 pi^2` times the integral Edwards evaluates in section 12.2 of *Riemann's Zeta Function*, read at source. **Verified.**

The exponential sum is Kluyver's identity in `Z[i]`. Partitioning `G_N` by reduced denominator class gives `S_N(lambda) = sum_{[d], N(d) <= N} c_d(lambda)` with the Gaussian Ramanujan sum `c_d(lambda) = sum_{u mod d, gcd(u,d) = 1} e(<lambda, u/d>)`, well defined because `u -> u + dt` moves the node by `t in Z[i]` and `<lambda, t>` is an integer, and depending only on the ideal because an associate permutes the reduced residues. Then

```
c_d(lambda) = sum_{e | gcd(d, lambda)} mu_G(d/e) N(e),    S_N(lambda) = sum_{[e] | lambda, N(e) <= N} N(e) M_G(N/N(e))
```

with `mu_G` the Mobius function on ideals, `N` the norm, and `M_G(x) = sum_{[f], N(f) <= x} mu_G(f)` the Gaussian Mertens function over associate classes. **Proved**, in three lines: every residue `u mod d` has `gcd(u,d) = d/e` for a unique ideal `e | d` and reduces to a `u'/e`, so `sum_{e | d} c_e(lambda)` is the full character sum over `Z[i]/(d)`, which is `N(d)` when `d | lambda` and `0` otherwise; Mobius inversion over the divisor lattice of the ideal, a lattice because `Z[i]` is a principal ideal domain, gives the first form, and writing `d = ef` gives the second. **Verified** exactly at norm bound 50, where all 2720 Gaussian Ramanujan sums, one for each of the 40 classes and each of the 68 nonzero `lambda` of norm at most 20, are summed literally over the reduced residues as integer vectors of roots of unity and reduced modulo the cyclotomic polynomial `Phi_{N(d)}`, every one landing on a rational integer equal to the Mobius formula with 0 mismatches, and the 68 literal sums over all 672 nodes agreeing to a worst error of `1.281e-13` (`lab/py/gaussian-franel`, `check_theorem_1`). The zero mode is the node count read twice, `sum_{[d]} Phi(d)` and `sum_{[e]} N(e) M_G(N/N(e))` both giving `120`, `672` and `10608` at norm bounds 20, 50 and 200. **Verified**, same generator.

Substituting and applying Parseval gives the identity, and its kernel is one this tree already owns. Writing `zeta_K(2) = zeta(2) L(2, chi_-4) = zeta(2) G = 1.506703` with `G` Catalan's constant,

```
m^2 D_2(N)^2 = 4 zeta_K(2) F(N),    F(N) = sum_{[a],[b] : N(a), N(b) <= N} (N(gcd(a,b))^2 / (N(a) N(b))) M_G(N/N(a)) M_G(N/N(b))
```

**Proved**, by expanding the square and exchanging: for fixed ideals the inner sum is `sum_{lambda != 0, lcm(a,b) | lambda} N(lambda)^{-2} = 4 zeta_K(2)/N(lcm(a,b))^2`, the 4 because a nonzero ideal has four generators, and `N(a) N(b)/N(lcm)^2 = N(gcd)^2/(N(a) N(b))`. The double sum is finite, `M_G(N/N(a))` vanishing above norm `N`, so the right side is exact and `F(N)` is an exact rational. That kernel is the Smith gcd matrix `gcd(m,n)^2/(mn)` of the layer Gram determinant below, one field up: the same object that computes the moire correlation of two carpet layers computes the discrepancy of the Gaussian Farey set. **Verified** at norm bounds 20 and 50 against the Fourier side truncated at `N(lambda) <= 200000`, with the tail bounded by `m^2` times the missing weight since `|S_N(lambda)| <= m`: at norm bound 20, `m = 120` and `F(N) = 114917096/3663075 = 31.371756`, the identity reading `189.071678` against `189.069795` with gap `0.001883` inside the tail bound `0.226192`; at norm bound 50, `m = 672` and `F(N) = 17870882021826065419/177236423132266875 = 100.830753`, the identity reading `607.687997` against `607.677451` with gap `0.010546` inside the tail bound `7.093392` (`lab/py/gaussian-franel`, `check_theorem_2`).

Run the same code on the rational data and it prints the classical page back. The classical form of the identity is `C(Q) - 1 = 12 Phi(Q) sum_j delta_j^2` with `C(Q) = sum_{a,b <= Q} gcd(a,b)^2/(ab) M(Q/a) M(Q/b)`, which is Edwards section 12.2 exactly; it holds as an identity of exact rationals at `Q = 40`, where the Farey enumeration gives `m = 490` and `sum_j delta_j^2 = 0.0104270117`. **Verified.** Reading `S2 * Q = (C(Q) - 1) Q/(12 Phi(Q))` off a Mertens sieve with no Farey sequence generated anywhere gives `0.5395, 0.5848, 0.6241, 0.6387, 0.6560, 0.6538, 0.6564` at `Q = 125, 250, 500, 1000, 2000, 4000, 8000`, digit for digit the discrepancy table of [the Farey page](farey.md). **Verified** (`lab/py/gaussian-franel`, `classical_exact` and `franel_form`). The identity is therefore not an analogy to the classical one; it is the classical one with the field changed, and the control proves the code path is the same path.

The threshold is re-derived rather than inherited, and it runs both ways. Under `M_G(x) = O(x^{1/2+eps})` each term of the exponential sum is at most `N^{1/2+eps} N(e)^{1/2}` and only ideals of norm at most `min(N, N(lambda))` contribute, so `|S_N(lambda)| = O(N^{1/2+eps} d(lambda) min(N, N(lambda))^{1/2})` with `d` the number of ideal divisors; splitting the `lambda` sum at `N(lambda) = N` leaves `O(log^4 N)` below and `O(log^3 N)` above, so `m^2 D_2(N)^2 = O(N^{1+eps})`. Conversely the four units have norm 1 and `S_N(lambda) = M_G(N)` at each, the unit ideal being the only ideal dividing a unit, so dropping every other nonnegative term of the Fourier sum gives `M_G(N)^2 <= zeta_K(2) F(N)` outright. Hence

```
F(N) = O(N^{1+eps}) for every eps > 0   <=>   D_2(N) = O(N^{-3/2+eps})   <=>   RH for zeta_K(s) = zeta(s) L(s, chi_-4)
```

**Proved**, both directions, the biconditional assembled here and written in neither source, on one input carried in from the literature and not re-proved: square-root cancellation in the Dedekind Mertens function is equivalent to the Riemann hypothesis for that Dedekind zeta. That input is itself two-sided and the two sides are not of equal weight. From the Mertens bound to the zero-free half-plane is elementary, the Dirichlet series of `M_G` being `1/zeta_K(s)`, which the bound continues right of `Re s = 1/2`; from the hypothesis back to the bound is Perron's formula against the bound on `log zeta_K` right of the critical line under the hypothesis and the good horizontal lines that carry the contour, Lemma 5.4 and Lemma 2.4 of Hu, Kaneko, Martin and Schildkraut, [arXiv:2109.06665](https://arxiv.org/abs/2109.06665), whose rational template is the Littlewood argument of Edwards section 12.1. The threshold on `D_2` is `N^{-3/2+eps}`, the `3/2` coming from `m` of order `N^2` set against `m^2 D_2(N)^2` of order `N^{1+eps}`, and it is derived here rather than carried over from the rational case. The backward direction is easier than Franel's, and the reason is the choice made at the top: a Fourier functional gives its own Mobius sum back by dropping terms, where a rank statistic does not. The one-line inequality is **Verified** at every rung of the meter, `M_G(N)^2/(zeta_K(2) F(N))` never rising above `0.017` (`lab/py/gaussian-franel`, `main`).

The meter reads what the equivalence predicts and claims nothing past its window.

| `N` | `m` | `F(N)` | `F(N)/N` | `D_2(N)^2 N^3` | local slope of `F` | `M_G(N)` | classical `C(N)/N` |
|---|---|---|---|---|---|---|---|
| 100 | 2600 | 212.1213 | 2.121213 | 189.1147 | - | -2 | 1.877964 |
| 250 | 16424 | 619.1589 | 2.476636 | 216.1484 | 1.1691 | 0 | 2.140099 |
| 500 | 65784 | 1278.4558 | 2.556912 | 222.5578 | 1.0460 | -3 | 2.282045 |
| 1000 | 260944 | 2725.4800 | 2.725480 | 241.2326 | 1.0921 | -1 | 2.332467 |
| 2000 | 1045088 | 5556.4599 | 2.778230 | 245.2845 | 1.0277 | -8 | 2.394800 |
| 4000 | 4176032 | 11394.1497 | 2.848537 | 252.0124 | 1.0361 | -1 | 2.385130 |
| 8000 | 16680488 | 23773.2448 | 2.971656 | 263.6505 | 1.0610 | -21 | 2.394592 |
| 16000 | 66694240 | 47603.5196 | 2.975220 | 264.1861 | 1.0017 | 18 | 2.442443 |
| 32000 | 266670328 | 96361.4734 | 3.011296 | 267.6034 | 1.0174 | 38 | 2.499486 |
| 64000 | 1067245288 | 193284.7209 | 3.020074 | 268.0999 | 1.0042 | -70 | 2.478573 |

**Verified** (`lab/py/gaussian-franel`, `main`). The local slope of `F` walks to `1.0042` and `F(N)/N` climbs from `2.121213` to `3.020074`, the shape of a bounded power of a logarithm, and the classical column beside it climbs the same way; the node count `m` is the Gaussian totient sum of the section above at every rung. Ten nested deterministic points cannot separate `N^{1+eps}` from `N^{1.02}` and no exponent is claimed beyond the window. The Gaussian global readout collapses exactly as the rational one does, `sum_{N(a) <= x} M_G(x/N(a)) = 1` at every `x` from 1 to 2000, so a Gaussian Mertens meter aggregates to a constant for the same reason its rational twin does. **Verified**, same generator.

Three cautions travel with the section. The functional is a choice and not the twin, and every number above is a number about that choice; a different weight on `N(lambda)` gives a different threshold and the equivalence would have to be re-derived. The Riemann hypothesis for `zeta_K` is the Riemann hypothesis and the generalised one for `chi_-4` together, strictly stronger than either, and the statement above is never to be shortened to `zeta`. And an equivalence is exactly as hard as the thing it is equivalent to: this is no more a route than the rational case is, exactly as [the Farey page](farey.md)'s honest cap says, and what changes is only that the observable is now located in `Q(i)` and its threshold is written down. The meter renders, it does not measure.

## The Eisenstein stack

The spun stack is Gaussian because the square lattice is, and the square lattice is not the only lattice that spins. A lattice with 3-fold symmetry is forced to be hexagonal, its arithmetic is [the Eisenstein integers](/wiki/eisenstein-integers/) `Z[omega]` with `omega = e^(2 pi i/3)` and norm `N(a + b omega) = a^2 - a b + b^2`, and [what base 3 hides](bases.md) already carries the constant that ring holds: `zeta_K(2) = zeta(2) L(2, chi_-3) = 1.285190955484149` for `K = Q(sqrt(-3))`, with `L(2, chi_-3)` in Catalan's class and no known closed form. Run the whole spun-stack construction over `Z[omega]` and that constant stops being a coprimality density and becomes the density of a picture: it is the constant in the node count of a stack.

Everything is one field change. Index the layers by the nonzero associate classes of `Z[omega]`, six units counted once per class, let layer `z` be the lattice `z^-1 Z[omega]`, scale `|z|` and rotation `-arg z` in one multiplication, and take coordinates in the basis `1, omega`, so that the fundamental domain of `C/Z[omega]` is the unit square of that chart and the picture is its image, the fundamental parallelogram.

The rotations change first, and the criterion is not the one the square lattice trains a reader to expect. On `Z^2` a rotation is admissible when `cos` and `sin` are both rational; on the hexagonal lattice the condition is that the rotation lies in the field, `e^(i theta) in Q(sqrt(-3))`, which asks for `cos` rational and `sin` a rational multiple of `sqrt 3`. **The rational rotations of the hexagonal lattice are exactly `w/conj(w) = w^2/N(w)` for nonzero `w` in `Z[omega]`. Proved**, by Hilbert 90 for the quadratic extension `Q(sqrt(-3))/Q`: a rotation of the lattice is a norm-one element of `K`, every norm-one element is `v/conj(v)` for some `v` in `K`, and clearing denominators puts `v` in `Z[omega]`. **Verified**, all 58 solutions of `p^2 + 3 q^2 = r^2` with `r` at most 60, read as the pair `(cos, sin/sqrt 3) = (p/r, q/r)`, being `w/conj(w)` for an Eisenstein `w` in the box of side 20 (`lab/py/eisenstein-stack`, `rotation_hits`). At whole degrees the count goes up: `e^(i theta)` is a 360th root of unity, it lies in `Q(omega)` exactly when its order divides 6, so **exactly the six multiples of 60 keep two hexagonal layers coincident, against the four multiples of 90 on the square lattice. Proved**, and **Verified** by a route that never uses Niven, reducing `zeta^d + zeta^-d` and `(zeta^d - zeta^-d)(zeta^120 - zeta^240)` modulo `Phi_360` and asking whether both remainders are constant, which returns `0, 60, 120, 180, 240, 300` of the 360 whole degrees and is re-decided at twelve of them by minimal polynomial (`lab/py/eisenstein-stack`, `field_rotation_degrees` and `spot_check_degrees`). Degrees 90 and 270 are the instructive failures, rational cosine and `sin/sqrt 3 = 1/sqrt 3` irrational; Niven's theorem alone would have kept them.

The address survives the field change intact, and so does the shape of the brightness law. The lit set is the Eisenstein Farey fractions `u/z` read modulo `Z[omega]`; a node with reduced denominator `d` is lit by exactly the layers `z` that `d` divides, so its brightness over norm bound `N` is the number of nonzero associate classes of norm at most `N/N(d)`, a hexagonal circle count. Writing `h(t)` for that count, the number of elements of norm `n` is `6 sum_{d | n} chi_-3(d)`, class number one and six units, so **`h(t) = sum_{j >= 0} (floor(t/(3j+1)) - floor(t/(3j+2)))`, the exact hexagonal twin of the Gaussian `floor(t/(4j+1)) - floor(t/(4j+3))`, and the brightness law is `B_N(w) = h(floor(N/N(d)))`. Proved**, and **Verified** two ways, the floor sum against direct enumeration of associate classes for every `t` from 0 to 400 with first twelve values `1, 1, 2, 3, 3, 3, 5, 5, 6, 6, 6, 7`, and the closed form against literal stacking of all 31 layers at norm bound 50 in exact rational arithmetic on all 630 nodes with 0 mismatches, the origin reading 31 (`lab/py/eisenstein-stack`, `hex_classes_closed`, `literal_stack` and `closed_brightness`). The node count is the Eisenstein totient sum, the nodes of reduced denominator class `[d]` being the `u` mod `d` coprime to `d`: **the lit set has `sum_{[d], N(d) <= N} Phi(d)` points with `Phi(d) = N(d) prod_{p | d} (1 - 1/N(p))`, reading 630, 9606, 151020, 337026, 945486 and 2419950 at norm bounds 50, 200, 800, 1200, 2000 and 3200. Proved**, and **Verified** at norm bound 50 against literal stacking (`lab/py/eisenstein-stack`, `totient_sum`).

That is where the base-3 constant enters, and it enters split into its two factors. The theorem of the spinning section applies verbatim with `h = 1`, `w = 6`, `|D_K| = 3` and `rho_K = pi/(3 sqrt 3) = 0.604599788078073`, so **the Eisenstein node count is `(pi/(6 sqrt 3 zeta(2) L(2, chi_-3))) N^2 + O(N^(3/2))`, the constant `0.235217881630015`. Proved**, the three factors printed at 50 working digits from the Hurwitz form `L(2, chi) = q^-2 sum_a chi(a) zeta(2, a/q)` by Euler-Maclaurin and `pi` by Machin, `zeta(2) = 1.644934066848`, `L(2, chi_-3) = 0.781302412896`, `zeta_K(2) = 1.285190955484` (`lab/py/totient-constant`, `hurwitz2`, `lvalue` and `dpi`). The counted ratios sit against it at `0.252000`, `0.240150`, `0.235969`, `0.234046`, `0.236372` and `0.236323` at the six norm bounds above, and the approach is not monotone, the deviation changing sign at norm bound 1200: the count's deviation from `c N^2` divided by `N log N` reads `+0.214, +0.186, +0.090, -0.198, +0.304, +0.438`, bounded and of both signs, which sits strictly inside the proved error and is not a drift away from the constant. **Verified**, by an independent recount that reproduces every count above and extends them to 38560362, 616981926 and 2466558234 at norm bounds 12800, 51200 and 102400, where `count/(c N^2)` reads `1.000049` (`lab/py/totient-constant`, `totient_sum` and `main`). That the true error is `O(N log N)`, the exact analogue of the classical error in `sum_{n <= N} phi(n)`, is **Conjecture**: it needs cancellation in `sum_b mu_K(b) E(N/N(b))` which the elementary argument does not supply.

Which rotations the hexagonal lattice admits at all is settled in the literature and lands inside the same algebra. Read at source in the arXiv LaTeX of [arXiv:math/0511147](https://arxiv.org/abs/math/0511147), Pleasants, Baake and Roth give the triangular lattice as the example in section 4, after the theorem that closes section 3: `K = Q(sqrt(-3))`, basic indices the primes `p = 1 mod 3`, the number of coincidence site lattices of index `m` equal to `prod_{p | m} 2` when `m` is a product of basic indices and 0 otherwise, average number of coincidence site lattices quoted there as `sqrt 3/(2 pi) = 0.276`, and the Dirichlet series `(1 + 3^-s)^-1 zeta_K(s)/zeta(2s) = prod_{p = 1 (3)} (1 + p^-s)/(1 - p^-s) = 1 + 2/7^s + 2/13^s + 2/19^s + 2/31^s + 2/37^s + 2/43^s + 2/49^s + ...`. **Verified** at source, and re-derived here by expanding both sides coefficient by coefficient to bound 100, equal throughout, nonzero at 1 and `2` at `7, 13, 19, 31, 37, 43, 49, 61, 67, 73, 79, 97` and `4` at 91 (`lab/py/eisenstein-stack`, `csl_zeta_ratio` and `csl_euler_product`). The inverse factor sits at the ramified prime 3, exactly where the square lattice's sits at 2. The layer census of the Eisenstein spun stack is again a ratio of zetas, and its inverse `zeta(2s)/zeta_K(s)` is where an Eisenstein Mertens function would live.

Two warnings come with the picture. The fundamental domain is a parallelogram and not a square, so a raster of the unit square is the wrong window for this stack and every count above is taken in the `1, omega` chart. And the tree's base-3 designs, the Sierpinski carpet and its level refinements, live on the square grid indexed by base-3 digits of square cells, while the Eisenstein stack is the hexagonal lattice's own stack; the 3 in it is the ramified prime of `Q(sqrt(-3))` and not a digit base, so the base-2 slice stack of [the hexagon page](hexagon.md) is not a route to it. The two meet only in the constant.

The render `eisenstein-stack.png` under `lab/py/eisenstein-stack` stacks the 774 lit nodes at norm bound 60 in the fundamental parallelogram with dots sized by the square root of brightness, brightest 35 at the origin. Its 3-fold rosettes sit at the images of the low-norm denominators; it is a picture of the address above and no theorem is claimed from it.

## The spun picture

The theory is exact and the picture is not, so the picture is worth reading only where it carries a theorem's shadow. Spin the odd carpet stack: scales `n = 1, 3, ..., 55`, layer `k` rotated about the centre by `theta_k`, and the ink field `D`, the fraction of the 28 layers inking a point, read on rasters of `R = 256, 512, 1024, 2048` inside the inscribed disc where every layer covers every sampled pixel.

The centre is the one free node, and it needs no arithmetic. Rotation about the centre preserves distance from it and in layer `n` the cell containing the centre is the square of inradius `1/(2n)`, so a disc of radius `1/(2N)` lies inside one cell of all layers at every angle at once. At `N = 55` that radius is `1/110`, and the centre reads ink `14/28` exactly, the 14 scales `n = 3 mod 4`, the unspun value, in every schedule at every resolution. **Proved** (`lab/py/spin-render`). The [tourbillon demo](../../site/demos/tourbillon/) turns every layer by its own angle and shows the shared grid breaking while that centre holds, the same fourteen layers of twenty-eight at every schedule.

The unspun maximum is an address rather than a pixel. Ink at `(u, v)` counts the scales dark in both coordinates, so it is at most the count of scales with `floor(nu)` odd, and on the diagonal the two counts agree: the two-dimensional maximum is a one-dimensional one, read off the 636 breakpoints `k/n` in exact rationals with no raster. It is `18/28` and the 18 agreeing scales are `n = 3, 5 mod 6`. **Proved** (`lab/py/spin-render`). The locus is four cells rather than one. At odd scales `floor(n(1-u)) = n - 1 - floor(nu)` with `n - 1` even, so the 1D count satisfies `A(u) = A(1-u)` exactly, and it reaches 18 on `[1/3, 18/53)` and on the reflection `[35/53, 2/3)`, each of length `1/159`; the two-dimensional maximum is therefore attained on all four products of those intervals, a locus of total area `4/25281 = 0.000158222`. **Proved.**

No spun schedule reaches it. The one-degree increment peaks at `14/28` and the prime-degree schedule at `16/28`, each at all four resolutions; the golden schedule reads `15/28` at `R = 256` and `16/28` above it, the seeded random one `16/28` at `R = 256` and `17/28` above it, and the Gaussian one `16/28` except at `R = 1024`, where it reads `17/28`. A zoom at effective `R = 51200` on each top peak finds nothing higher there. The surviving cells are far smaller, the zoom reading the area of one unspun maximal cell as `3.95523e-05` against `1.65596e-05` for the prime-degree peak and `1.0128e-06` for the golden, the last one pixel wide even at `R = 2048`. **Verified** (`lab/py/spin-render`).

Spinning does not touch the fade. At `R = 1024` over the full square, `c = rms sqrt(L)` at `L = 28` reads `0.460395` unspun, `0.401417` one-degree, `0.427986` golden, `0.425189` prime-degree, `0.423811` random and `0.440940` Gaussian, and the disc mean of paper coverage stays between `0.764167` and `0.768898` across every schedule and every resolution: rotation moves no ink, only its arrangement. The unspun row over `L = 4, 8, 14, 28` reads `0.309907, 0.390837, 0.427756, 0.460395` against the exact `0.309477, 0.389754, 0.426869, 0.458411` from summing the rational covariance formula over the scale pairs with no render at all, the raster reading a little high at every one. **Verified** (`lab/py/spin-render`). The `0.522` of the [moire-correlation-laws](https://github.com/carlomitchener/carlomitchener/tree/main/research/moire-correlation-laws) lane is the limit of that exact sequence and not its value at 28 layers, which is `0.458411`.

Averaging the layers is one blend and folding them to their [parity](/wiki/parity/) is another, and the second has an exact answer where the first has a raster. Give scale `n` its carpet `C_n(u, v) = chi_n(u) chi_n(v)`, take the XOR of the odd layers to `N`, and ask what fraction of the unit square it inks. Write `s_n = 1 - 2 C_n` for the signed layer, so `prod_n s_n = (-1)^(sum_n C_n) = 1 - 2 XOR` and the fill is `(1 - E[prod_n s_n])/2`. Expand `prod_n (1 - 2 C_n) = sum_S (-2)^|S| prod_(n in S) C_n` over subsets of the scales; each term splits as `prod_(n in S) C_n(u, v) = [prod_(n in S) chi_n(u)][prod_(n in S) chi_n(v)]`, so its mean over the square factorises into `m_S^2` with `m_S` the measure of the set of `u` in `[0, 1)` where every `floor(n u)`, `n in S`, is odd. Hence `fill(N) = (1 - sum_S (-2)^|S| m_S^2)/2`, and every `m_S` is a rational cell count on the grid of `lcm(S)`, since each `chi_n` is constant on cells of side `1/lcm(S)`. **Proved** (`lab/py/parity-fill`, `fill_exact`). Layer `n = 1` is blank on the square, so the sum runs over subsets of `3, 5, ..., N`.

The values are rational and they do not climb. At `N = 3, 5, ..., 21` the fill reads `1/9`, `53/225`, `3524/11025`, `36284/99225`, `19619/51975`, `117419647/289864575`, `109067744/289864575`, `17006699344/45107387325`, `6812188030619/19244451701475` and `1114185811873/2749207385925`, which is `0.111111111` climbing to `0.405084502` at `N = 13`, falling to `0.376271381` at `N = 15`, falling again to `0.353981924` at `N = 19` and returning to `0.405275287` at `N = 21`. **Verified** by two routes sharing no line, the subset expansion summed in integers over the common denominator and a literal XOR of the layer products counted cell by cell on the `lcm x lcm` grid at every `N <= 9` with zero mismatches, and against a `4096 x 4096` raster mean at every `N` within `2.42e-04` (`lab/py/parity-fill`, `fill_exact` and `fill_literal`).

What makes the sequence lurch is that most subsets contribute nothing: `587` of the `1024` subsets of `{3, 5, ..., 21}` have `m_S = 0`. The smallest is `{3, 5, 7}`, and it is a three-line check: `floor(3u)` odd is `u in [1/3, 2/3)`, `floor(5u)` odd cuts that to `[1/3, 2/5) u [3/5, 2/3)`, and neither piece meets `[1/7, 2/7) u [3/7, 4/7) u [5/7, 6/7)`. **Proved.** So the three coarsest live scales are never all inked at one `u`, and the parity fold loses a term the independent picture would have kept.

That vanishing is exactly where the coin model breaks. Layer `n` has mean `p_n = ((n-1)/(2n))^2`, and independent Bernoulli layers would XOR to `(1 - prod_n (1 - 2 p_n))/2`; since `1 - 2 p_n -> 1/2`, that model's deviation from `1/2` is `O(2^-L)` with successive ratios reading `0.680000, 0.632653, 0.604938` down to `0.546485`. **Proved.** At two coprime scales the moire correlation law makes the layers independent outright, so the exact and the approximate fills agree to the digit at `N = 3` and `N = 5`. From `N = 7` they separate, because `m_{3,5,7} = 0` against the independent `2/35`, and the exact fill sits below the approximation at every `N` from `7` to `21`, by `-1.31e-02` at `N = 7` widening to `-1.40e-01` at `N = 19`. **Verified** (`lab/py/parity-fill`, `section_independent`). The rate does not transfer with the value: the exact deviation's ratios read `0.680000, 0.682044, 0.744755, 0.912184, 0.774630, 1.303566, 0.993894, 1.187399, 0.648719`, exceeding `1` twice, and the ratio of the exact deviation to the independent one grows from `1.000000` at `L = 2` to `29.337331` at `L = 11`. **Refuted**, the independent model as a rate for the parity fold, same generator. Pairwise independence is not joint independence, and the parity blend is the observable that sees the difference: it is a function of every subset mass at once, where the fade is a function of the pairs alone. That `fill -> 1/2` is **Conjecture**, on the raster reading `0.320427, 0.375175, 0.424397, 0.444069` at `L = 4, 8, 14, 28` with the exact deviation still `9.47e-02` at `L = 11` and no rate derived; a proof through the moire correlation law is not immediate, the law controlling pairs while the expansion needs every subset mass, and the expansion is `2^L` terms on the grid of `lcm(3, ..., N)`, so exact values stop at `L = 11`, `N = 21`, `lcm = 14549535`.

Spun, the fill goes to the middle and stays there. On a `1024` raster masked to the inscribed disc at `N = 55`, the parity fill reads `0.472574` unspun, `0.490510` at one degree per layer index, `0.505291` at prime degrees, `0.503331` golden, and `0.500821, 0.491967, 0.500658, 0.502868` at the eyes `90/q` for Farey denominator `q = 2, 3, 4, 5`. The unspun stack is the outlier at `2.74e-02` from `1/2` and no spun schedule departs by more than `9.49e-03`; the raster band is about `3e-03`, the unspun reading running `0.478511, 0.475647, 0.472574, 0.473205` over `R = 256, 512, 1024, 2048`, so the unspun offset survives by a factor of nine where the individual spun offsets mostly do not. **Verified** as raster readings (`lab/py/parity-fill`, `section_spun`).

The eyes were the thing to look for and they are not there. Sweeping the fixed increment over every whole degree from `0` to `90` at `N = 55` and `R = 512`, the `89` nonzero increments span `0.490165` to `0.511161`, and the eyes at `18`, `30` and `45` read `0.500185`, `0.494657` and `0.500282`, inside the band and at neither end; the extremes are the unspun `0.475647` at `0` and `90` and `0.511161` at `23` and `67`. **Refuted**, the expectation that a rational increment, where whole classes of layers share a lattice, shows in the parity fill. Coincident layers do not cancel: layers in one angle class carry different scales and share only a sublattice of nodes, never the whole picture.

Two exact symmetries close that sweep and check the raster. At odd `n`, `chi_n(1 - u) = chi_n(u)`, and `C_n` is symmetric in its two coordinates, so every layer is invariant under the quarter turn about the centre. Hence the increment `90` stack is the unspun stack layer for layer, and the increment `d` stack is the mirror image of the increment `90 - d` stack, which on the rotation-invariant disc gives `fill(90) = fill(0)` and `fill(d) = fill(90 - d)`. **Proved**, and **Verified** on the sweep, which reads `0.475647` at both `0` and `90` and matches `45` of the `46` mirror pairs to the bit, the one exception differing by `9.71e-06` in `float32` (`lab/py/parity-fill`, `section_sweep`).

A raster sees near-coincidences, so a spun stack is never blank, and the drift test that would decide whether a stable off-centre peak is an exact node decides nothing. The stack is piecewise constant on cells of positive area, so its maxima are plateaus, and any plateau wider than a pixel is found in the same place at every resolution: positional stability measures a cell's area, not whether the layers coincide there. The prime-degree schedule supplies the witness, its peak `16/28` at `(0.19469, 0.15501)` holding its value at all four resolutions and drifting `0.29` pixels over `1024 -> 2048` under whole-degree angles, where the dead-spin theorem forbids an exact node; it is a polygon of area `1.65596e-05` where 16 rotated carpets overlap. **Refuted**, resolution stability as a falsification route (`lab/py/spin-render`). What the picture does carry is the two numbers that are not about position at all: the peak value and the peak cell area, both of which fall.

The renders are `stack-unspun.png`, `stack-degrees.png`, `stack-primes.png` and `stack-gaussian.png` under `lab/py/spin-render`, with the four at quarter size in `stack-sheet.png`. Unspun is a lattice of straight rays through the diagonals; the whole-degree fan pleats them into curved bands; the prime and golden schedules wind them into a vortex of arms about the centre with the centre node a single dark speck; the Gaussian schedule keeps the straight rays, nineteen of its twenty-eight angles being zero. The vortex is an observation of a picture and no theorem is claimed from it.

## Levels and designs

Two layers of a stack meet in one number, the covariance of the two periodic pictures over the square, and one law computes it for every pair. For 1-periodic `f` and `g` with Fourier coefficients `hat f(k)`, `hat g(k)`, writing `d = gcd(m,n)`, `m' = m/d` and `n' = n/d`,

```
int_0^1 f(mx) g(nx) dx = sum_j hat f(j n') hat g(-j m')
```

and the covariance is the same sum over `j != 0`. **Proved**, in three lines: expand both factors, integrate term by term, and note that `km + ln = 0` with `gcd(m',n') = 1` forces `k = j n'` and `l = -j m'`. Everything below is that sum at different `f` and `g`.

The parity family is the check. With `F(x) = (-1)^floor(2x)` the 1-periodic square wave, `hat F(k) = 2/(pi i k)` at odd `k` and `0` elsewhere, the law gives `sum_{j odd} 4/(pi^2 j^2 m'n')`, which [the odd Basel sum](/wiki/basel-problem/) `pi^2/8` turns into `gcd(m,n)^2/(mn)`. **Proved**, and **Verified** by exact rational integration on the lcm grid at all 820 pairs to 40, reading `1/15` at `(3,5)` and `1/3` at `(3,9)` and `(5,15)`, with the layer covariance `(gcd^2 - 1)/(4mn)` zero at all 159 coprime odd pairs (`lab/py/stack-levels`).

That recovery sharpens the landed law rather than breaking it. The tree's layer `chi_n` has mean `(n-1)/(2n)`, and the signed wave `s(nx) = (-1)^floor(nx)` under it has mean `1/n`, because the unit interval holds `(n-1)/2` full periods of that wave and one half period; that single half period is the whole of the coprime vanishing. Lay the same parity rule down genuinely 1-periodically, `p(x) = 1` iff `floor(2x)` is odd, and its covariance is `gcd(m,n)^2/(4mn)` when `m'` and `n'` are both odd and `0` otherwise, reading `1/60` at `(3,5)` and nonzero at 159 of the 490 coprime pairs to 40. **Proved** from the law above, **Verified** at all 820 pairs (`lab/py/stack-levels`). Coprime independence is therefore a property of the odd-scale half-period sampling, not of the parity rule; the landed law's hypothesis is exactly that sampling, so this is a sharpening of it and not a break.

Outside the parity family the law is 3-adic. The 1D shadow of the base-3 Sierpinski carpet at level `level` is `f_level(x) = 1` iff none of the first `level` base-3 digits of `x` is 1, and its coefficient is `hat f_level(k) = (-1)^k 2^level sin(pi k/3^level) prod_{i = 1..level} cos(2 pi k/3^i)/(pi k)` with `hat f_level(0) = (2/3)^level`, real, even, and zero exactly at `k != 0` with `3^level | k`. **Proved**, by summing `e(-ka)` over the `2^level` interval offsets. Three laws follow: the covariance depends only on the reduced scales; it vanishes whenever `3^level` divides `m'` or `n'`, that is whenever `|v_3(m) - v_3(n)| >= level`; and the product `Cov * m'n'` depends only on `m'` and `n'` modulo `3^level`, an odd symmetric kernel `G_level` with `G_level(0, b) = 0`. **Proved**, and **Verified** with zero failures at all 820 pairs to 40 and `level 1, 2, 3` (`lab/py/stack-levels`). At level 1 the kernel is a character: `Cov(f_1(mx), f_1(nx)) = (2/9) chi(m') chi(n')/(m'n')` with `chi` the nontrivial character mod 3, since `hat f_1(k) = chi(k) sqrt(3)/(2 pi k)` turns the sum into twice `sum_{3 not | j} 1/j^2 = (8/9) zeta(2)`. **Proved**, and **Verified** at all 1600 ordered pairs to 40, reading `-1/9` at `(1,2)`, `1/45` at `(2,5)` and `0` at `(1,3)` (`lab/py/stack-levels`).

That is a gcd law twisted by a character, and it settles the question. The shape survives, `gcd(m,n)^2` over `mn` up to a bounded factor; the zero set does not. It is `v_3(m) != v_3(n)`, not `gcd(m,n) = 1`, and `Cov(f_1(x), f_1(2x)) = -1/9` at a coprime pair says the layers can even be anticorrelated. There is no prime detector in base 3. **Refuted**, the hypothesis that the gcd law and coprime independence extend outside the parity family. The level-1 law does not lift either: `G_2(1,1) G_2(4,4) - G_2(1,4)^2 = 76/729` on the units mod 9, so no product form `theta(a) theta(b)` reproduces the kernel above level 1. **Refuted**, separability at `level >= 2` (`lab/py/stack-levels`). Whether the vanishing condition is also necessary above level 1 stays open, holding over `m, n <= 40` and `level <= 3` with 240, 410 and 463 of the 490 coprime pairs carrying nonzero covariance at `level 1, 2, 3`, and the same for the cross-level rule `Cov(f_level(mx), f_level2(nx)) = 0` at two levels `level` and `level2` when `3^level | n'` or `3^level2 | m'`, sufficient by the vanishing coefficients and with no breach over all 14400 ordered triples in that domain (`lab/py/stack-levels`). **Conjecture.**

Levels are not new layers. The digit test factors as `f_level(x) = f_1(x) f_{level-1}(3x)`, hence `f_level(x) = prod_{i = 0..level-1} f_1(3^i x)`, so a layer at level `level` and scale `n` is the pointwise product of level-1 layers at the scales `n, 3n, ..., 3^{level-1} n`: stacking a design at higher level adds no direction those layers do not already span, it multiplies them. **Proved**, and **Verified** as an identity of masks at `level 1, 2, 3, 4` (`lab/py/stack-levels`). Redundancy in the other direction fails. The same factorisation gives `f_level(nx) <= f_{level-1}(3nx)` pointwise with gap the top digit test at scale `n`, of measure `(2/3)^{level-1}/3`, so the containment is strict: level `level-1` at scale `3n` is not the same picture as level `level` at scale `n`, and the cross-covariance is not symmetric in the two levels, `Cov(f_2(x), f_1(3x)) = 4/27` against `Cov(f_1(x), f_2(3x)) = 0`. **Refuted**, the redundancy (`lab/py/stack-levels`).

Across bases one pair is exactly orthogonal, and for a reason of symmetry rather than arithmetic. Between the base-2 odd strip and a base-3 one-digit-removed shadow the law is `c/(18 m'n')` with `c` in `-3, 0, 3`, and `c = 0` identically against the Sierpinski shadow, all 1600 scale pairs exactly zero: the middle-thirds set is symmetric under `x -> -x` so its centred indicator is even, while `p(-x) = 1 - p(x)` almost everywhere makes the centred strip odd, and an even function is orthogonal to an odd one. **Proved**, **Verified** at every design and scale pair swept (`lab/py/stack-levels`). Between two base-3 shadows the law is `c/(27 m'n')` with `c` in `-6, -3, 3, 6`, never zero, so no two base-3 designs are coprime-independent whenever `v_3(m) = v_3(n)`. **Proved**, **Verified** at all nine ordered design pairs and all 1600 scale pairs (`lab/py/stack-levels`).

Finally the layers of the parity stack are linearly independent and the determinant is closed. Normalise the Gram matrix by the master integral, entries `G(m,n) = gcd(m,n)^2/(mn)` over odd `m, n <= 2K+1`. The odd numbers are factor-closed, so with `J_2` the Jordan totient and `k^2 = sum_{d | k} J_2(d)` the matrix is `E D E^T` for `E` the divisibility incidence matrix and `D = diag(J_2(k)/k^2)` conjugated by `diag(1/m)`, and ordering the odds increasingly makes `E` unitriangular. Hence `det G = prod_{k odd <= 2K+1} prod_{p | k} (1 - p^-2)`. **Proved**, and **Verified** against exact elimination at `K = 1..12`, the value at `K = 12` being `11399736556781568/21994507608198125` (`lab/py/stack-levels`). Every factor is positive, so the stack has as many degrees of freedom in `L^2` as it has layers.

## The layers as a dilation system

The stack's layers are one function seen at every scale, and that is a named object with a theory attached. The square wave `s(x) = (-1)^floor(x)` is exactly the odd 2-periodic extension of the constant function `1` on `(0,1)`, so the layers `s(nx)` are the dilates `phi(nx)` of a single `phi in L^2(0,1)` in the sense of Hedenmalm, Lindqvist and Seip, [arXiv:math/9512211](https://arxiv.org/abs/math/9512211), who ask when such a system is a Riesz basis or a complete sequence in `L^2(0,1)` and answer through a Dirichlet series. Against the orthonormal basis `e_n(x) = sqrt 2 sin(n pi x)` the coefficients are `a_n = 2 sqrt 2/(pi n)` at odd `n` and `0` at even `n`, so the symbol of the parity stack is

```
S(s) = sum_n a_n n^-s = (2 sqrt 2/pi) (1 - 2^(-1-s)) zeta(1 + s).
```

**Proved**, by integrating the constant against `e_n`, and **Verified** in the form the rest of the section uses, `<s(nx), e_k> = a_(k/n)` when `n | k` and `0` otherwise, to `1.16e-15` over `n <= 8` and `k <= 60` (`lab/py/stack-dilations`, `check_dilation_shift`). The isometry `e_n -> n^-s` therefore sends the layer `s(nx)` to `n^-s S(s)`: the stack is the multiplication operator by `S` written out in a basis.

The Gram matrix of the layers is the landed correlation law, and the law's parity clause is the symbol's support. Under that isometry `<s(mx), s(nx)>` is `sum_j a_(j n') a_(j m')` with `g = gcd(m,n)`, `m' = m/g` and `n' = n/g`, which is `0` unless `m'` and `n'` are both odd and otherwise `(8/pi^2)(pi^2/8)/(m'n') = gcd(m,n)^2/(mn)` by the odd Basel sum. That is the moire correlation law with its general-integer hypothesis, recovered as a statement about one Dirichlet series rather than about a pair of scales. **Proved**, and **Verified** at all 78 pairs `m <= n <= 12` two ways, exact rational integration on the `lcm` grid against the symbol sum, reading `1/15` at `(3,5)`, `1/3` at `(3,9)` and `0` at `(2,3)`, with the truncated symbol sum inside its own tail bound at every pair (`lab/py/stack-dilations`, `check_gram_two_ways`).

One structure statement makes the odd convention harmless. The entry vanishes unless `v_2(m) = v_2(n)`, and the block at `v_2 = a` is the odd Gram `gcd(m,n)^2/(mn)` itself, so the Gram of the full dilation system is a countable direct sum of copies of the odd one. The half-period sharpening above is the same object once more: `p(nx) - 1/2 = -(1/2) s(2nx)`, so the 1-periodic layers with covariance `gcd(m,n)^2/(4mn)` are the `v_2 = 1` block scaled by `1/4`. **Proved**, and **Verified** at all 2730 ordered pairs to 64 (`lab/py/stack-dilations`, `check_blocks`). Every spectral question about the stack is therefore a question about the odd Gram alone.

The verdict is that the parity stack sits exactly on the boundary of the Riesz condition. Their Theorem 5.2 makes `{phi(nx)}` a Riesz basis of `L^2(0,1)` if and only if `S` and `1/S` are both multipliers of their space of Dirichlet series, and their Theorem 3.1 identifies the multipliers as exactly the Dirichlet series bounded in the half-plane `Re s > 0`, with multiplier norm the supremum there. `S` is unbounded there, `(1 - 2^(-1-s)) zeta(1 + s)` blowing up as `s -> 0+`, so the parity stack is not a Riesz basis of `L^2(0,1)`. **Proved**, by those two theorems and nothing else. Their Corollary 5.3 reaches the same verdict along the arithmetic route, specialising to totally multiplicative coefficients, where the system is a Riesz basis if and only if `sum_p |a_p|` converges over the primes: the parity coefficients are totally multiplicative after dividing by `a_1 = 2 sqrt 2/pi`, which is the hypothesis the corollary needs since both verdicts are invariant under scaling `phi` by a nonzero constant, and `sum_p |a_p|` is `(2 sqrt 2/pi) sum_(p odd) 1/p`, divergent by Mertens. **Verified** in the checkable half, the Dirichlet inverse of `a/a_1` being `mu(n)/n` on the odd `n` at every `n <= 400`, with the prime sum already at `1.9854` for `p <= 100000` (`lab/py/stack-dilations`, `check_inverse`).

Which condition fails is the whole content. Their own example is `phi = sum_n e_n/n^tau`, symbol `zeta(tau + s)`, a Riesz basis if and only if `tau > 1`; the parity stack is that example at the boundary case `tau = 1`, restricted to the odd integers, and it fails because `zeta(1 + s)` has its pole at `s = 0`, on the edge of the half-plane the theorem tests. The failure is not an accident of the parity rule: it is the pole of zeta, which is the statement that there are infinitely many primes. **Proved**.

What the system is instead is sharp on both sides. Its coefficients are totally multiplicative after the same division by `a_1`, so by their Corollary 5.8 the layers are complete in `L^2(0,1)`: nothing in the unit interval is invisible to the parity stack. They are also minimal, with an explicit biorthogonal system `psi_n(x) = sum_(d | n) b_(n/d) e_d(x)` built from the Dirichlet inverse `b`, and that biorthogonal system consists of dilates of a single function only in the trivial case `phi = e_1`, so the Mobius square wave's own dilates are not the dual basis. **Proved**. The frame bounds are the symbol's range: their proof gives `B = sup(Re s > 0) |S|` and `A = inf(Re s > 0) |S|`, and here `B` is infinite by the pole while `A` is zero, because a positive `A` would say `1/zeta(1 + s)` is bounded on `Re s > 0`. It is not: by their Lemma 2.4 every character gives a vertical limit function of `S`, and at the Liouville character the limit is `(2 sqrt 2/pi) prod_(p odd) (1 + p^(-1-s))^(-1)`, which tends to `0` as `s -> 0+` because the reciprocals of the primes diverge. **Proved**, and classical: it is the extreme-value statement `liminf_t |zeta(1 + it)| = 0`. The parity stack is complete, minimal, and neither a frame nor a Riesz sequence.

The finite spectrum is computable and it moves like `log log`. The odd Gram over the first `K` odd scales has `lambda_max` rising from `2.01467` at `K = 25` to `2.47224` at `K = 200` and `lambda_min` falling from `4.393e-01` to `3.570e-01`, condition number `4.586` to `6.926`, with the determinant matching the Smith product `prod_{k odd} prod_{p | k} (1 - p^-2)` exactly at `K = 1..13`. **Verified**, in that window and with no exponent claimed (`lab/py/stack-dilations`, `spectrum` and `check_determinant`). The divergence is real but slow, and the reason is that the layer Gram is a gcd matrix at exponent one: the spectral norm of `gcd(m,n)^2/(mn)` over any `k` distinct integers is of order `(log log k)^2` and that order is sharp. That is Theorem 2 of Lewko and Radziwill, [arXiv:1408.2334](https://arxiv.org/abs/1408.2334), which settles the exponent-one spectral norm left open by the result it refines, Gal's 1949 bound on the gcd sum itself; their extremal sequences are supported on very smooth integers rather than on the odd scales, and their displayed bound carries a `1/k` that has to be a misprint, since with it the statement would be weaker than the trace bound `lambda_max <= k` that the unit diagonal already gives, so only the order is read off here and no constant. The pole heuristic, that a stack of `N` layers should reach `|S|^2` at `Re s` of order `1/log N` and grow like `(log N)^2`, is therefore **Refuted**: that growth exceeds the `(log log k)^2` ceiling, and the window agrees, `lambda_max/(log N)^2` falling by a factor `1.93` across it against `1.41` for `lambda_max/(log log N)^2`. That `lambda_max` grows like `(log log K)^2` and `lambda_min` decays like its reciprocal, on the odd scales specifically, is **Conjecture**, the ceiling being attained on smooth sets that the odd scales are not.

The place of the Riemann hypothesis is now exact, and it is one line away. The parity stack's symbol is `zeta` evaluated at `1 + s` with `Re s > 0`, so every question the dilation theory asks about the stack is a question about `zeta` on and to the right of the line `Re s = 1`: the pole decides the upper frame bound, and how small `|zeta(1 + it)|` gets decides the lower one. That the lower bound fails by size and not by a zero is the prime number theorem in its equivalent form `zeta(1 + it) != 0`, which keeps `1/S` analytic on the whole closed half-plane apart from the pole. The critical line never enters. Weighting cannot bring it in either: a weight `w` on the scales multiplies the symbol by the Dirichlet series of `w` at the same `s`, so the Mobius weight sends `S` to `a_1^2/S`, the reciprocal up to that constant, and the Mobius stack's dilation system fails the same Riesz test by the same divergent prime sum. **Proved**. The Nyman-Beurling criterion is a completeness statement for a different dilation system, the `{1/x}`-type functions, and it is not this one. So the tree's honest cap is unchanged and now carries a mechanism: the stack renders `zeta` and `1/zeta` on the line `Re s = 1`, and no reweighting moves the line.

## Stacking the nodes

What the stack adds so far is ink. A layer also carries nodes: its **edge set**, the cell sides separating an inked cell from a paper cell or from outside the square, and its **corner set**, the vertices of its inked cells. Stacking those gives a measure on segments and a measure on points, and a segment or a point is lit by the number of layers that contain it. Where the ink stack answers how dark a pixel is, the node stack answers how many layers meet exactly here, so the layers are seen meeting rather than overlapping.

The parity layer at odd scale `n` inks cell `(i, j)` when `i` and `j` are both odd. Crossing `x = k/n` inside an even row leaves paper on both sides, while inside an odd row exactly one of the two consecutive column indices `k-1, k` is odd, so the crossing flips ink to paper; at `k = 0` and `k = n` the neighbouring index is `0` or `n-1`, both even at odd `n`. The edge set is therefore the interior grid lines restricted to the odd rows and columns, together with its transpose, and the border of the square carries no edge at all; the corner set is cleaner still, being exactly the interior grid vertices `{(k/n, l/n) : 1 <= k, l <= n-1}`, since each of `k-1, k` holds one odd index and neither `0` nor `n` does. **Proved**, and **Verified** by building the literal edge and corner sets cell by cell at every odd `n <= 15` with zero mismatches (`lab/py/node-stack`, `check_parity_edges` and `check_parity_corners`).

That identification turns the corner stack into number theory with nothing left over. A point `(a/b, c/d)` in lowest terms is an interior vertex of layer `n` exactly when `b` and `d` both divide `n`, so it is lit by the odd multiples of `lcm(b, d)` up to `N`: the lit set is the Farey field of odd denominators in the open unit square, `b` and `d` odd with `lcm(b, d) <= N`, and the brightness is `floor((floor(N/lcm(b,d)) + 1)/2)`. **Proved**, and **Verified** at `N = 15` by two routes, literal stacking and the closed form agreeing on all `536` lit points with none missed, none invented and no value mismatch, the top brightness `3` at the four denominator-3 points (`lab/py/node-stack`, `parity_corner_stack` and `parity_corner_predicted`). This is the line stack's `floor(N/b)` seen in two dimensions and cut by the odd convention: the same nodes, a brightness halved by the parity of the scales, and the whole centre cross missing because every even denominator is dark.

The edge stack between those corners factors. A whole line `x = a/b` is an edge line of `floor((floor(N/b) + 1)/2)` layers at odd `b` and of none at even `b`, and the brightness at a point `(a/b, y)` of that line is the number of odd `n <= N` with `b | n` and `floor(ny)` odd: the line stack in one coordinate times the one-dimensional parity stack in the other. **Proved**, and **Verified** at `N = 15` on all `48` lit lines and at the midpoint of every elementary interval of the union of all layers' grids, `2352` segment tests with zero breaches (`lab/py/node-stack`, `check_line_brightness_parity` and `parity_segment_check`).

The base-3 carpet lights its walls and never its periods. At a period boundary the two neighbouring columns carry all-`2` and all-`0` digits, which collide with nothing, so both cells are inked at every row and the period lines `x = k/n` are never edge lines; every other residue does carry an edge, in an explicit row set, `J_1 = {1, 2}` at level 1 and `J_2 = {1, ..., 8}` at level 2. A reduced `a/b` is lit by layer `n` exactly when `b | 3^level n` and `a (3^level n / b) mod 3^level` lies in `J_level`. **Proved**, with zero layer mismatches at `N = 12, level 1` and `N = 6, level 2` (`lab/py/node-stack`, `edge_residues` and `check_carpet_lines`). Since `J_level` misses only the residue `0` the criterion collapses to the 3-adic valuation `s = v_3(b)`: the lit lines are `{a/b : 3 | b, b/3^min(s, level) <= N}` and the brightness telescopes over the layers whose valuation lands in `[max(0, s-level), s-1]`, giving `floor(N/(b/3^min(s, level))) - floor(N/b)`. **Proved**, and **Verified** against literal stacking on `106` lit lines at `N = 12, level 1` and `100` at `N = 6, level 2`, sets equal and zero brightness breaches on either (`lab/py/node-stack`, `carpet_lines_reach` and `check_line_brightness_carpet`).

A line is lit in pieces, and the segment count is the finer object: the edge at `(a/b, y)` exists exactly when the column residue lies in `J_level` and `floor(3^level n y) mod 3^level` lies in that residue's row set, and summing over layers gives the segment brightness. **Proved**, and **Verified** at the midpoint of every elementary interval of every lit line, `14628` tests at `N = 12, level 1` and `10800` at `N = 6, level 2` with zero breaches; the segment census at `N = 12, level 1` reads 18 segments at brightness 4, 60 at 3, 108 at 2 and 1156 at 1, the first six of the eighteen being `{1/3} x [1/3, 11/30]` with its three mirrors and `{1/3} x [10/33, 1/3]` and `{1/3} x [16/33, 17/33]`, against the `8` the line form above gives at `x = 1/3`, so line brightness is an upper bound that no point of the line attains (`lab/py/node-stack`, `carpet_segment_check` and `top_segments`).

The carpet's corners are level-dependent. At level 1 the two columns `k-1, k` hold at most one index congruent to `1 mod 3`, so at most one of a vertex's four cells is paper and every vertex of the `3n` grid is a corner, whence the brightness is `floor(N/(m/gcd(m,3)))` with `m = lcm(b, d)`. **Proved**, and **Verified** at `N = 12` with `5029` lit corners, zero breaches against literal stacking and top brightness `12` at the points whose coordinates have denominator 1 or 3 (`lab/py/node-stack`, `carpet_corner_stack` and `carpet_corner_form`). Against the plain Farey pair count at the same order, `|F_36|^2 = 157609`, the stack lights `5029`: the corner stack is a sparse subfield of the Farey field rather than a thinning of it. At level 2 the vertex grid is not the whole grid, `96` of the level-2 tile's `100` vertices being corners and the four points `(4/9, 4/9)`, `(4/9, 5/9)`, `(5/9, 4/9)`, `(5/9, 5/9)` having all four incident cells papered by the first-level collision; the closed form above needs that exclusion at `level >= 2` and is not extended here. **Proved** by exhaustion of the tile (`lab/py/node-stack`, `carpet_corners`).

One reading has to be closed before a reader takes it. The tree's Farey door restricts the denominator by a cutoff, `b <= Q`, and every design gives the same node set there; this family restricts the denominator by a divisibility, `3 | b`, with a level-dependent cutoff. The condition producing it is written on the numerator, but for the Sierpinski carpet `J_level` is every nonzero residue and the numerator drops out, so there is no numerator-restricted Farey cousin here and the two families must not be conflated. **Refuted**, witness `J_1 = {1, 2}` and `J_2 = {1, ..., 8}` (`lab/py/node-stack`, `edge_residues`). Where the cousin should be looked for is a sibling design: a base-3 design removing the digit vector `(0, 0)` has a residue set that is proper and misses a nonzero residue, which is a genuine condition on `a mod 3`. That is the open door, and no study on this tree prints it yet.

Levels enter here exactly as they do above: because a layer at level `level` is a product of 3-power-scaled level-1 layers, the level-2 corner stack is a `9 x 9` lattice of Farey fields, one per level-2 cell. The four renders are `edges-parity.png` and `corners-parity.png`, the parity edge and corner stacks over the odd scales `n <= 31`, and `edges-carpet.png` and `corners-carpet.png`, the base-3 carpet at `level 2` over the scales `1..12`, with the four at quarter size in `nodes-sheet.png`, all under `lab/py/node-stack`. A raster cannot show a coincidence: every count in this section is exact arithmetic checked against literal stacking, and the pictures only illustrate which nodes are bright.

## The leaning stack

Every stack above is a weight on the scales, and a weight cannot move a line. Lean the stack instead: translate layer `n` by a drift `t_n`, so its lines sit at the `x` with `n x - theta_n` an integer, where `theta_n = n t_n mod 1` is the phase of the layer. Brightness is still a count of layers through a point, `B_N(x) = #{n <= N : n x - theta_n in Z}`, and the plain stack is `theta_n = 0`. Two drifts decide everything. The constant drift `t_n = delta` gives the linear phase `n delta`; the index-proportional drift `t_n = n delta` gives the quadratic phase `n^2 delta`, the leaning tower. The first is the plain stack in disguise. The second is not a weighted stack at all: it moves where a layer draws rather than how much that layer counts, it leaves the Dirichlet group of weights, and it still lands a closed form.

The linear lean is a translation and nothing more. With `theta_n = n delta` the condition `n x - n delta in Z` is `n (x - delta) in Z`, so the whole picture is the plain stack slid along the circle: the lit set is `F_Q + delta` and the brightness at `delta + a/b` is `floor(N/b)`. **Proved**, in one line, and **Verified** at `N = 30` over all 278 reduced nodes with `b <= 30`, exactly in rationals at `delta = 2/7` with 0 brightness mismatches and 0 nonzero readings off the translate, and at `1e-12` for `delta = sqrt 2 - 1` and `phi - 1` with 0 mismatches; at an irrational drift no rational point is lit at all, the closest a rational point comes to a coincidence being `0.000036` and `0.000041` (`lab/py/leaning-stack`, `linear_lean`).

The quadratic lean is a congruence. Write the drift as `delta = c/d` in lowest terms and the point as `x = a/b` in lowest terms. Then `n a/b - n^2 c/d = n (a d - b c n)/(b d)`, so layer `n` lights `a/b` exactly when

```
n (a d - b c n) = 0 mod b d
```

a quadratic congruence in `n`. **Proved.** Its solution set is a union of arithmetic progressions, so brightness is floor-linear in `N`, and the whole question is the period and the classes.

The class structure is closed, and the arithmetic of squares sets it. Write `d*` for the least `k` with `d | k^2`, that is `d* = prod p^ceil(v_p(d)/2)`, and read the congruence prime by prime with `beta = v_p(b)` and `delta_p = v_p(d)`. At a prime with `delta_p < beta` or `delta_p >= 2 beta` the only solution class is `n = 0` modulo `p^max(beta, ceil(delta_p/2))`. At a prime in the middle band `beta <= delta_p < 2 beta` there are two, `n = 0` and `n = p^(delta_p - beta) u` modulo `p^beta`, with `u = a d' (c b')^-1 mod p^(2 beta - delta_p)` where `b' = b/p^beta` and `d' = d/p^delta_p`. Recombining by the Chinese remainder theorem, **the lit layers form a union of `2^w` residue classes modulo `lcm(b, d*)`, with `w` the number of primes in the middle band**, and the brightness is the sum over those classes of `floor((N - s)/lcm(b, d*)) + 1`. **Proved**, and **Verified** twice with the expectation coming from outside the sweep: the closed form's residue set against the literal solution set `n (a d - b c n) mod b d`, 0 mismatches over the 46 reduced `a/b` with `b <= 12` against the seven drifts `1/2, 1/3, 1/4, 2/5, 1/6, 3/8, 5/9`, and the brightness against literal stacking from the definition, 0 mismatches over all 128 reduced `a/b` with `b <= 20` against all 80 reduced drifts with `d <= 16`, 10240 point-drift pairs at `N = 60` (`lab/py/leaning-stack`, `brightness_form`, `adversarial`).

That modulus is a period and not always the least one, and the exception is `2`-adic. The least period is `lcm(b, d*)/2` exactly when `v_2(b) >= 1` and `v_2(d) = 2 v_2(b) - 1`, and `lcm(b, d*)` otherwise: in that one case the middle-band class at `2` is `2^(beta-1)` times a unit, so the two classes are closed under addition and collapse to one. **Proved**, and **Verified** over all 16384 reduced tuples with `b, d <= 20`, where the least period falls below `lcm(b, d*)` at 417 of them with 0 breaches of the rule (`lab/py/leaning-stack`, `minimal_period_law`). The point that makes the lean famous is one of them: `x = 1/2` at `delta = 1/2` has classes `0, 1` mod `2`, which is all of `Z`, least period `1`. No brightness moves, the count being over classes rather than periods.

Two things about that law have no analogue anywhere else on this tree. The first is that **the lit set reads the numerator**. Every family the tree has met is decided by the denominator alone: `floor(N/b)` on the line stack, `lcm(b,d)` on the corner stack, `3 | b` on the base-3 edge stack, where the numerator condition collapses because the residue set is everything. Here the extra class carries `a` through the unit `u`, so two points with the same denominator are lit by different layers. At `delta = 1/4` the point `1/4` is lit by `n = 0, 1 mod 4` and first at `n = 1`, while `3/4` is lit by `n = 0, 3 mod 4` and first at `n = 3`, giving `B_61 = 31` against `30`; over `b <= 12` and `d in 2, 4, 8, 9` there are 48 reduced pairs whose first lit layer moves with the numerator, and every first-lit prediction matches the literal search at all seven drifts. **Proved**, and **Verified** (`lab/py/leaning-stack`, `lit_set`). **Refuted**, the reading that stack brightness is a function of the denominator, outside the plain stack.

The second is that **the brightest node need no longer be the origin**. At `x = 0` the condition is `d | c n^2`, that is `d* | n`, so the origin reads the plain stack at scale `d*`: its brightness is `floor(N/d*)`. **Proved**, and **Verified** over every reduced drift with `d <= 60` at `N = 60` with 0 mismatches. Meanwhile the drift hands its own points full brightness, and beats the origin at five of the seven drifts printed: at `delta = 1/2` every layer passes through `x = 1/2`, top brightness `60` at `N = 60` against `30` at the origin, at `delta = 1/3` the top is `40` at `1/3` and `2/3` against `20`, at `delta = 2/5` it is `24` at the four fifths against `12`, at `delta = 1/6` it is `40` at `1/6` and `5/6` against `10`, at `delta = 3/8` it is `30` at `1/4` and `3/4` against `15`, while at `delta = 1/4` and `5/9` the origin ties for top (`lab/py/leaning-stack`, `quadratic_lean`, `origin_law`). A weighted stack can never do this: `sum_{k <= N/b} w(kb)` at `b = 1` dominates every other node for any weight, so no weight reproduces the lean. **Refuted**, the lean as an element of the Dirichlet group.

The sequence `d*` is not new and its Dirichlet series says where the lean still sits. It is [A019554](https://oeis.org/A019554), the smallest number whose square is divisible by `n`, multiplicative with `a(p^e) = p^ceil(e/2)`, reading `1, 2, 3, 2, 5, 6, 7, 4, 3, 10, 11, 6, 13, 14, 15, 4, 17, 6, 19, 10, 21, 22, 23, 12, 5, 26, 9, 14, 29, 30` at `d = 1..30`, with `d* = d/A000188(d)` checked to `d = 1000` with 0 breaches. Its series is `sum_n 1/(a(n) n^s) = zeta(2s+1) zeta(s+1)/zeta(2s+2)`, and the study recovers it from the origin densities: partial sums `1.826509, 1.826861, 1.826902` at cuts `10^4, 10^5, 10^6` against `zeta(3) zeta(2)/zeta(4) = 1.826907` at `s = 1`, and `1.225197` at all three cuts against `zeta(5) zeta(3)/zeta(6) = 1.225197` at `s = 2`. **Verified** (`lab/py/leaning-stack`, `origin_law`). The lean leaves the group of weights and the census of what it lights is still a ratio of zetas, which is the pattern this page keeps finding.

Gauss sums enter the stack here, for the first time and not decoratively. Orthogonality turns the solution count into a Fourier sum,

```
R = (1/m) sum_{h mod m} sum_{n mod m} e(h Q(n)/m),   Q(n) = b c n^2 - a d n,   m = b d
```

whose inner sum is a quadratic Gauss sum with a linear term. **Proved**, and **Verified** numerically, the Fourier count returning `1, 1, 8, 24, 16` at `(a/b, delta) = (1/1, 1/5), (1/2, 1/3), (1/4, 1/4), (1/6, 1/6), (5/12, 3/8)` and matching the class count times `m/lcm(b, d*)` in every case (`lab/py/leaning-stack`, `gauss_sums`). The cleanest sighting is upstream of the count, in the phases themselves: at a prime drift denominator the phase `theta_n = n^2 c/p` takes only `(p+1)/2` values, and the multiplicity of `j/p` is `1 + (j c^-1 / p)` at `j != 0` and `1` at `j = 0` - a Legendre symbol, exactly. **Proved**, and **Verified** at `p = 5, 7, 11, 13` with `c` a residue and a non-residue, giving `3, 4, 6, 7` distinct phases and 0 census breaches. The residue character of the drift twists the Gauss sum and cancels out of the count: `S(c, p) = sum_n e(c n^2/p) = (c/p) S(1, p)` holds coefficient by coefficient on the centred multiplicity vectors, multiplicity minus one, which is the Legendre identity `(j c^-1/p) = (c/p)(j/p)`, with 0 breaches at all eight cases; the raw multiplicity vectors are not proportional, since one of them carries a zero where the other carries its largest entry, and the two sums agree only through `sum_j e(j/p) = 0`. Numerically `S(c,p)` reads `2.236068, -2.236068, 2.645751i, -2.645751i, 3.316625i, -3.316625i, 3.605551, -3.605551` against `(c/p) eps_p sqrt p`, while the count at `x = 0` stays `1` for every `c` because the Legendre symbol sums to zero over the nonzero `h`. **Proved** for the twist and the cancellation, **Verified** for the sign `eps_p`, which is `1` at `p = 1 mod 4` and `i` at `p = 3 mod 4` by Theorem 1.1 of Murty and Pathak, *Evaluation of the quadratic Gauss sum*, read at source.

The lean's whole coincidence structure is one condition. Layers `m` and `n` share a point exactly when some `x` satisfies both `m x - m^2 delta in Z` and `n x - n^2 delta in Z`; the difference of a lit point of one and a lit point of the other is `(j n - k m)/(m n) + delta (m - n)`, and `j n - k m` runs over `gcd(m, n) Z`, so **layers `m != n` share a lit point if and only if `lcm(m, n) (m - n) delta` is an integer. Proved**, and **Verified** against literal intersection of the two layers' lit sets over `m < n <= 12` against every reduced drift with `d <= 16`, 5280 pairs, 1474 sharing, 0 criterion failures; the weaker readings fail, `n (m - n) delta` being rational at every one of the 3806 non-sharing pairs and `m n (m - n) delta` being an integer at 64 of them, first at `(m, n, delta) = (2, 4, 1/16)` (`lab/py/leaning-stack`, `sharing_law`).

At an irrational drift that condition never holds at `m != n`, so the lean does not thin the stack, it annihilates it. **Every pair of layers is disjoint, so the brightness of the leaning stack at irrational drift is at most 1 at every point and every `N`. Proved**, in three lines, and with no Niven and no rotation: the dead-spin theorem kills coincidences by turning a layer, this kills them by sliding one. **Verified** by counting the lit points of layers `1..25`, which are 325 distinct points out of 325 drawn at both `delta = sqrt 2 - 1` and `phi - 1`, and by the closest approach over all pairs to `N = 120`, `9.202e-09` at `(72, 77)` and `7.488e-09` at `(56, 92)` (`lab/py/leaning-stack`, `adversarial`).

What is left is the near-coincidence, and that is Weyl's. The phases `{n^2 delta}` are equidistributed for irrational `delta` (H. Weyl, *Uber die Gleichverteilung von Zahlen mod. Eins*, Mathematische Annalen 77, 313-352, full scan on [EuDML](https://eudml.org/doc/158730)), so the layers' offsets fill the circle and the stack has no node but many misses. The star discrepancy of `{n^2 delta}` reads `0.019450` and `0.006421` at `N = 1000, 10000` for `sqrt 2 - 1` and `0.022253` and `0.009391` for `phi - 1`, against `1/sqrt N = 0.031623` and `0.010000`, ratios `0.6151, 0.6421, 0.7037, 0.9391`. **Verified**, four points, no fit and no exponent claimed (`lab/py/leaning-stack`, `irrational_lean`).

The picture is `leaning-stack.png` under `lab/py/leaning-stack`, the leaning stack turned into a field by taking the product of the `x` and `y` line stacks as the Farey field does, `N = 30`, `delta = 1/5` on the left and `delta = sqrt 2 - 1` on the right. The left panel keeps a blank cross grid on the lines at multiples of `1/5` that no layer reaches; the right panel has no blank structure at all. The rational drift keeps a periodic skeleton and the irrational one destroys it, which is the two theorems above seen at once; nothing is claimed from the raster.

The two-dimensional lean needs no separate theorem. A carpet layer factors as `C_n(u,v) = chi_n(u) chi_n(v)`, and translating the layer translates each factor, so the leaning carpet stack is the leaning line stack applied per coordinate for a product design. **Proved**, and not built here.

## What a breakthrough would look like

Brightness is closed form and rank is not, and every stack built by stacking, selecting or reweighting lives inside one abelian group whose series is a ratio of zetas. A genuine result therefore has to leave that group, and the exits are few. They rank by how far they would move mathematics, which is the reverse of how much traction they offer.

**A rank statement not routed through Mertens.** The target is the Franel functional itself, `sum_j delta_j^2` over `F_Q`, bounded without importing `mu`. It is the largest possible result and it has no traction, for a reason that is a theorem rather than a mood: Franel's 1924 argument *is* the reduction of the Farey discrepancy to Mertens-type sums, so a bound on the functional is a bound on `M(x)`, and the rank is the reduction rather than a coincidence to be routed around. Asking the picture where its nodes sit re-imports `mu` at the first step, through `A(x, Q) = sum_{d <= Q} mu(d) sum_{e <= Q/d} floor(x e)`, while brightness keeps its `mu`-free `floor(Q/b)`. The smallest checkable statement here is not a bound but an effective form of the reduction, Franel's identity with explicit constants in exact rational arithmetic at finite `Q`. Nothing on this page is a route to it. **Conjecture.**

**The operations outside the Dirichlet algebra.** There are three, one closed, one written and one new. The first is the pointwise product, whose arithmetic is gcd rather than Dirichlet: multiplying layers instead of adding them makes the layer Gram matrix `gcd(m,n)^2/(mn)`, a gcd matrix in Smith's sense, and Smith's 1875 determinant evaluates such a matrix as `prod_{k <= n} (f * mu)(k)` - the Dirichlet inverse as a product of local values instead of a partial sum, which is exactly why it is closed form where Mertens is not. Both halves of it are now settled, the determinant above and the spectrum by the symbol: the layers are a dilation system, the Gram splits into copies of the odd Gram, the sharp frame bounds are the range of `S` on `Re s > 0`, and the growth of the finite spectrum is capped at the order `(log log k)^2` that the gcd-matrix bound gives. What is left is not the order but the constant on the odd scales, which is a Gal-sum question about a fixed set that is not one of the extremal smooth ones, and it is the Conjecture the dilation section leaves standing. The spectrum is no longer the open object this page named. Multiplying is not the only non-linear blend either: the parity fold is a third non-linear operation on the layers, its exact fill a signed sum of squared subset masses, and the law behind those masses is a covering question about odd intervals, open.

The second is rotation, where a Dedekind zeta enters three times over, through the coincidence count `zeta_{Q(i)}(s)/zeta(2s)`, through the Gaussian Farey node constant and through the discrepancy identity, and where the statement to write is now written. The identity is written; the rate is the Riemann hypothesis for the field, exactly as hard. That is the whole of the exit: `m^2 D_2(N)^2 = 4 zeta_K(2) F(N)` holds as an exact rational identity, and `D_2(N) = O(N^{-3/2+eps})` is equivalent to the Riemann hypothesis for `zeta(s) L(s, chi_-4)`, so the door leads to the same wall one field up rather than around it. The Eisenstein twin of the address is built beside it, `chi_-4` replaced by `chi_-3`, the Gauss circle count by the hexagonal one and `zeta_K(2) = zeta(2) L(2, chi_-3)` in a node constant that is now a theorem; it had to be built on `Z[omega]` from the start, since the base-2 slice stack carries no `L(2, chi_-3)`, and [the hexagon page](hexagon.md) proves that absence from the Walsh quasipolynomial of the cut ink rather than reporting it from a search, the L-value belonging to base 3 by [what base 3 hides](bases.md). **Refuted**, the slice stack as an Eisenstein door. What is not written one field up is the Eisenstein discrepancy identity itself, which is the same transcription once more with the hexagonal ideal lattice in place of the square one.

The third is the lean, and it is the one this page adds: translate layer `n` rather than weight it. It leaves the group with a theorem rather than with a hope, since the quadratic lean's lit layers are a union of `2^w` residue classes modulo `lcm(b, d*)`, its lit set reads the numerator where every other family on this tree reads the denominator alone, its brightest node moves off the origin, and at irrational drift its brightness is at most 1 everywhere. Those are the section above's, and what they open is the leaning Farey question: the lit set at rational drift is numerator-restricted and periodic, so its rank functional is an object with no Mertens reduction imported yet, which is the one place on this page where the rank door is not already closed by Franel's own argument.

**The design-restricted stack.** Restrict the scales to a digit-restricted set and the object stops being the classical one, so nothing is inherited and Franel-Landau does not transfer. That zeta is not `zeta`: it has zeros where the Euler product forbids them, and each is a proof that the design's own Mobius fails every square-root-shaped bound, which is [the zeta page](zeta.md)'s territory and is not restated here. The smallest checkable statement is the node set: which fractions the digit-restricted stack lights, and whether its novelty count is a restricted totient with a closed form. **Conjecture.** This is the one exit where a negative result is already banked, which makes it safe ground rather than a door.

The pattern in the stacks is the Dirichlet series, and saying so answers the question completely. Every visible law of the plain stack is a coefficient of `zeta`, of `zeta^2` or of a gcd sum: brightness `floor(N/b)`, novelty `phi(n)`, [visible density](/wiki/visible-lattice-points/) `6/pi^2`, the correlation `gcd(m,n)^2/(mn)`, the Smith determinant. Every invisible one is a coefficient of `1/zeta`: the Mertens node, the Redheffer determinant, the Franel rank. The stack renders `zeta` exactly and `1/zeta` only as a picture, and the mechanism is the symbol on the line `Re s = 1`: the layers' Dirichlet series is `zeta(1 + s)` up to an Euler factor, a weight multiplies that symbol by its own series at the same `s`, and no reweighting moves the line. **Proved** for the forward direction, which is the group law; the wall is [the Farey page](farey.md)'s, restated here and not re-proved.

## The generators

> Stacking, selecting and reweighting are one abelian group, and the group already knows everything it will ever say; the picture changes only when the layers are multiplied, turned or leaned.

Eleven studies print every number above and nothing here is printed twice. `lab/py/stack-algebra` runs `uv run python research/lab/py/stack-algebra/stack_algebra.py` and carries the convolution theorem, the selections and the primes-only fade. `lab/py/spun-stack` runs `uv run python research/lab/py/spun-stack/spun_stack.py` and carries the dead-spin theorem, the fixed-increment eyes, the Gaussian Farey brightness and the complex bases. `lab/py/gaussian-franel` runs `uv run python research/lab/py/gaussian-franel/gaussian_franel.py` and carries Kluyver's identity in `Z[i]`, Franel's identity one field up, the two-sided equivalence and both meters, the Gaussian one and the classical control. `lab/py/eisenstein-stack` runs `uv run python research/lab/py/eisenstein-stack/eisenstein_stack.py` and carries the Eisenstein address, the hexagonal rational rotations and the coincidence series, writing `eisenstein-stack.png` beside itself. `lab/py/totient-constant` runs `uv run python research/lab/py/totient-constant/totient_constant.py` on the standard library alone and carries the node-count constant of both spun stacks, the recount of every published node count and the Farey unit convention. `lab/py/stack-levels` runs `uv run python research/lab/py/stack-levels/stack_levels.py` and carries the product law, the base-3 kernels and the Gram determinant. `lab/py/stack-dilations` runs `uv run python research/lab/py/stack-dilations/stack_dilations.py` and carries the symbol, the Gram two ways, the `v_2` blocks and the eigenvalue window. `lab/py/spin-render` runs `uv run python research/lab/py/spin-render/spin_render.py` and carries the centre theorem, the unspun maximum and the fade table, writing its four renders and their contact sheet beside itself. `lab/py/node-stack` runs `uv run python research/lab/py/node-stack/node_stack.py` and carries both node stacks, their closed forms and the restricted Farey family, writing its own four renders and a sheet. `lab/py/leaning-stack` runs `uv run python research/lab/py/leaning-stack/leaning_stack.py` and carries the linear and quadratic leans, the class and period laws, the Gauss sums and the irrational drift, writing `leaning-stack.png` beside itself. `lab/py/parity-fill` runs `uv run python research/lab/py/parity-fill/parity_fill.py` and carries the subset expansion of the parity fill, its exact values to `N = 21`, the independent comparison and the spun sweep. All eleven run from the repository root in a few seconds each, and each README names what its study computes, how to run it and the domain every number is read on.