stack.md

--- 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 says what the plain stack lights - the Farey fractions, 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, 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 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 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, 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.

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 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. 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 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 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 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.

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 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, 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, 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 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 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. 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, 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.

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'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 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 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, 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 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 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 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 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 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, 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, 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, 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), 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 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. 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'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 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'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.