---
title: Crop
lead: The circle on a design: the corner disc count, its log-periodic main term, and the crossing shell read as a rooted tree whose transfer operator is derived from the geometry.
figure: research-crop
slug: crop
---

A crop lays an exact shape - a ball, a box, a diamond, any rational polytope - over a design's grid and classifies every cell as In, Cut or Out, in exact integer arithmetic with no floats: ball tests clear denominators and compare squared distances, half-space tests evaluate the linear form at two extreme corners. Cropping then zeroes the filled cells the shape rejects, keeping Cut cells on request, and `Shape::Anti` swaps In with Out while Cut stays. This page is the census of what a circle and a diamond keep of the carpet, what a sphere and an octahedron keep of the sponge, and the one open lane the Cut column points at: the dimension of a curved slice.

Every claim carries a tag. **Proved** means a proof is given or restated here; **Verified** means recomputed from scratch by a crate test or a lab study; **Conjecture** means neither. The generators are `mrlymath::shape` in `../crates` - `classify`, `regions`, `crop`, `refine`, `census` - of which `classify`, `crop`, `refine` and `census` are each pinned by tests named for their claims, including an independent `2^dim`-corner oracle, while `regions` carries no test of its own name and is exercised only through the others. `lab/rs/crop-counts` is the one pass that prints every number below. The [crop demo](../../site/demos/crop/) draws a named shape over a design and counts the in, cut and out regions before anything is rendered.

## Two identities, by construction

**Partition (Proved).** Every cell is exactly one of Out, Cut, In - `classify` returns one region, `census` tallies cells and filled cells per region, and the three filled tallies sum to the design's fill. `crop(types, shape, true)` keeps the filled cells of In and Cut, `crop(types, shape, false)` keeps In alone, so the two crops bracket the boundary from both sides.

**Anti-crop complement (Proved).** `Shape::Anti` flips In and Out and fixes Cut, so `crop(types, Anti(shape), false)` keeps exactly the filled Out cells and `crop(types, Anti(shape), true)` keeps Out and Cut: the crop and the anti-crop with the complementary cut rule partition the filled set exactly, whichever side gets the boundary. Both identities are read off the definition of `classify` and asserted, both ways, on all 118 configurations `lab/rs/crop-counts` prints, and independently by the `mrlymath::shape` partition tests. (Proved; Verified.)

## The inscribed ball and diamond, level by level

Code 7 at `dim = 2` is the carpet, code 23 at `dim = 3` the sponge; the shape is centered at `(1/2, ..., 1/2)` with the inscribed radius `1/2`, so the ball touches the four or six face midpoints and the diamond is the inscribed cross-polytope. `filled_in` and `filled_cut` are the filled cells fully inside and crossing the boundary; `exposed_after` counts the exposed unit faces of the keep-cut crop, a face being exposed when its neighbour is empty or off the grid. Level 0 is the single filled cell. (Verified, `lab/rs/crop-counts`, every row.)

Carpet, `level = 0..5`, side `3^level`:

| `level` | ball in | ball cut | ball exposed | diamond in | diamond cut | diamond exposed |
|---:|---:|---:|---:|---:|---:|---:|
| 0 | 0 | 1 | 4 | 0 | 1 | 4 |
| 1 | 0 | 8 | 16 | 0 | 8 | 16 |
| 2 | 32 | 28 | 80 | 12 | 32 | 64 |
| 3 | 332 | 76 | 400 | 168 | 104 | 304 |
| 4 | 2908 | 204 | 2688 | 1596 | 320 | 1792 |
| 5 | 23900 | 580 | 20160 | 13560 | 968 | 12400 |

Sponge, `level = 0..4`, side `3^level`:

| `level` | ball in | ball cut | ball exposed | diamond in | diamond cut | diamond exposed |
|---:|---:|---:|---:|---:|---:|---:|
| 0 | 0 | 1 | 6 | 0 | 1 | 6 |
| 1 | 0 | 20 | 72 | 0 | 20 | 72 |
| 2 | 44 | 216 | 792 | 0 | 116 | 504 |
| 3 | 2320 | 1224 | 8400 | 132 | 476 | 2016 |
| 4 | 54800 | 7968 | 134448 | 4320 | 2612 | 18456 |

Two structural readings, both exact. The inscribed sphere never enters the sponge at level 1: `census` reads cells `[0, 26, 1]` - the one In cell is the empty centre, all 20 filled cells are Cut - so the keep-cut crop keeps everything and the strict crop keeps nothing (Verified, `mrlymath::shape` test and the `level = 1` row). And the inscribed octahedron holds no filled sponge cell fully inside through level 2: its deep interior is exactly where the sponge is empty. (Verified.)

## The radius sweep

At carpet level 4 (side 81) and sponge level 3 (side 27), radii `r = 1/24 .. 24/24`. The digest; every number is a printed line of `lab/rs/crop-counts`. (Verified.)

- Dead zones: the carpet crop is empty - In and Cut both zero - for `r < 1/6` under ball and diamond alike, the central hole's inradius in both norms, and the sponge diamond crop for `r < 1/3`; both radii are exact. The sponge ball's exact contact radius is `sqrt(2)/6 = 0.2357`, off the sweep grid: the level-3 cell `[13/27, 14/27] x [8/27, 9/27] x [8/27, 9/27]` is filled - digit triples `(1,0,0), (1,2,2), (1,2,2)`, each with at most one middle digit - and its nearest point to the centre is `(1/2, 1/3, 1/3)` at distance `sqrt(2)/6`, so the sweep reads empty at `r = 5/24 = 0.208` and first cuts at `r = 6/24`, the first grid radius past contact. (Proved by the witness cell; the sweep rows Verified.)
- First contact on the sweep grid: carpet ball at `r = 1/6` reads `in = 0, cut = 4`; sponge ball at `r = 6/24` reads `in = 0, cut = 60`; sponge diamond at `r = 1/3` reads `in = 0, cut = 12`.
- At the inscribed `r = 1/2` the sweep reproduces the level tables: carpet ball `2908 / 204`, carpet diamond `1596 / 320`, sponge ball `2320 / 1224`, sponge diamond `132 / 476`.
- Saturation: the carpet ball crop holds all `4096` filled cells with zero Cut from `r = 17/24`, the first sweep radius past the circumradius `sqrt(2)/2 = 0.7071`; the sponge ball from `r = 7/8`, past `sqrt(3)/2 = 0.8660`. The sponge diamond never saturates in the sweep - at `r = 1` it reads `in = 5356, cut = 1332` of 8000, since the cube's corners sit at `L1` distance `3/2`.
- The Cut column is not monotone in `r`: the carpet ball's runs `204, 184, 204, 144` across `r = 5/12 .. 13/24`. How this count fluctuates along `log r` is the [dimensions](dimensions.md) question below. (Verified for the values; nothing is claimed about the fluctuation.)

## The circle count

The sweep above fixes the level and moves the radius across the unit box; this section fixes the radius in cells and lets it run, which is the Gauss circle question asked of a carpet. Cells are indexed `x` in `[0, 3^level)^dim` and a cell counts when its centre, `x + 1/2` on every axis, lies in the closed Euclidean ball `|y| <= r`; two centres are run, the corner ball about the lattice corner `0` and the centre ball about the grid centre `3^level/2`. `lab/rs/circle-crop` prints every number below across `22028` asserted rows, `6802` of them carrying a live error band, and checks its integer sweep against `mrlymath::shape::census` at `41` radii, the filled and the whole-grid columns alike; the whole-grid count itself stays within `0.310472 r` of the quarter disc's area for `r <= 242` and within `0.476401 r^2` of the octant's volume for `r <= 26`. (Verified.)

**The count is one sequence, not one per level (Proved; Verified).** Let `S` be the design's filled residue corners - `{0,1,2}^2` without the middle `(1,1)` for the carpet, so `m = 8`, and the `20` vectors with at most one middle coordinate for the sponge - and let `F` be the points of `Z_{>=0}^dim` whose every base-3 digit vector lies in `S`. The zero digit vector lies in `S` in both designs, so `F` cut to `[0, 3^level)^dim` is exactly the design at level `level`, and every cell the corner ball of radius `r <= 3^level - 1` counts sits inside that box. The corner count `N(r) = #{x in F : |x + 1/2| <= r}` therefore does not depend on `level`: the generator asserts each level against the one below over the whole range the lower level reaches, count, In and Cut columns alike - on the carpet `level = 6` against `level = 5` on `r = 1..242`, `level = 7` against `level = 6` on `r = 1..728`, `level = 8` against `level = 7` on `r = 1..2186` and `level = 9` against `level = 8` on `r = 1..6560`, on the sponge `level = 4` against `level = 3` on `r = 1..26`, `level = 5` against `level = 4` on `r = 1..80` and `level = 6` against `level = 5` on `r = 1..242`. Chaining those checks, all five carpet levels agree on `r = 1..242` and all four sponge levels on `r = 1..26`, which are the ranges every level of a design reaches; the deepest pair is checked over `r = 1..6560` and `r = 1..242`.

**The main term is a periodic multiplier, not a constant (Proved).** Write `mu` for the design's natural measure - the self-similar probability measure with equal weights `1/m` on the maps `x -> (x + s)/3`, `s in S`, normalised by `mu([0,1]^dim) = 1` and supported on the limit set - and `dimension = log_3 m`, so `dimension = 1.8927892607` for the carpet and `2.7268330279` for the sponge. For `s <= 1` the ball `B_(s/3)` lies in the corner sub-box `[0, 1/3]^dim`, which carries the `s = 0` piece and meets the other pieces only in faces, and `mu` gives a face measure zero; on that piece `mu` is `1/m` times the `1/3`-scaled copy of itself and `x -> x/3` pulls `B_(s/3)` back to `B_s`, so `mu(B_(s/3)) = mu(B_s)/m` and `M(r) = m^k mu(B_(r/3^k))` is one number for every `k` with `3^k >= r`. Writing `k = ceil(log_3 r)` gives `M(r) = r^dimension G(log_3 r)` with `G` positive and `1`-periodic: the count's main term carries the lattice oscillation the [dimensions](dimensions.md) page predicts, and no constant times `r^dimension` can replace it.

**The circle theorem (Proved).** For every `r >= 1`, `|N(r) - M(r)| <= C(r)`, where `C(r)` is the number of filled unit cells the sphere `|y| = r` crosses, which is exactly the Cut column of the corner ball. At scale `3^-k` a filled cell fully inside the ball contributes `1` to `N` and `m^k mu(cell) = 1` to `M`, a cell fully outside contributes `0` to both, and a crossing cell contributes `1` or `0` to `N` and something in `[0, 1]` to `M`, so the two counts differ only over the crossing cells and by at most one each. Since the crossing cells of the whole grid number `O(r^(dim-1))` in every `dim` - a cell meeting the sphere has diameter `sqrt(dim)`, so it lies in the shell `| |y| - r | <= sqrt(dim)`, and unit cells have disjoint interiors, so their number is at most that shell's volume in the positive orthant, `2^(-dim) omega_dim ((r + sqrt(dim))^dim - max(r - sqrt(dim), 0)^dim)` with `omega_dim = vol(B_1)`, which is `pi sqrt(2) r` at `dim = 2` and `pi sqrt(3) (r^2 + 1) < 5.4414 (r^2 + 1)` at `dim = 3` once `r >= sqrt(dim)`, and less below; the telescoping column count sharpens the plane, where the crossing cells of a column form an interval of length at most `sqrt(r^2 - i^2) - sqrt(r^2 - (i+1)^2) + 2` whose first part telescopes, and the generator asserts `C_full(r) <= 3r + 5` at every `r <= 19682` in `dim = 2` and `C_full(r) <= pi sqrt(3) (r^2 + 1)` at every `r <= 728` in `dim = 3` - the theorem reads

- `N(r) = r^dimension G(log_3 r) + O(r^(dim-1))`, an unconditional saving of `r^0.8927892607` on the carpet and `r^0.7268330279` on the sponge over the count itself.

**The defect is an exact integer (Proved).** `M(3r) = m M(r)` by periodicity, so with `E(r) = N(r) - M(r)` and the defect `delta(r) = N(3r) - m N(r)` one gets `E(3r) = m E(r) + delta(r)`, and since `|E| <= C = O(r^(dim-1)) = o(r^dimension)` the recursion inverts: `E(r) = - sum_(j >= 0) m^(-j-1) delta(3^j r)`. The defect is an exact integer, printed at every radius; the error is printed as `N(r) - N(3^j r)/m^j` at the deepest `j` the grid allows, banded by `C(3^j r)/m^j`, which is the theorem applied at that radius. So `|E(3)|` lies in `[0.989655, 0.995193]`, `|E(9)|` in `[0.038459, 0.082757]`, `|E(27)|` in `[0.337951, 0.692322]`, `|E(81)|` in `[2.703613, 5.538575]` on the carpet, and the exponent of `|delta|` bounds the exponent of `|E|`.

**The measured exponents (Verified, with their windows).** The running maximum's growth over one triadic step, read at every radius in the range, gives for the crossing count `C` on the carpet `min 0.871371`, `mean 0.898741`, `max 0.969141`, log-log fit `0.870673` and endpoints `0.898794` over `r = 27..19682`, and on the sponge `1.704391`, `1.733764`, `1.757218`, `1.654302`, `1.720961` over `r = 27..728`. Both bands contain `dimension - 1`, which is `0.8927892607` and `1.7268330279`: the circle's trace on the carpet and the sphere's on the sponge measure about one less than the design's own dimension, over six and three triadic windows. For the defect the same estimators give `0.220478`, `0.527490`, `1.015046`, `0.544749`, `0.648815` over `r = 27..6560` on the carpet and `0.645285`, `1.056561`, `1.730726`, `1.001255`, `1.273634` over `r = 27..242` on the sponge: the three central estimators land in `[0.527490, 0.648815]` for the carpet and `[1.001255, 1.273634]` for the sponge, while the per-radius readings run over `[0.220478, 1.015046]` and `[0.645285, 1.730726]`, and the range decides nothing sharper. All six central estimates sit above half the crossing exponent, `0.4494` and `0.8669`, so square-root cancellation over the crossing cells - the Hardy-shaped guess - is not what these radii show, and all six sit below the crossing exponent itself, so the theorem's bound is not attained either. (**Conjecture**, either way.)

**The window mean of the crossing count (Proved).** The crossing count is a difference of two corner counts. With `A(r) = #{x in F : |x| <= r}` and `B(r) = #{x in F : |x + 1| <= r}`, a filled cell crosses the sphere exactly when `|x| <= r < |x + 1|`, so `C(r) = A(r) - B(r)` at every integer `r`, where `B` is the In column and `A` the In plus Cut column the generator prints. On the nonnegative orthant a cell's two corner radii are never closer than one apart: `|x + 1|^2 - |x|^2 = 2 sum_i x_i + dim` while `|x + 1| + |x| <= 2 |x| + sqrt(dim) <= 2 sum_i x_i + sqrt(dim)`, since `|x| <= sum_i x_i` there and `sqrt(dim) <= dim`, so `1 <= |x + 1| - |x| <= sqrt(dim)`, the upper bound by the triangle inequality. The half-open interval `[|x|, |x + 1|)` therefore holds at least one integer and at most `floor(sqrt(dim)) + 1`, which is `2` for both designs. Summing `C` over a triadic window counts the pairs `(x, r)` with `r` in `[|x|, |x + 1|) cap [R, 3R)`, and the two multiplicity bounds give the exact sandwich `B(3R) - A(R) <= W(R) <= 2 (A(3R) - B(R))` for `W(R) = sum_(r = R)^(3R - 1) C(r)`. The bracket lemma `B(r) <= M(r) <= A(r)` is the circle theorem's own cell argument, not a consequence of `In <= N <= In + Cut` with `|N - M| <= C`: a filled cell fully inside the ball contributes `1` to `M`, one fully outside `0`, a crossing cell something in `[0, 1]`, so `M` sits between the In column and the In plus Cut column at every radius. Feeding that in, with `A = B + C` and `M(3R) = m M(R)`, turns the sandwich into `(m - 1) M(R) - C(3R) - C(R) <= W(R) <= 2 ((m - 1) M(R) + C(3R) + C(R))`, and since `C = O(r^(dim-1))` with `dimension > dim - 1`, dividing by the window's `2R` radii gives the theorem: the mean of `C` over `r in [R, 3R)` lies between `((m - 1)/2) G_min R^(dimension-1)` and `(m - 1) G_max R^(dimension-1)` up to `O(R^(dim-2))`, with `G_min >= mu(B_1)/m` and `G_max <= m mu(B_1)` the positive bounds of the periodic multiplier. Averaged over a triadic window the crossing exponent is `dimension - 1` exactly, with `m - 1 = 7` on the carpet and `19` on the sponge; only the pointwise statement is open.

**The constants, at every window (Verified).** The generator prints a `mean` line for each triadic window with `3R <= 3^level - 1`, eight on the carpet and five on the sponge, and asserts at every one both the exact sandwich and its closed form, the latter with `M(R)` bracketed by its own In and In plus Cut columns at the deepest depth the grid reaches. At `r = 2187..6560` the carpet's window sum is `13758140`, the sandwich reads `[11019880, 22055720]`, the closed form `[11013332.750000, 22068746.000000]` and the mean `3145.436671`; the window below has mean `1180.226337`, so successive window means multiply by `2.665113` against `m/3 = 8/3`, which is `3^(dimension-1)`. Every printed bracket rounds outward at `1e-6`. The multiplicity `kappa = W(R) / ((m - 1) M(R))` sits in `[1, 2]` only asymptotically: the exact statement carries the slack `(C(3R) + C(R)) / ((m - 1) M(R))` on both sides, and at `r = 1..2` on the carpet that slack drives `form_low` to `-4.744629`, below zero. Measured, `kappa` brackets to `[1.247746, 1.248322]` at `r = 2187..6560` and descends monotonically from `[1.331356, 1.331971]` at `r = 1..2`; on the sponge it climbs from `[1.084118, 1.105871]` to `[1.417534, 1.445977]` at `r = 81..242` and is still climbing at the last window it reaches, so only the carpet's sequence has settled. On the carpet the sum sits near the theorem's lower constant and nowhere near its upper one: the factor two in the sandwich is the price of counting integers in `[|x|, |x + 1|)` instead of measuring that interval.

**The pointwise question is one statement about digits (Proved reduction; Verified factor).** Let `C_full(r)` be the whole grid's crossing count. It is `Theta(r^(dim-1))`: the shell bound above gives the upper half, and for the lower half fix a lattice point `p >= 0` with `|p| <= r` in the first `dim - 1` coordinates, put `j = floor(sqrt(r^2 - |p|^2))` and take the cell `x = (p, j)`: then `|x|^2 = |p|^2 + j^2 <= r^2` and `|x + 1|^2 >= |p|^2 + (j + 1)^2 > r^2`, so it crosses, distinct `p` give distinct cells, and the orthant ball holding the cube of side `r / sqrt(dim - 1)` gives `C_full(r) >= (r / sqrt(dim - 1))^(dim-1)`; the generator asserts that bound at every radius, and the measured `C_full(r) / r^(dim-1)` bands to `[2.000152, 2.037038]` on the carpet over `r = 27..6560` and to `[2.298611, 2.380000]` on the sponge over `r = 9..242`. Let `level` be the least level with `r < 3^level`, so `3^(level-1) <= r < 3^level`, and put `Phi(r) = C(r) (3^dim/m)^level / C_full(r)`: the filled share of the crossing cells divided by `(m/3^dim)^level`, the share a cell at level `level` carries at random. Since `(m/3^dim)^level = 3^(level(dimension - dim))`, the pointwise `C(r) = Theta(r^(dimension-1))` holds if and only if `Phi` is bounded above and below by positive constants, so the pointwise crossing exponent is exactly the statement that the sphere's crossing cells carry the design's digits at their ambient density up to a bounded factor, and nothing further about the circle enters. The generator prints a `factor` line per window with the minimum, mean and maximum of `Phi`, each mean asserted against a `ground` built from the window theorem's lower constant and the proved cap on `C_full`, which is `3r + 5` at `dim = 2` and `pi sqrt(3) (r^2 + 1)` at `dim = 3`, so the check does not draw its expectation from the sweep it checks. On the carpet over eight windows, `r = 1..6560`, the mean reads `1.012500, 0.981078, 0.959982, 0.954469, 0.948442, 0.944582, 0.943419, 0.942790`, the minimum stays inside `[0.588115, 0.900000]` and the maximum inside `[1.125000, 1.518945]`; on the sponge over five windows, `r = 1..242`, the mean reads `1.080000, 1.042535, 0.980332, 0.968704, 0.965114`, the minimum inside `[0.602555, 0.810000]` and the maximum inside `[1.350000, 1.673315]`. Both ends widen, and the widening decelerates: the carpet's maximum rises at all seven steps by `0.140625, 0.090402, 0.074920, 0.033718, 0.033360, 0.020111, 0.000808` and its minimum falls at six of the seven, the sponge's maximum rises at all four by `0.176959, 0.086036, 0.054979, 0.005341`. The increments shrink by an order over the range, so the reading is a factor whose spread is settling rather than one growing with `r`, and the pointwise exponent `dimension - 1` survives the test that would refute it without being confirmed by it. (**Conjecture** past the measured range, in both directions.)

**The crossing shell of the plane is exactly `2r + 1` cells (Proved).** At `dim = 2` the whole grid's crossing count is not merely `Theta(r)`, it is an identity: `C_full(r) = 2r + 1` at every integer `r >= 1`. Fix a column `x_1 = i` with `0 <= i <= r`. The cell `(i, x_2)` crosses when `i^2 + x_2^2 <= r^2 < (i+1)^2 + (x_2+1)^2`, so `x_2` runs over `[lo_i, hi_i]` with `hi_i = floor(sqrt(r^2 - i^2))` and `lo_i` the least integer with `(x_2 + 1)^2 > r^2 - (i+1)^2`, which is `floor(sqrt(r^2 - (i+1)^2)) = hi_(i+1)` whenever `(i+1)^2 <= r^2` and `0` at `i = r`, which is what setting `hi_(r+1) := 0` records, since `r^2 - (r+1)^2 < 0` leaves the root undefined there. The column counts therefore telescope, `C_full(r) = sum_(i=0)^r (hi_i - hi_(i+1) + 1) = hi_0 - hi_(r+1) + (r + 1) = 2r + 1`, using `hi_0 = r`. The same computation at a real radius `R` gives `2 floor(R) + 1`, and if `x` crosses at radius `r` then its level-`j` box `X = floor(x/3^j)` satisfies `|X| <= r/3^j < |X + 1|`, since `3^j X <= x` and `x + 1 <= 3^j (X + 1)` coordinatewise, so the level-`j` boxes carrying a crossing cell number at most `2 floor(r/3^j) + 1`; clipping the same telescoping to one box gives at most `2 * 3^j` crossing cells inside it. The generator asserts `C_full(r) = 2r + 1` at every radius of every carpet level, out to `r = 19682` at `level = 9`. The identity sharpens the proved cap `C_full(r) <= 3r + 5`, replaces the measured band `[2.000152, 2.037038]` for `C_full(r)/r` - which is exactly the range of `(2r + 1)/r` over `r = 27..6560` - and makes the pointwise factor exact in its denominator, `Phi(r) = C(r) (9/8)^level / (2r + 1)`. In `dim = 3` the low corner of a column moves in two coordinates at once, nothing telescopes, and the sphere's band stays measured.

**The digits of the crossing shell (Proved cap; Verified census).** Write `p_j(r)` for the fraction of the `C_full(r)` crossing cells whose base-3 digit vector at position `j` is one the design omits - `(1,1)` on the carpet, one of the seven vectors with two or three middle coordinates on the sponge - so a crossing cell is filled exactly when no position carries an omitted vector and `C(r)/C_full(r)` is the survival of the crossing cells' digit vectors, against the null rate `1 - m/3^dim`, which is `1/9` and `7/27`. The pointwise question then splits into two exact factors, `ind(r) = prod_(j < level) (1 - p_j(r)) (3^dim/m)^level`, the independent model's survival times `(3^dim/m)^level`, and the dependence correction `Psi(r) = (C(r)/C_full(r)) / prod_(j < level) (1 - p_j(r))`, with `Phi(r) = ind(r) Psi(r)` by construction; since `log ind(r) = sum_(j < level) (log(1 - p_j(r)) - log(m/3^dim))`, `ind` bounded is exactly the statement that the average of `log(1 - p_j)` over the `level` positions equals `log(m/3^dim)` to `O(1/level)`; `ind` and `Psi` both bounded above and below is sufficient for the pointwise exponent, and is not necessary, since `Phi` stays bounded along any pairing of `ind -> 0` with `Psi -> infinity`. One cap is proved at `dim = 2`: a cell with the omitted vector at position `j` lies in the centre child of a level-`(j+1)` box, a level-`(j+1)` box has one centre child and carries a crossing cell only if it is one of the `2 floor(r/3^(j+1)) + 1` boxes counted above, and a level-`j` box holds at most `2 * 3^j` crossing cells, so `p_j(r) <= 2 * 3^j (2 floor(r/3^(j+1)) + 1) / (2r + 1) < 2/3 + 3^j/r`, asserted in exact integers at every radius and position of the eight windows, and every position with `3^j <= r/30` is capped at `0.7` uniformly in `r`. On its own that buys nothing, because the sharpest bound the marginals alone support is the Frechet-Hoeffding lower bound `C(r) >= C_full(r) (1 - sum_j p_j(r))`, attained when the omission events are disjoint, also asserted exactly, and the generator prints `sum_j p_j` with window mean `0.941002` and maximum `1.349974` at `level = 8` on the carpet and `1.321036` and `1.627693` at `level = 5` on the sponge: the union bound is already empty at the sizes that matter, and grows emptier like `level/9`. What the census reads instead is equidistribution everywhere except the top of the scale. On the carpet at `r = 2187..6560`, `level = 8`, the window means run `0.111086, 0.111086, 0.111068, 0.111063, 0.111141, 0.109478, 0.109295, 0.166786` from the finest position to the coarsest: five of the eight agree with `1/9` to four decimals, and the whole departure lives in the top three, a profile locked to `level - j` rather than to `r`, ending at `0.166786` where the digit is the arc's place in the level-1 grid. Every fine position, every `j` with `j + 4 <= level`, has window mean inside `[0.108363, 0.111141]` across the five of the eight carpet windows deep enough to have one, and `(p_j - 1/9) 3^k/3^j` on the window `r = 3^k..3^(k+1) - 1` stays inside `[-0.111806, 0.063806]` at every position of every window, which is the reading `p_j(r) = 1/9 + O(3^j/r)` in the window mean; per radius the band is wider and set by the shell's size, `[0.102466, 0.121271]` at the finest position and `[0.000000, 0.447092]` at the coarsest. The sponge reads the same shape against `7/27 = 0.2592592593`, window means `0.259211, 0.259237, 0.259663, 0.256864, 0.286061` at `r = 81..242`, fine positions inside `[0.259103, 0.259237]` and the scaled drift inside `[-0.108311, 0.026803]` over five windows, with one difference: the sponge's fine band lies wholly below `7/27` where the carpet's straddles `1/9`, a one-sided bias on the three readings its two deep-enough windows supply, too few to call. The pair dependence is bounded per pair: on the window's pooled counts the consecutive ratios `p_(j,j+1)/(p_j p_(j+1))`, where `p_(j,j')` is the fraction of crossing cells carrying an omitted digit vector at both positions, read `1.000165, 1.000219, 1.000521, 0.998543, 0.992613, 1.076698, 0.956158` on the carpet at `level = 8` and `0.999847, 1.000927, 1.003308, 0.954574` on the sponge at `level = 5`, the gap-two ratios `1.000298, 1.000022, 1.000203, 1.000221, 1.003261, 1.005671` and `0.999497, 0.999197, 0.997414`, and over every window the consecutive ratio stays in `[0.939130, 1.714286]` on the carpet - the high end is the two-position window `r = 3..8` - and in `[0.954573, 1.151415]` on the sponge, the gap-two ratio in `[0.988460, 1.126957]` and `[0.997413, 1.019127]`. So neighbouring positions are dependent by a bounded factor and the dependence falls off with the gap, the finite-range shape a transfer operator would give. What that does not settle is `Psi`: its window means read `1.000000, 1.010516, 1.009082, 1.006311, 1.007708, 1.006371, 1.005977, 1.005714` on the carpet, settling near `1.0057`, while its extremes widen with decelerating drift exactly as `Phi`'s do, `[0.793296, 1.374208]` at the deepest window against `[0.808810, 1.362428]` at the one below. Over all eight windows the generator prints the global brackets `[0.542697, 1.515753]` for `ind` and `[0.793296, 1.374208]` for `Psi`, the second being the deepest window's bracket and the global one at once, the first not: `ind`'s low end is read at `r = 243..728`, while its window means run `1.012500, 0.973637, 0.954993, 0.953180, 0.945805, 0.943289, 0.942499, 0.942104`. The pointwise conjecture therefore survives its sharpest test - the fine positions carry no drift, the drift is three positions deep, and pair dependence is bounded - and what is missing is a bound on `Psi`, which bounded pair ratios do not supply: a product over pairs bounds a survival probability only under a Markov property proved rather than measured. (**Proved** for the cap and for the emptiness of the union bound; **Verified** for every rate, ratio and factor printed; **Conjecture** that `Psi` is bounded, hence that `Phi` is; `ind` bounded is proved two claims below.)

**A bound on `ind` from a 1923 theorem (Proved).** The crossing shell of the plane is a monotone lattice path: within a column its rows are an interval, and column `x` and column `x + 1` share the row `floor(y(x+1))` for `y(x) = sqrt(r^2 - x^2)`, so consecutive cells are edge-adjacent while `x` never decreases and the row never increases. A monotone path meeting `w` columns and `h` rows has exactly `w + h - 1` cells, and an axis-aligned box clips a contiguous sub-path, so a level-`j` box `X` carries `leaves(X) = w(X) + h(X) - 1` crossing cells. The two marginals are exact and telescope: fine column `x` meets the box rows `[beta(x+1), beta(x)]` with `beta(x) = floor(y(x)/3^j)`, so `sum_(X in S_j) w(X) = sum_(X in S_j) h(X) = floor(r/3^j) + r + 1` and `sum_(X in S_j) leaves(X) = 2r + 1`, the shell's own size. Both the shell and the centre seat `X = (1,1) mod 3` are invariant under swapping the coordinates, and the swap carries `w` to `h`, so the seat class `Ctr_j` has equal marginals and `p_j(r) (2r + 1) = 2 sum_(X in Ctr_j) w(X) - |Ctr_j|` with no error term. That identity is why the leaf weighting is load-bearing rather than decorative. Counting the seat's cells directly asks a congruence in the fine row as well as the fine column, `3^(2j)` residue classes mod `3^(j+1)`, and beats the trivial bound only for `3^(4j) < r`; counting `w` asks a congruence in the fine column and one in the box row, `3^j` classes, and `3^j (3^(j+1))^(-2/3) r^(2/3)` is `3^(-2/3) r R^(-1/3)` at every level, `R = r/3^j`. With `floor((floor(v) + k)/n) = floor((v + k)/n)` both counts become sums of `floor` of one smooth arc over those classes, and `floor(z) = z - 1/2 - psi(z)` splits each into a main term and sawtooth sums.

**The bound, its constant and its reach (Proved; Verified).** The sawtooth sums are exactly the object [van der Corput, Zahlentheoretische Abschätzungen mit Anwendung auf Gitterpunktprobleme, Math. Z. 17 (1923) 250-259](https://doi.org/10.1007/BF01504346) caps in Satz 5: for `h` in `C^2[a, b]` with `h''` monotonic and nonzero, `|sum_(a < n <= b) psi(h(n))| <= 6 int_a^b |h''|^(1/3) + 175 max |h''|^(-1/2) + 2`, read at source in [Laugesen and Liu, Optimal stretching for lattice points and eigenvalues](https://arxiv.org/abs/1609.06172), Appendix A, Theorem 18, which cites Satz 5 and Kraetzel's corollary and sharpens the `+2` to `+1`; the `+2` is what is used here. A progression is an affine substitution, so `h(u) = (y(qu + c) - b)/q` has `h'' = q y''`. The arc is never used closed, since `y` is not `C^1` at `x = r`: the theorem is applied on `[a, b]` with `q b + c < r`, where `h''` is monotonic and nonzero, `min |h''| = q/r` sits at `x = 0` for every such `b`, and `int_0^(qb+c) |y''|^(1/3) dx <= int_0^r |y''|^(1/3) dx = (pi/2) r^(2/3)` converges, so both constants are uniform in `b` and no split at slope `1` is needed - one class costs `3 pi q^(-2/3) r^(2/3) + 175 q^(-1/2) r^(1/2) + 2`. What the subinterval leaves outside is peeled at two points, not one: the term at `x = r` where `y''` is undefined, and, in the sum whose argument is `y(x+1)`, the term at `x = r - 1` for the same reason and the term at `x = r` where `y(r+1) := 0` is a convention and not the arc. Each carries `|psi| <= 1/2`, so the peel costs `1` in that sum and `1/2` in the other, which is exactly the `+1` the assembly carries, with zero margin. The main term is not an Euler-Maclaurin error but a monotone sequence split by residue: `y(x) - y(x+1)` is nondecreasing by concavity, a residue class deviates from the block mean by at most the block spread, the spreads are disjoint increments and telescope, and only the largest single increment - `sqrt(2r - 1)` on the arc, `sqrt(2R)` at the shell - is paid at full size, so the main-term error is a square root and not a constant. Summed over the `3^j` classes each of the two column sawtooth sums is at most `4.5310 r R^(-1/3) + 101.0364 r R^(-1/2) + 2 r R^(-1) + 1` and each of the two box sawtooth sums at most `4.5310 R^(2/3) + 101.0364 R^(1/2) + 3`, since `3 pi 3^(-2/3) = 4.5309...` and `175 * 3^(-1/2) = 101.0362...`, both rounded up; the residue split costs `(7/9) sqrt(2r) <= 1.1000 r^(1/2)` on the column marginal and `(10/3) sqrt R + (4/3) sqrt(2R) <= 5.2190 R^(1/2)` on the box count, the two counting terms being exact to `2 * 3^j` and to `2/3`; the main terms cancel to `(2r + 1)/9` plus the residue `(R - floor(R))/9`, itself below `1/9`, and the errors add to `27.1860 r R^(-1/3) + 610.1581 r R^(-1/2) + 9.3334 r R^(-1) + 10.3334`, which `2r + 1 >= 2r` and `R <= r` fold into three constants. Assembling, `|p_j(r) - 1/9| <= 13.60 R^(-1/3) + 305.08 R^(-1/2) + 9.84 R^(-1)` at every level of every radius, every constant rounded up and every hypothesis inside the statement. Since `R_j = r/3^j` is geometric, `sum_(j < level) R_j^(-delta) <= 3^delta/(3^delta - 1)`, which reads `3.2612`, `2.3661` and `1.5` at `delta = 1/3, 1/2, 1`, so `sum_(j < level) |p_j(r) - 1/9| <= 781` uniformly in `r`; a Huxley-type `delta = 77/208` in place of van der Corput's `1/3` would move the first of those three to `2.9927` and nothing else, so the modern exponent is a luxury on this route and not a hinge. Box column `0` is never a seat and carries `r - floor(sqrt(r^2 - 3^(2j))) + 3^j >= 3^j` cells, so `1 - p_j(r) >= 3^j/(2r + 1) >= 1/(3 R_j)` at every level and the product never degenerates. Where `R_j` clears the `23157375` at which the bound first falls under `1/9`, the crossing sitting at `23157374.055`, `1 - p_j >= 7/9` and the mean value theorem gives `|log(1 - p_j) - log(8/9)| <= (9/7) |p_j - 1/9|`, so that block costs at most `(9/7) 781 <= 1004.15`. At most `16` levels fall below it, since `R_j < 23157375` asks `j > log_3 r - 15.44` while `log_3 r >= level - 1`, and on them `|log(1 - p_j) - log(8/9)| <= log(3 R_j) < (i + 1) log 3` at the `i`-th from the top, a tail of at most `log 3 * n(n + 3)/2` over the top `n` levels and so at most `167.0` at `n = 16`. Hence `|log ind(r)| <= 1191` for every `r >= 1`, and `ind` is bounded above and below by positive constants. What that is not: `Psi` is untouched, so `Phi = ind Psi` does not follow, and the frozen-slope refutation below still stands; the constant is a certificate and not a size, the measured `ind` living in `[0.542697, 1.515753]` inside an envelope of `e^(+-1191)`, all of it driven by the `175`; and the staircase is a plane fact, so the sponge has none of this. `lab/rs/circle-crop` asserts every identity above in exact integers at every level of `r = 80, 242, 1000, 2186, 6560, 12345, 19682` - the leaf weighting box by box, both marginals, the transpose equality, the seat identity, both floor formulas, the away-from-one lemma - then the bound itself, the drift sum against `781` and `|log ind|` against `1191`; the drift sums read `0.223603, 0.245132, 0.328170, 0.256778, 0.260804, 0.446659, 0.267260` and `|log ind|` reads `0.069975, 0.105310, 0.341219, 0.140802, 0.144928, 0.281717, 0.158483`, with worst slack `0.001478` against the cap. Those seven radii check the identities and not the bound: `13.60 R^(-1/3) + 305.08 R^(-1/2) + 9.84 R^(-1)` stays above the trivial `8/9` for every `R < 212957`, so at `r <= 19682` no assertion on the bound can fail, and the pass prints `live_levels=0` at each of them rather than claiming otherwise. The bound is asserted where it bites, at `j = 0` and `r = 212957`, `531441` and `2000000`, the first of them the least radius at which the cap clears `8/9` at all: caps `0.888888350`, `0.586410834` and `0.323672329`, measured gaps `0.000590`, `0.000447` and `0.000192`, ratios to the cap `0.000664`, `0.000761` and `0.000592`. (**Proved** for the staircase, the marginals, the seat identity, the arc cap, the residue split and all three bounds; **Verified** for every identity and every number the generator prints.)

**The crossing shell is a tree, and the pointwise question is a growth rate on it (Proved).** Fix `r`, write `S_j` for the level-`j` boxes carrying a crossing cell, and `R_j = r/3^j`. The box bound above gives `|X| <= R_j < |X + 1|` for every `X` in `S_j`, and the converse holds too: a monotone lattice path of unit cells from the box's near corner to its far corner starts inside the ball and ends outside it, and the first cell on it whose far corner is outside has near corner at most the previous cell's far corner coordinatewise, hence inside, so that cell crosses. `S_j` is therefore exactly the whole grid's crossing shell at the real radius `R_j`, and the real-radius form of the plane identity gives `|S_j| = 2 floor(r/3^j) + 1` at every level, `2r + 1` at `j = 0` and a single box at any `j` with `3^j > r`. Since a cell's level-`(j+1)` box is `floor(x/3)` of its level-`j` box, the levels chain into a rooted tree of depth `level` with `2r + 1` leaves, and a leaf's base-3 digit vector at position `j` is exactly its seat in its level-`(j+1)` parent, so `C(r)` counts the leaves whose root-to-leaf path never takes the centre seat and the pointwise question is a growth rate on a pruned tree. Writing `b(X)` for the number of children of `X` in `S_j`, summing over `S_(j+1)` gives the exact branching identity `sum_(X in S_(j+1)) b(X) = |S_j|`, so with `Q = floor(r/3^(j+1))` and `floor(r/3^j) = 3Q + k`, `k in {0, 1, 2}`, the mean branching is `(6Q + 2k + 1)/(2Q + 1) = 3 + (2k - 2)/(2Q + 1)`: exactly `3` at every level where `floor(r/3^j)` is `1 mod 3`, and `3 + O(1/Q)` at the other two residues. Both identities are asserted at every level of every radius the transfer pass runs. Suppose the pruned tree had a growth rate `lambda` per level while the tree grows at `3`: then `Phi(r) = C(r) (9/8)^level / C_full(r)` would be `(3 lambda / 8)^level` up to bounded factors, and `Phi` bounded would be exactly `lambda = 8/3`, the branching number `3` less the centre seat's share `1/3` - and `1/3` at the box is the same reading as `p_j = 1/9` at the cell, since a level-`j` centre child is one of the three seats a level-`(j+1)` box fills on average and carries an average leaf load. Nothing here proves the pruned tree has a growth rate, so the equivalence is a restatement under a hypothesis and not a reduction of `Phi` to a number. The [shell demo](../../site/demos/shell/) draws the shell as that tree at any radius, level by level, the surviving leaves lit against the pruned ones and every level's box count set beside `2 floor(r/3^j) + 1`. (**Conjecture** that the rate exists.)

**The transfer operator on the local pattern (Verified).** Give a box the 9-bit pattern of its crossed children as its state, printed in octal with bit `4` the centre. The pass reads the boxes of levels `1..level-3` only, dropping the top three levels of each tree, and over those levels `lab/rs/circle-crop` finds the same alphabet of `30` patterns at `r = 6560`, `19682` and `12345`, asserted equal across the three - `001, 003, 007, 011, 013, 017, 036, 070, 074, 111, 113, 132, 136, 170, 174, 222, 226, 264, 322, 326, 360, 364, 400, 440, 444, 600, 640, 644, 700, 740` - with no pattern taking more than `0.104824` of the boxes at any of them, and the branching means `3.003711`, `3.001532`, `3.000976` and centre rates `0.326994`, `0.328381`, `0.335367`, which tripled read `0.980983`, `0.985143`, `1.006102` against `1`. That alphabet belongs to the truncation and not to the tree. Reading every box of every level the count is `31` at all three radii, the extra state being the root's own pattern - `744` at `r = 6560` and `19682`, `032` at `r = 12345` - and even under the truncation the alphabet is not closed: of the `16683` radii `r = 3000..19682`, `228` carry a state outside the thirty over levels `1..level-3` and `1966` carry one over levels `1..level-1`, the extra reading `744` or `032` in every case and no radius ever reading fewer than thirty. The pinned witnesses are `r = 15122`, whose extra `744` appears at level `6 = level-3`, `r = 3182`, which carries `032` at every truncation, and `r = 1395`, `1739` and `6570`, which carry theirs at `1..level-1` alone, the last of them sitting ten above the pass's own `6560`. What is Verified is that the thirty all occur and no thirty-first does at the three study radii over levels `1..level-3`. The operator is the exact integer matrix `M[s][t]` of parent-child pairs over the printed levels and its mean offspring matrix is `A[s][t] = M[s][t] / n_s`; its Perron root is certified and never fitted, a positive integer test vector `v` giving the Collatz-Wielandt bracket `min_s (sum_t M[s][t] v_t) / (n_s v_s) <= rho(A) <= max_s`, an exact ratio of integers printed with the lower end truncated down and the upper rounded up. Against `3` the brackets read `[3.000861, 3.000862]`, `[3.000948, 3.000949]` and `[2.997616, 2.997617]`: `rho(A_r)` differs from `3` at all three radii, certified, by at most `0.0024`. That is a fact about three matrices and not a verdict on the process, and the same pass prints three reasons the Perron root is the wrong functional to try it with. The row sums of `A` are exactly `popcount(s)`, asserted state by state, so from the true state census at any level the memory-one model returns the level below with zero error - `161, 485, 1457, 4373, 13121` against the tree's own `|S_4|` down to `|S_0|` at `r = 6560` - and iterating the matrix four times from the level-`5` census still lands within `8.694464` of `13121`. The exact `3` the brackets miss is not a rate the tree realises: its pooled branching at `r = 6560` reads `3.037736, 3.012422, 3.004124, 3.001373, 3.000457` from level `5` down, the exact `3` being the `Q -> infinity` limit of `3 + (2k - 2)/(2Q + 1)` and no finite level. And the miss is finite-size: built from one level pair at a time the bracket's certified distance from `3` falls monotonically `0.323840, 0.002623, 0.002385, 0.000086` as the parent count rises `53, 161, 485, 1457`. Over `18` radii the pass does not otherwise use, `3001` to `18301` at stride `900`, every bracket excludes `3`, `9` of them above and `9` below, at sizes `0.000336` to `0.005951` - the same sign flip that leaves the ratio drift below uninformative. So `rho(A_r) != 3` at the three named radii is Verified, and whether the pattern process is Markov at memory one is untested here. Against `8/3` the pruned matrix - the same counts with the centre child dropped and the states that reach no survivor removed - brackets to `[2.657742, 2.657743]`, `[2.672261, 2.672262]` and `[2.668083, 2.668084]`, so the ratio `rho(A_nc)/rho(A)` brackets to `[0.885659, 0.885661]`, `[0.890471, 0.890473]` and `[0.890068, 0.890069]` against `8/9`, a per-level drift of `Phi`'s exponent of `[-0.003314, -0.003311]`, `[0.001618, 0.001621]` and `[0.001206, 0.001208]` in `log_3`. The sign flips with the radius, so nothing systematic survives, and a three-per-thousand error in the ratio is `(1 +- 0.003)^level` in `Phi`, which is precisely the error a bound may not carry: the memory-one operator neither confirms nor refutes `lambda = 8/3`. Enlarging the state to the pattern paired with the box's own seat in its parent - `263`, `270` and `270` of the `270` possible - moves the bracket to `[2.964909, 2.964910]`, `[3.000989, 3.000990]` and `[2.998702, 2.998703]` and the ratio to `[0.893588, 0.893590]`, `[0.891339, 0.891341]` and `[0.890199, 0.890201]`: no closer, and one of the three worse. One step of memory does not converge the state, which is the obstruction the route was always going to meet - a box's pattern is fixed by the arc's slope and its offset in the box, the offset triples modulo one down a level while the slope is a continuous parameter, so the exact state is an interval map and not a finite set. What the finite matrix does deliver is a certified contraction: the one-step Dobrushin coefficient is exactly `1` at every radius, two patterns with disjoint seats having disjoint child seats, but the minorisation `sum_t min_s P^n[s][t]`, computed in fixed point with every rounding taken down so the printed floor is a bound, reads `0.000000, 0.073937, 0.217716, 0.347398, 0.458035, 0.552167` at `n = 1..6` and `r = 6560`, forcing a contraction per level of at most `0.874687`, `0.874812` and `0.872736` at the three radii, a gap of at least `0.125188` for the printed matrix.

**`Psi` is a product over scales, and its terms decay (Proved identity; Verified decay).** Let `T_k(r)` count the crossing cells whose digit vectors at the top `k` positions `j = level - 1, ..., level - k` are all non-centre, so `T_0 = C_full(r)` and `T_level = C(r)`, and put `u_k = T_k / T_(k-1)`, the survival at the `k`-th position from the top given every coarser one. Indexing by the depth `k = level - 1 - j` from the top, the gain at rank `k` is `g_k = u_(k+1) / (1 - p_(level-1-k))`, that survival against its own marginal, which is what the generator computes. The `u_k` telescope to `C(r)/C_full(r)`, so `Psi(r) = prod_(k=0)^(level-1) g_k(r)` exactly, with `g_0 = u_1/(1 - p_(level-1)) = 1` identically - the top rank's conditional survival is its own marginal - and every `g_k` a ratio of two integer counts; the generator asserts the product against `Psi` computed directly to `1e-12` relative, and `g_0 = 1` exactly, at every radius. `Psi` bounded is therefore exactly the convergence of `sum_k log g_k` uniformly in `level`, so the generator sweeps six triadic windows at an even stride - `54, 162, 98, 98, 98, 97` radii from `r = 27..80` to `r = 6561..19682` - and pools `|log g_k|` by the depth `k` from the top rather than by the position `j`. Two ranks carry no information. `g_0 = 1` by construction, and `g_1 = 1` exactly whenever the centre box at level `level-1` or at level `level-2` is uncrossed, which is the case at `r = 80, 242, 1000, 2186, 6560, 19682` and `12345` alike, and at `18` of `54`, `54` of `162`, `35` of `98`, `35` of `98`, `35` of `98` and `32` of `97` sampled radii across the six windows. The ladder therefore carries at most `level - 1` informative ranks and often `level - 2`. The profile is set by `k` and not by `level`: the rank-one window mean stays inside `[35.902169, 36.207969]` in units of `10^-3` across all six windows and the rank-two mean inside `[33.540080, 34.280021]` across the five past `level = 4`, and at `r = 6561..19682` the full profile reads `0.000000, 36.111664, 34.280021, 24.412289, 14.937825, 11.086863, 6.332857, 3.731719, 2.371680`. From rank `2` the rank-to-rank decay is geometric, at worst `0.752924, 0.704680, 0.772659, 0.785194, 0.784415, 0.742201` over the six windows; the rank-one to rank-two step sits outside that statistic and is far slower, `0.949278` at the deepest window, so the decay quoted is the decay of the tail and not of the whole profile. The window totals of the mean `|log g_k|` read `89.734824, 105.695558, 118.801020, 125.674943, 130.335999, 133.264920`, increments `15.960734, 13.105462, 6.873923, 4.661056, 2.928921` falling by `0.821106, 0.524508, 0.678078, 0.628381`, and extrapolating those increments geometrically gives `146.708428` and the band `Psi` in `[0.863545, 1.158017]` in the window mean. That band is a fit and neither a cap nor pointwise, and the generator prints both failures beside it. It is not pointwise: the sampled per-window extremes of `Psi` envelope to `[0.824797, 1.321206]`, outside the band at both ends, printed on the same line with `band_holds=false`. And the extrapolation is not stable under the sampling that feeds it: resampling the three deepest windows at strides `24`, `48` and `72` moves the last increment to `1.993070`, `2.186657` and `4.336745` against `2.928921`, the deepest total to `131.731144`, `131.469841` and `131.968206` against `133.264920`, and the extrapolated total to `120.468507`, `141.506415` and `151.873506` against `146.708428` - and at stride `24` the increments do not decay at all, worst ratio `1.215013`, so the geometric sum diverges and there is no cap to print. The increments the band rests on are smaller than the noise of the grid that reads them. The per-radius picture agrees: the deviation of `log Psi` reads `0.070520, 0.074837, 0.074889, 0.076942, 0.078042, 0.078954` across the six windows, a rise of one part in eight where `sqrt(level)` over the same span would be one part in two, and the sampled extremes of `Psi` read `[0.881494, 1.276712]`, `[0.824797, 1.321206]`, `[0.842485, 1.281241]`, `[0.836172, 1.283999]`, `[0.837527, 1.290536]` and `[0.838220, 1.314879]`, flat over six windows. What the ladder delivers is the decay of the profile, which survives every resampling above; what it does not deliver is a rate, a cap or a band, all three of which move with the grid. (**Proved** for the tree, the branching identity, the ladder identity and `g_0 = 1`; **Verified** for every bracket, floor and rank profile printed; **Conjecture** for the band, for the geometric rate, and for `Psi` bounded, the six windows that read the decay being the same six that would have to bound it.)

**The operator, derived from the geometry (Proved law; Verified alphabet).** The pattern was read off the shell above; here it is derived, and the derivation is checked against the shell rather than the other way round. At level `j` the shell is the staircase of the circle of radius `R_j = r/3^j`: writing `y_j(x) = sqrt(R_j^2 - x^2)`, column `x` holds the rows `floor(y_j(x+1))` to `floor(y_j(x))`, and the level identity above is that telescoping. The scaling `y_(j-1)(3x) = 3 y_j(x)` is an identity of reals, so the offset `a_j(i) = frac(y_j(i))` obeys `a_(j-1)(3i) = frac(3 a_j(i))` at every level and every column: the offset at a box's leftmost child is exactly `3a mod 1`, with no error term and no hypothesis. The slope `sigma = -y_j'(i) = i/y_j(i)` is scale-free, the same number in fine units and coarse, so along the other two child columns the frozen-slope reading gives the offsets `3a - sigma` and `3a - 2 sigma`. The state is therefore `(sigma, a)` and the level map is the `x -> 3x mod 1` transfer operator on the offset at frozen slope, integrated over the circle's slope. The pattern falls out of the same coordinates: with `u` the box's offset in child units and the four floors `v_k = floor(u - k sigma)`, `k = 0..3`, the box carries the child in column `k` and row `t` exactly when `v_(k+1) <= t <= v_k`, so the 9-bit pattern is the function `mask(v_0, v_1, v_2, v_3)` of four integers clipped to `[0, 2]`. That makes the alphabet a theorem about the map. A quadruple is realised by some `(u, sigma)` with `sigma >= 0` exactly when `max_(k<l) (v_k - v_l - 1)/(l - k) < min_(l<k) (v_l - v_k + 1)/(k - l)` and that upper end is positive, an exact rational test; enumerating every quadruple returns exactly thirty masks, stable from search radius `12` to `15`, and they are the shell's thirty character for character - `001, 003, 007, 011, 013, 017, 036, 070, 074, 111, 113, 132, 136, 170, 174, 222, 226, 264, 322, 326, 360, 364, 400, 440, 444, 600, 640, 644, 700, 740` - asserted equal at `r = 6560`, `19682` and `12345`. The thirty-first state is not realisable by any line: `744` forces `v = (>= 2, 2, 2, <= 0)` and `032` forces `v = (1, 1, <= -1, ...)`, each a zero step beside a step of at least two, while the floors of a line step by `floor(sigma)` or `floor(sigma) + 1` and never by both. So the thirty is the frozen-slope alphabet, the extra state is a curvature state, and that is why it lives at the top of the tree alone. Where the turning bites is then measurable: taking the chord of the box, `sigma = (y_j(3i) - y_j(3i+3))/3`, the derived pattern reproduces the shell's on the shallow half of the arc, `sigma <= 1`, with `2` faults of `2188` boxes at level `0` and none at all at levels `1` to `5` at `r = 6560`; the shell is symmetric under swapping the coordinates, so the steep half is the transpose of the shallow half and the same law reads it in rows. Forcing the column parametrization on the steep end too, the chord's fault rate over all boxes reads `0.011434, 0.020590, 0.035052, 0.068323, 0.113208, 0.235294, 0.600000` at levels `0..6` for `r = 6560` and `0.006631, 0.009604, 0.018531, 0.051546, 0.062112, 0.188679, 0.235294, 0.600000` at levels `0..7` for `r = 19682`, against the tangent's `0.023325, 0.040494, 0.101031, 0.161491, 0.415094, 0.411765, 0.600000` at the first: the law is exact where the parametrization is right and fails only where `R_j = O(1)` and the arc turns by `O(1)` inside one box. The centre seat comes out of the same coordinates at `1/3`: the centre child is crossed exactly when `u` lies in `[1 + sigma, 2 + 2 sigma)`, an interval of length `1 + sigma` met by a progression of step `3`, while the coarse column carries `1 + sigma + O(1)` boxes, so with the offset equidistributed the centre rate is `1/3` at every slope and `p_j = 1/9` follows from `|S_(j+1)|/|S_j| -> 1/3`; measured, `r = 6560` reads `0.342099, 0.334248, 0.309278, 0.310559, 0.339623, 0.294118, 0.400000` at levels `0..6` and `r = 19682` reads `0.340980, 0.329522, 0.330130, 0.317526, 0.310559, 0.339623, 0.294118, 0.400000` at levels `0..7`. (**Proved** for the offset map, the pattern law and the feasibility test; **Verified** for the alphabet's equality with the shell, for the fault rates and for the centre rates.)

**A frozen-slope gap cannot bound `Psi` (Refuted).** The derivation says what `Psi` is. At frozen slope a leaf's digits are the symbolic itinerary of the offset under `x -> 3x mod 1`, the leaf dies when one of its boxes takes the centre seat, so `C/C_full` is the survivor measure of that map with the hole `[1 + sigma, 2 + 2 sigma)` and `Psi` is that survivor measure divided by the product of the hole's marginals. `Psi` bounded is therefore exactly the statement that the punctured operator's leading eigenvalue equals `1 - p` rather than merely approximating it, and for an open system that is a coincidence, not a gap: the hole is a full triadic cylinder only at `sigma = 0`, where the digits are independent and `Psi = 1` identically. It fails. Running the ladder on a straight line of slope `1/3` across `3^level` columns, where the pattern law is exact, `log Psi` reads `0.039821, 0.063195, 0.087646, 0.111808, 0.136048, 0.160267, 0.184491, 0.208714, 0.232938` at `level = 4..12`, an increment of `0.024224` a level at each of the three line offsets `0`, `0.411523` and `0.906094` alike, so `Psi` grows like `1.024520^level`, and the per-level survival `survival^(1/level)` reads `0.910342` at `level = 12` against the independent model's `8/9 = 0.888889` printed beside it; at slope `1/7` the same ladder has `log Psi` falling by `0.009633` a level, and at `1/2`, `sqrt(2) - 1`, `(sqrt(5) - 1)/2` and `pi/4` it settles flat at `-0.008195`, `0.002837`, `0.021450` and `-0.009142`. A spectral gap of the frozen operator therefore cannot bound `Psi`, at any slope-by-slope integration, since the frozen model's own `Psi` is unbounded at a set of slopes the circle meets. What kills the resonance is the turning that was the route's named obstruction. A leaf's slope drifts by `(1 + sigma^2)^(3/2)/R_j` across its level-`j` box, so an arc tracks a given slope only while `3^j/r` stays inside the resonance's width; setting the line's slope to `1/3 + 3^-k` the ladder follows the resonant `log Psi` through depth `k - 2` and departs one depth later, so at `k = 9` the four readings `0.039821, 0.063195, 0.087646, 0.111808` at depths `4` to `7` are shared with the resonant line before the split at `0.132569` against `0.136048`. The circle visits every resonance and stays at none, which is why the shell's own `Psi` measures flat over eight windows while the frozen model's does not, and it is why the top three positions, where `R_j = O(1)` and the slope turns by `O(1)` in a single box, carry the whole departure of `p_j` from `1/9`. So the route dies at its first move and leaves its successor named: a bound on `Psi` is not a gap of the frozen operator but a bound on how many levels a resonance can be tracked, `O(log_3(eps r))` levels inside a window of width `eps`, which the two paragraphs below prove with the constant `floor(log_3(2 eps r)) + 1` and show sharp. (**Refuted** for the frozen-slope gap as a route to `Psi` bounded; **Verified** for every ladder number and the tracking depth; **Conjecture**, still, that `Psi` is bounded.)

**The resonance-tracking bound (Proved; Verified).** Write `y(u) = sqrt(r^2 - u^2)` on `[0, r)` and `t(u) = u/y(u) = -y'(u)` for the arc's slope at fine column `u`, increasing from `0` to `+infinity` with `t'(u) = r^2 (r^2 - u^2)^(-3/2) = (1 + t(u)^2)^(3/2)/r`. The level-`j` COLUMN BLOCK in column `i` is the fine columns `[3^j i, 3^j (i + 1)]`, and it TRACKS the window `W(a/b, eps) = (a/b - eps, a/b + eps)` when `t` carries that closed interval into `W`. A level-`j` BOX is a cell of the level-`j` grid and its content is the part of the shell inside it, `w(X)` fine columns and `h(X)` fine rows; only the boxes the arc crosses side to side have `w(X) = 3^j`, so a block statement is not a box statement and the difference is measured below. Two facts settle the question the refutation left. Tracking is inherited downwards: a level-`(j-1)` block inside a tracking level-`j` block tracks the same window, since `t` is increasing and the sub-interval is contained, so for one leaf and one window the tracked levels are a run `{0, ..., J}` from the bottom of the tree and never a gap. And `t'(u) >= r^2 r^(-3) = 1/r` on all of `[0, r)`, so by the mean value theorem every level-`j` block's slope span is at least `3^j/r = 1/R_j`, at every block whose right edge is at most `r` - the outermost block of a level runs past `r`, where `t` does not exist, and the sweep stops before it - with no shallow hypothesis and no curvature estimate. Tracking puts that span inside an interval of length `2 eps`, so at `dim = 2`, for every integer `r >= 1`, every rational `a/b` and every `eps > 0`, a level-`j` column block of the crossing shell of radius `r` tracks `W(a/b, eps)` only if `3^j < 2 eps r`, and the tracked run of any leaf is at most `floor(log_3(2 eps r)) + 1` levels, uniformly in `a`, in `b` and in the leaf. At the Dirichlet width `eps = 1/b^2`, where the rationals of denominator at most `b` are separated, that reads `floor(log_3(2r/b^2)) + 1`, and no level-`j` block tracks a rational of denominator `b >= sqrt(2 R_j)`; counting ranks from the top of the `Psi` ladder, `k = level - 1 - j` and `R_j < 3^(k+1)`, so no block at rank `k` tracks a rational with `b >= sqrt(6) 3^(k/2)` - rank `0` sees only `b <= 2`, rank `1` only `b <= 4`, rank `2` only `b <= 7`, rank `3` only `b <= 12`, rank `4` only `b <= 22`. That budget is on the block and not on the box, and the gap is printed: the level-`6` box `(16, 20)` at `r = 19682` has content slope span `0.002487440`, `6.7157%` of its block's floor `3^6/r = 0.037038919`, and its whole content sits inside the Dirichlet window of `17/21` while the rank-`2` block budget stops at `b <= 7`. The cap is sharp for blocks and not merely true: if `a >= 1` and `ab + 1 <= b^2`, so the window sits inside the shallow half `t <= 1`, and if `8 * 3^(2j) b^4 < r^2`, then some level-`j` shell block does track `W(a/b, 1/b^2)`, because `(t^(-1))'(s) = r (1 + s^2)^(-3/2) >= r 2^(-3/2)` on `[0, 1]` makes `t^(-1)(W)` longer than `2 * 3^j` exactly then, an open interval that long holds a closed block `[3^j i, 3^j (i + 1)]`, and that block ends below `t^(-1)(1) = r/sqrt 2` so its column is a shell column. `lab/rs/circle-crop` sweeps all `279` fractions of `F_30`, every `a/b` in `[0, 1]` with `b <= 30`, at `r = 3^level - 1` for `level = 6, 7, 8, 9`, reads the run on the shallow half by exact integer arithmetic - `t(u) < p/q` is `u^2 (q^2 + p^2) < p^2 r^2`, the cap is `#{j : 3^j b^2 < 2r}` and the floor is `#{j : 8 * 3^(2j) b^4 < r^2}` - and asserts the run inside those two integer counts on every one of the `1116` slope rows, a run past the cap being the witness that would kill the theorem. The cap bites at `276` of the `279` slopes at each radius, the run equals the cap at `102`, `91`, `93` and `98` of them and equals the floor at `26`, `72`, `66` and `63`, and over the `277` slopes meeting the sharpness hypothesis `a >= 1` and `a b + 1 <= b^2`, `1108` of the rows, cap less floor is never above `2` and attains it, so the two exact integer counts pin those runs to within two levels at every radius swept; at `0/1` and `1/1` the hypothesis fails, the floor reads `0`, and the pair says nothing. At `r = 19682` the run is `8` at slope `1/3` against cap `8` and floor `7`, `7` at `1/5` against `7` and `6`, `4` at `1/30` against `4` and `2`, and `2` at `29/30` against `4` and `2`. The [Farey](/wiki/farey-sequence/) budget the sweep measures, the largest `F_30` denominator tracked at a level, reads `30, 30, 30, 30, 19, 11, 6, 3, 1` at levels `0` to `8` for `r = 19682` against the theorem's `22, 12, 7, 4, 2` at the last five, the first four levels being held by the sweep's own `b <= 30` and not by the bound; every level's line prints `b^2 3^j` beside `2r`. Residue classes ride with each row: the tracking columns at the deepest tracked level are censused mod `3`, the seat classes `p_j` reads. The steep half is the transpose of the shallow half in rows and the seat class is transpose-invariant, so nothing is lost by reading columns only. (**Proved** for the down-set, the span floor, the block cap and its sharpness; **Verified** for every run, budget, residue census and box witness.)

**No column block of the shell is a line past `level/2 + O(1)`, and a box still can (Proved; Verified).** Let `U`, `U + m` and `U + 2m` be integers in `[0, r)` and suppose the shell heights `v(X) = floor(y(X))` agree at those three columns with `floor(l(X))` for some affine `l`. For an affine `l` the second difference of `floor(l)` is `-frac(l(U)) + 2 frac(l(U + m)) - frac(l(U + 2m))`, an integer in `(-2, 2)` and hence at least `-1`; for the arc, `y(U) - 2 y(U + m) + y(U + 2m) = m^2 y''(xi)` for some `xi` in `(U, U + 2m)` with `|y''| = r^2 (r^2 - u^2)^(-3/2) >= 1/r`, so that second difference is at most `-m^2/r`, and `v = y - frac(y)` adds less than `2`. Both readings of one integer give `-1 <= 2 - m^2/r`, so `m^2 <= 3r`. A level-`j` column block holds `3^j` fine columns and therefore the triple with `m = (3^j - 1)/2`, so if the shell's staircase across the whole block is any line's staircase then `(3^j - 1)^2 <= 12 r` and `j <= log_3(1 + 2 sqrt(3r))`, which is `level/2 + O(1)` and reads `5.633` at `r = 19682`; the bound is left in that form because `log_3(1 + 2 sqrt(3r))` runs `2.165784, 2.663880, 3.154190, 3.645789, 4.139992` at `level = 2` to `6` and `level/2 + 1.14` rounds the unsafe way below `level = 6`. Above that level no column block is a line and, by the coordinate swap, no row block either. A box is not a block, and the same triple says only what its extents allow: a box whose content is a line's staircase has `w(X) <= 2 + 2 sqrt(3r)` and `h(X) <= 2 + 2 sqrt(3r)`, which above the block cap excludes nothing for a box the arc enters and leaves through the same side. It excludes nothing, and boxes take the room: at `r = 19682` and level `6`, above the block cap, the arc crosses only `12` of the `53` boxes side to side, `19` of the `53` have both extents inside the theorem's own reach, and exactly `3` boxes have their whole content equal to a line's staircase, `(16, 20)` on columns `12369..12392` with `-y'` in `(0.8000000, 0.8125000)`, `(19, 19)` on `13851..13983` with `-y'` in `(0.9924812, 1.0075188)` and `(20, 16)` on `15290..15308` with `-y'` in `(1.2307692, 1.2500000)`, each certified by the exact rational feasibility bracket for `floor(s x + c) = v(x)` over the whole content. The generator reads the necessary condition `abs(v(U) - 2 v(U + m) + v(U + 2m)) <= 1` at `m = (3^j - 1)/2` over every level and every shell column and prints the deepest level that passes, `4, 4, 5, 5` at `r = 728, 2186, 6560, 19682` with witness column `0` at each, the flattest place on the arc; it then asserts both `((3^j - 1)/2)^2 <= 3r` and `((3^(j+1) - 1)/2)^2 > 3r`, so the block cap is met and not merely satisfied, `14641 <= 59046 < 132496` at `r = 19682`. What is attained there is the three-point condition and not a line: the condition is necessary, so the level it reaches is an upper bound for the line depth and not the line depth. The same coordinates say why the thirty-mask alphabet cannot see a resonance: the state is `mask(v_0, v_1, v_2, v_3)` with `v_k = floor(u - k sigma)`, and moving `sigma` to `sigma + eps` moves `u - k sigma` by `k eps`, so `v_k` changes only on the offsets with `frac(u - k sigma) < k eps`, a set of measure `k eps`, and the two masks differ on at most `6 eps` of the offset circle; the generator computes that set exactly at `sigma = 1/3` and `eps = 3^(-k)` for `k = 2` to `7` and finds it exactly `4 eps` every time, the gap to `6 eps` being the mask's clamp of its four floors to the rows `0` to `2`, which lets a floor move without the state moving. What this gives `Psi` is exact and it is not a bound. Rank `k` of the ladder reads level `j = level - 1 - k`, so every rank with `k < level - 1 - log_3(1 + 2 sqrt(3r))` carries no frozen-slope resonance across a whole block; that is `level/2 - 2.14` ranks to leading order, always under half of them, and at `level = 9` it frees ranks `0`, `1` and `2`, three of the nine, which carry `70.391685` of the deepest window's profile total `133.264920` in units of `10^-3`, `52.82%` of it. The frozen refutation's own divergence, `0.024224` a level at slope `1/3`, therefore cannot run the depth of the tree on a circle block by block, only `level/2 + O(1)` levels of it, which halves the exponent the refuted route produced and bounds nothing. `Psi` bounded is the convergence of `sum_k abs(log g_k)` uniformly in `level`; the tracking bound caps the length of a resonant run and says nothing about the amplitude the run carries, `g_k` is a ratio of counts over all `2 floor(R_j) + 1` boxes of a level at once, and the caps are block statements while the counts are box counts. The mass of the measured profile sits at ranks `1` and `2`, exactly the ranks with the smallest Farey budget, `b <= 4` and `b <= 7`, the seven fractions of `F_4` and the nineteen of `F_7`, and exactly the ranks freed of every block-wide line: the top of the profile is not a resonance effect but the `R_j = O(1)` effect that already carries the departure of `p_j` from `1/9`. (**Proved** for the three-point bound, the block corollary, the box corollary and the alphabet's blindness; **Verified** for the line depths, the three line boxes, the exact blind measures and the rank arithmetic; **Conjecture**, still, that `Psi` is bounded.)

**The measure of the corner disc (Verified).** `M(3^k) = m^k mu(B_1)` and the In and Cut columns bracket it, so the printed rows certify `mu(B_1)` in `[0.750767350, 0.751113415]` for the carpet at `r = 6561` and in `[0.475928750, 0.485478125]` for the sponge at `r = 243`. Lebesgue's values are `pi/4 = 0.7853981634` and `pi/6 = 0.5235987756`, far outside; `3/4` is outside the carpet's bracket too, so the quarter disc's carpet mass is not that either. This is the one place the count reads a constant of the limit measure straight off exact integers.

**There is no resonance at `r = 3^n` (Verified).** The powers of the base are the natural place to expect the error, since the digit-product transform does not decay along `3^m t` at integer `t`. The defect says otherwise: at `r = 1, 3, 9, 27, 81, 243, 729, 2187` the carpet's `|delta|` ranks at `0.5000, 0.8333, 0.1111, 0.0185, 0.6605, 0.5514, 0.7167, 0.4390` inside its own triadic window, the rank of `3^n` being the fraction of the window `r = 3^n .. 3^(n+1) - 1` with `|delta(r)| <= |delta(3^n)|`, and the sponge's at `0.5000, 0.6667, 0.3333, 0.2963, 0.3395` - scattered, with no trend and no extreme high. `delta(27) = 0` exactly, the minimum of `|delta|` over `r = 27..80` at rank `0.0185`, so `N(81) = 8 N(27)` on the nose, and `N(3^(k+1))/N(3^k)` reads `7, 6.857143, 8.020833, 8, 7.990260, 7.998618, 8.000467, 7.999949`. What is periodic is the profile, not a spike: the crossing count's window maximum sits at `2.9671` times the window's start for `k = 5, 6, 7, 8`, the argument tripling exactly from `r = 721` onward, and the defect's maximum sits at `2.3333, 2.7407, 2.8724, 2.8628, 2.7979` times the start for `k = 3..7`. The `3^n` radii are quiet points of the crossing profile, which ranks them at `0.1296, 0.1235, 0.1296, 0.1200, 0.1253, 0.1283` for `k = 3..8` on the carpet and `0.0185, 0.0062, 0.0021` for `k = 3, 4, 5` on the sponge by the same statistic; they are not quiet points of the defect, whose eight carpet ranks average `0.4788` (derived from the ranks above) and reach `0.8333` at `r = 3`.

**The centre is a hole, and the density main term dies there (Proved; Verified).** The centre cell of the grid at level `level` is `((3^level - 1)/2, ...)`, whose base-3 digits are all `1`, and the digit vector `(1, ..., 1)` is missing from `S` in both designs, so the entire middle block is empty and the centre count vanishes out to the block's inradius `(3^(level-1) - 1)/2`. There the error against the density main term is minus the whole main term: `N - rho_level N_full` has relative size exactly `1`, at every level, over a range of radii of length `3^(level-1)/2`. The first filled cell sits at `r = 122` and `r = 365` on the carpet at `level = 6, 7`, one past the inradius; on the sponge the empty region is larger, since every face neighbour of the middle block has two middle digits and is missing too, and the first hit is `r = 20` and `r = 58` at `level = 4, 5`, the first integer past `sqrt(2) 3^(level-1)/2`. Across the whole inscribed range the relative error falls only to `0.059636` on the carpet at `level = 7` and `0.301915` on the sponge at `level = 5`. So `rho_level * vol(B_r)` is not an asymptotic for a centred design count at any level, and the corner convention above is the one that carries a theorem.

**The transform route, and where it stops (open).** For the centre ball, which lies inside one period box, the finite-level identity is exact: with `f` the design at level `level` read mod `3^level`, `hat f(a) = 3^(-dim level) sum_(y in F_level) e(-a.y/3^level)` and `S_r(t) = sum_(x in B_r cap Z^dim) e(t.x)`, Fourier inversion and one swap give `N(r) - rho_level N_full(r) = sum_(a != 0) hat f(a) S_r(a/3^level)` with no error term. The digit-product transform factors: in the unnormalised convention `P(u) = sum_(d in S) e(-d . u)`, which is the one used here, `|sum_(y in F_level) e(-a . y/3^level)| = m^k prod_(j = k+1)^level |P(a/3^j)|` when `3^k` exactly divides `a`, since `P` equals `m` at every integer argument; the same product written with the normalised `P/m` is off by `m^(level-k)`. So the frequencies of high `3`-adic valuation carry their full mass. In the limit the statement is the non-Rajchman tombstone `hat mu(3t) = (P(t)/m) hat mu(t)`, true at every real `t`, with `P(t)/m = 1` exactly on `t in Z^dim` because `S` contains `0` and every unit vector: the familiar `hat mu(3^m t) = hat mu(t)` therefore needs `t in Z^dim` and fails off the lattice, the carpet reading `|hat mu(t)| = 0.59332804` against `|hat mu(3t)| = 0.29666402` at `t = (1/2, 0)`, where `P(t)/m = 0.5`, and `0.10072687` at both for `t = (1, 0)`. Turning the identity into a bound needs `S_r` at those rationals, and the only decay in stock is Bessel, `r^((dim-1)/2) |t|^(-(dim+1)/2)` for the ball's continuous transform; passing from the lattice sum to that transform reintroduces the classical circle error the exact main term above was chosen to avoid, and the frequencies where `|hat 1_F|` is at full size are exactly the ones a term-by-term Bessel bound handles worst. No bound is carried through here, so none is claimed, and the price of the route is exact. Write `phi_level(a) = m^(-level) sum_(y in F_level) e(-a . y/3^level)`, so `phi_level(0) = 1` and `hat f(a) = rho_level phi_level(a)` with `rho_level = (m/3^dim)^level`, and the identity reads `N(r) - rho_level N_full(r) = rho_level sum_(a != 0) phi_level(a) S_r(a/3^level)`. Take `3^(level-1) <= r < 3^level`, so `rho_level` is `r^(dimension-dim)` up to a bounded factor, and landing this error at `r^(dimension-1)`, the saving the corner count already carries, asks exactly `sum_(a != 0) |phi_level(a)| |S_r(a/3^level)| = O(r^(dim-1))`: the budget is the shell bound itself. The circle sum has a floor at the square root of that budget. By Poisson the lattice sum is the ball's continuous transform summed over integer shifts, of size `r^((dim-1)/2) |t|^(-(dim+1)/2)`, so at a frequency whose distance to the lattice is of order `1` the sum is of order `r^((dim-1)/2)`, which is `r^(1/2)` at `dim = 2` and is attained; a van der Corput second-derivative bound on an arc of the circle gives the same `r^(1/2)`, and no term-by-term estimate of any order goes below it. The route therefore needs the `l^1` mass `Lambda_level = sum_(a != 0) |phi_level(a)|` to be `O(3^(level/2))`, at most `sqrt(3) = 1.7320508076` per triadic step. Write one step as `h(u) = m^(-1) sum_(e in {0,1,2}^dim) |P(u + e/3)|`. At `u in Z^dim` on the carpet `|P(u)| = m` while the full digit box sums to zero off the lattice, so `P(e/3) = -e(-(e_1 + e_2)/3)` has modulus `1` at each of the `3^dim - 1 = 8` nonzero `e` and `h(u) = (m + 3^dim - 1)/m = 2` exactly (**Proved**). That value is not the minimum: the generator evaluates `h` at the level-5 triadic point `u = (155/243, 155/243)`, which the recursion visits, and gets `1.951261 < 2` (**Refuted**). So the mass is measured, not bounded from below by a step argument: `Lambda_level` reads `1.000000, 3.585973, 9.637999, 23.736907, 56.547512, 132.884543` at `level = 1..6`, the step falls `3.585973, 2.687694, 2.462846, 2.382261, 2.349963` toward the transfer operator's eigenvalue and stays above `2` at every step printed, and the step at `level = 6` is `log_3 2.349963 = 0.777708` per triadic level. The route is worse off for it: the term-by-term cost is `r^1.277708` against the budget `r^1`, the error is no better than `r^1.170497`, and both exceed what the exact floor `Lambda_level >= 2^level - 1` would give, `r^1.1309297536` and `r^1.0237190143`, the `-1` being the excluded `a = 0` and the level-1 mass being `2`. The exact saving that would close it is a uniform `|S_r(a/3^level)| = O(r^(dim - 1 - log_3 step))` over the nonzero frequencies, `O(r^0.3690702464)` at the `2^level` floor and `O(r^0.222292)` at the measured step, both strictly below the square-root floor `1/2`, so no term-by-term bound closes it at any van der Corput order; what is left is cancellation in the `a` sum, or an `l^2` large-values count of `#{a : |phi_level(a)| >= X}` in place of the mass. (**Proved** for the budget and for `h(u) = 2` at `u in Z^2`; **Refuted** for `2` as the minimum of `h`; **Verified** for the mass values and their step over `level = 1..6`; the Bessel size is cited; **Conjecture** that the route can be made to beat `r^(dim-1)` at all.)

**The yardstick, at source (cited, with this tree's own savings tagged in place).** For the whole lattice the same question is the Gauss circle problem: `#(Z^2 cap B_R) - pi R^2 = O(R^theta)`, conjectured by Hardy at `theta = 1/2 + eps` and forced above it by Hardy's `Omega(R^(1/2) (log R)^(1/4))`. The exponent to quote is `theta = 131/208 = 0.6298076923`, from [Huxley, Exponential sums and lattice points III, Proc. LMS 87 (2003) 591-609](https://doi.org/10.1112/S0024611503014485), where `K = 131/208` bounds the lattice-point discrepancy as `O(R^K (log R)^Lambda)` in the maximum radius of curvature `R`, improving `46/73` from the second paper of the series. The sharper `517/824 = 0.6274271845` should not be quoted: its source, [Bourgain and Watt, Mean square of zeta function, circle problem and divisor problem revisited](https://arxiv.org/abs/1709.04340), stands withdrawn, the authors' own note recording a gap in the proofs of Propositions 2 and 3 and a further problem with Proposition 1', so that "Theorems 1, 2 and 3 lose their status as theorems". In three dimensions the count `S(R) = #{x in Z^3 : |x| <= R}` satisfies `S(R) = (4/3) pi R^3 + O_eps(R^(21/16 + eps))` by [Heath-Brown, Lattice points in the sphere](https://ora.ox.ac.uk/objects/uuid:4b17126d-c3a0-4827-8fa2-0ad82872d17e), sharpening `29/22` of Chamizo and Iwaniec and the `4/3` of Chen and Vinogradov, against the known `Omega(R (log R)^(1/2))` and the conjectured `O_eps(R^(1 + eps))`. Against all of this the savings line up as follows. For the lattice the saving is `2 - theta`, so `1.3701923077` at Huxley's exponent and `3/2` at Hardy's conjecture, both cited above. For the carpet the proved saving is `dimension - 1 = 0.8927892607` (**Proved**) and the measured one lies between `1.243974` and `1.365299`, `dimension` less the defect's three central estimators (**Conjecture**). Each of the four is a lower bound on a saving, so they order what is proved and what is measured, not the two error terms; nothing here says which error decays faster.

**What the search found, and what it did not.** Searches for lattice points of self-similar sets in discs, for a fractal Gauss circle problem, for [Sierpinski carpet](/wiki/sierpinski-carpet/) lattice point counting, for log-periodic counting functions in balls and for missing-digit sets in balls returned the analytic number theory of digit-restricted integers - primes and Waring problems and the divisor function over missing-digit sets, all of them counting in intervals or under arithmetic constraints, never in a Euclidean ball - and the classical archetype for the periodic multiplier, Delange's summatory digit-sum fluctuation. No theorem counting a self-similar carpet's lattice points in a disc was found among what those searches reach, which is a statement about the search and not about the literature; nothing here is claimed as a first.

**How to break it.** Every measured number above is printed by `lab/rs/circle-crop`; every other number - the exponents `dimension` and `dimension - 1`, the halves and savings taken from printed estimators, and the classical constants - is derived or cited where it stands. Every row is asserted before it prints: `In <= N <= In + Cut` for the design and for the whole grid, the crossing bounds `C_full(r) <= 3r + 5` in `dim = 2` and `C_full(r) <= pi sqrt(3) (r^2 + 1)` in `dim = 3`, `|delta(r)| <= C(3r) + m C(r)`, the theorem's own `|E| - band <= C(r)`, the level-free identity level against level, and the census cross-check in exact `Frac` arithmetic at `41` radii. Of the `22028` rows the `totals` line counts, `6802` carry a live band - `6560` of the carpet's `19682` corner rows and `242` of the sponge's `728`, by the two `bands` lines - and the rest sit at depth `0`, where the assertion reads `0 <= C(r)`; every band quoted above comes from a row of depth `4` or more, `7, 6, 5, 4` at `r = 3, 9, 27, 81`. The exponents are windowed measurements and nothing more: the crossing exponent is pinned to `[0.871, 0.970]` on the carpet by `6534` readings and to `[1.704, 1.758]` on the sponge by `216`, and any claim that it equals `dimension - 1` needs a proof or a deeper level. The defect exponent is pinned only to `[0.22, 1.02]`, and one more triadic window on the carpet needs level `10`, a grid of `3.5 * 10^9` cells, so a smarter generator, not a bigger one, is what would settle it. The transfer pass asserts its own scaffolding before any of it prints: `|S_j| = 2 floor(r/3^j) + 1` at every level, the children of one level exhausting the level below, the pattern alphabet equal across the three radii over levels `1..level-3`, `g_0 = 1` exactly, and `prod_k g_k` equal to `Psi` computed directly to `1e-12`; its Perron brackets are exact ratios of integers and its minorisation floors round down at every step, so both are bounds and not readings, and the two claims that would break the lane are sharp - a certified bracket for `rho(A_nc)/rho(A)` that excludes `8/9` at every large radius kills `Phi` bounded, and a rank profile whose decay approaches `1` kills `Psi` bounded. The index pass asserts the proof itself rather than its conclusion: `leaves(X) = w + h - 1` box by box, both marginals against `floor(r/3^j) + r + 1`, `sum_X leaves = 2r + 1`, the transpose equality of the seat marginals, the seat identity `p_j (2r+1) = 2 sum_(seat) w - #seats`, both floor formulas rebuilt from integer square roots, and `(2r+1) - seats >= 3^j`, all in exact integers at every level of seven radii, so an algebra slip in the derivation fails an assertion instead of shifting a decimal; the bound itself is asserted per level and its slack printed, and a single radius whose drift sum passes `781` or whose `|log ind|` passes `1191` kills the theorem outright. The derivation pass asserts its own scaffolding too: the line alphabet is asserted equal at search radius `12` and `15`, equal to the shell's truncated alphabet at all three radii, and the every-level alphabet is asserted to hold exactly one state the line cannot realise. The [crop demo](../../site/demos/crop/) draws the shape and the census; it does not yet draw `N(r)` against `r^dimension G(log_3 r)`, which is the one picture this section wants.

## The open lane: curved slices

The Cut column at fixed `r = 1/2` is a box count: `filled_cut` at level `level` counts the `3^-level` cells that meet both the circle and the pre-fractal at level `level`, so its growth exponent `log_3` of the ratio measures the dimension of the circle's trace on the carpet - an upper bound for the trace on the limit set, since a surviving cell need not meet the intersection itself. The printed ratios give `log_3(28/8) = 1.140`, then `0.909, 0.899, 0.951` for the carpet circle, and `2.166, 1.579, 1.705` for the sponge sphere. (Verified for the ratios; any limit is **Conjecture** - five levels decide nothing.)

The yardstick is the straight case. Furstenberg's slice conjecture, proved independently by [Shmerkin 2019](https://arxiv.org/abs/1609.07802) and [Wu 2019](https://arxiv.org/abs/1609.08053), concerns the intersection of a `xp`-invariant and a `xq`-invariant closed subset of the line with `p` and `q` multiplicatively independent - equivalently, irrational-slope slices of the product `A x B` - and bounds its box dimension by `max(dimension - 1, 0)`. That theorem is cited, not claimed, and the carpet is a single `x3`-invariant planar set, not such a product, so the theorem does not literally cover the carpet's straight lines either, let alone circles: for the carpet and the sponge, both the straight `dimension - 1` bound and any curved analogue are yardsticks by analogy, not covered cases. The comparison values are `dimension - 1 = 0.8928` for the carpet and `1.7268` for the sponge, and the printed exponents hover near both - suggestive and unproved. Whether the slice bound, or the generic-slice value from the Marstrand side, extends to curved slices - a circle on the carpet, a sphere on the sponge - appears uncharted for self-similar carpets: the arithmetic digit structure that drives the straight-line theory has no obvious action on a curve of no rational slope anywhere. That is the lane. (**Conjecture**, all of it.)

## The neighbours

- [slices](slices.md) and [cuts](cuts.md) section these solids with single planes, one offset at a time, and get exact meshes and digit-scheduled gaskets. A sphere crop of the sponge sweeps all plane sections at once: the Cut shell at radius `r` meets tangent planes of every orientation, and the sweep in `r` runs through every offset, so the sphere's cut census aggregates the whole two-parameter family of plane sections the plane pages take one by one. The price is exactness - the plane pages get closed forms, the shell so far only counts.
- [dimensions](dimensions.md) predicts that a lattice set's counts oscillate along `log` of the scale with period `2*pi/ln 3`. `filled_in(r)` detrended by `r^dimension` along `log r`, and `filled_cut` along the level, are the same observable for the crop; the 24-point sweep above is too coarse to fold, and nothing is measured yet. (Open.)
- The trivial end, stated honestly: a grid-aligned polytope crop is digit counting, not geometry. A box whose walls sit on multiples of `3^-k` keeps exactly the cells whose coordinates lie in integer intervals at level `k`, and counting a digit-product set over an integer box is the restricted-digit machinery of `mrlylab::press` - the count factors along digit positions and the crop adds nothing. (Proved, read off the definitions.) The lane above starts precisely where this reduction stops: the ball is the simplest shape with no digit structure.

## Where the numbers live

`mrlymath::shape` carries the machinery - `Frac`, `classify`, `regions`, `named`, `crop`, `refine` with its 20-million-cell guard, `census` - with the corner oracle, the partition identities, the diamond closed form `2m(m-1)` and the sponge shell `[0, 26, 1]` pinned by its tests. `lab/rs/crop-counts` prints every table and sweep line above and asserts both identities on each; `lab/rs/circle-crop` prints every line of the circle count, its exponents and its bands, its transfer pass prints the shell's tree, the pattern operator with its certified Perron brackets and minorisation floors, and the gain ladder that turns `Psi` into a product over scales, and its derivation pass prints the frozen-slope alphabet, the fault rates of the derived pattern law against the shell, the centre rates against `1/3`, and the straight-line gain ladder that refutes the frozen gap.