---
title: Beneath a design
lead: The object beneath a design as three slots, accept, place and glue: the memory dial priced by a transfer matrix with `kappa` zero on exactly the non-empty product rules over `19563` live classes, the Collatz carry landed on that dial as a four-state transducer of unbounded radius whose zero-carry sets are the golden and supergolden rules at `3n + 1` and `7n + 1`, and the radix dial that keeps every count, carries the gasket, the dragons and the Koch curve as codes with a twist vector, and loses the fill law the moment a digit turns; the Mobius meter of every width-three rule to `2^30` against its own mass, the memory zeta as a matrix ladder with one pole comb per eigenvalue, and the design census up to similarity and up to affine conjugacy.
figure: research-beneath
slug: beneath
---

A design as [core](core.md) defines it freezes three independent choices at once, and only one of them is visible in the definition. This page names all three and turns the two that carry a parameter.

A design is three slots.

- **Accept.** Which digit words survive. Today: the full shift on the digit set `F`, every word over `F` allowed and no word tested against its neighbours.
- **Place.** Where each word lands. Today: place value at base `base` on `Z^dim`, the word `d_1 d_2 d_3 ...` landing on the point `sum_j d_j base^(-j)`.
- **Glue.** Which words name one point. Never chosen: two words name one point exactly when they land on the same point of the ambient.

Accept and place do not interfere, and the split is exact: the number of accepted words of length `level` is a function of the accept slot alone, and the point set drawn at level `level` is the image of those words under the place slot. (**Proved**, from the definitions: neither the set of accepted words nor its cardinality mentions the place map, and the drawn set is by definition the image.) So the counting side of this tree is carried by accept, with place entering a count only through the contraction ratio and through which words collide; the drawing side is carried entirely by place.

One sentence explains why the counts close. Today's accept slot tests each digit alone, so the accepted words of length `level` are the words over `F` and there are `card F^level` of them, a product of `level` equal factors. (**Proved**, from the definition of the full shift.) That product is the property the two dials below are measured against. The memory dial breaks it in a controlled way and prices the break with a number; the radix dial leaves it untouched and moves only the picture.

Throughout, a digit vector `d` in `{0,1}^dim` is read as the corner integer `c(d) = sum_i d_i 2^i`, axis `i` on bit `i`, so at `dim 2` bit `0` is the column `x` and bit `1` the row `y`. That is the crate's reading too: `mrlymath::bang::universe::corners(dim)` emits the corner vector row first and `corner_index` folds it most significant first, so a crate design's corner integer at `dim 2` is `c = x + 2y`. (**Verified**, `lab/py/memory-census`, pinned cell for cell by the [memory demo](../../site/demos/memory/)'s host test on codes `11` and `13`, which the axis swap exchanges and which are drawn differently.)

## The memory dial

The accept slot is dialled by letting the rule remember. Fix a dimension `dim` and work at base 2, where the alphabet is the `2^dim` digit vectors; a general base replaces `2^dim` by `base^dim` everywhere below with no other change.

A **width-`k` rule** is a set `W` of windows `(d_1, ..., d_k)` of `k` digit vectors. The window integer is `w = sum_(j=1..k) c(d_j) 2^(dim(k-j))`, the first digit of the window most significant, and the rule code has bit `w` set exactly when the window is allowed, so the code lies in `[0, 2^(2^(k dim)))`. A word `d_1 d_2 ... d_level` is read coarsest digit first - `d_1` is the top digit, the level-1 cell - and is **accepted** iff every window of `k` consecutive digits lies in `W`; for `level < k` every word is accepted. Write `N_W(level)` for the number of accepted words of length `level`.

At `k = 1` a window is one digit vector, the window integer is the corner integer, and a word is accepted iff every digit lies in `W`. That is today's design of the same code, and the accepted words of length `level` are exactly the cells at level `level` of `bang dim <dim>, code <code>`. (**Proved**, the two definitions are the same sentence.) The dial therefore extends the catalog rather than replacing it. Past `k = 1` the codes are read the same way: at `dim 1` and `k = 2` the windows `00, 01, 10, 11` carry integers `0, 1, 2, 3`, so code `7` allows the first three and forbids `11`, the golden mean shift; at `k = 3` the eight windows carry `0` through `7` in the order `000, 001, 010, 011, 100, 101, 110, 111`, so code `23` allows exactly `000, 001, 010, 100`, the rule "at most one `1` per window". (**Proved**, arithmetic of the definition.)

### The transfer matrix

Let the states be the `2^(dim(k-1))` words of `k-1` digit vectors, and let `A` be the matrix whose `(x, y)` entry is the number of allowed windows whose first `k-1` digits are `x` and whose last `k-1` digits are `y`. For `k >= 2` a window is determined by that pair, so every entry is `0` or `1`; for `k = 1` there is one state, the empty word, and `A = [card W]`. Then for `level >= k-1`

```
N_W(level) = 1^T A^(level-k+1) 1.
```

**Proved.** A word of length `level >= k-1` is exactly a walk of `level-k+1` edges in that graph: its first `k-1` digits are the start state, each further digit advances the state by dropping the oldest digit and appending the new one, the edge exists exactly when the window it closes is allowed, and a walk reconstructs the word. Summing over start and end states is the pair of all-ones vectors. Write `rho` for [the spectral radius](/wiki/spectral-radius/) of `A`. **Proved:** `rho` is an algebraic integer, being a root of the monic characteristic polynomial of an integer matrix, and it is itself an eigenvalue of `A` with a nonnegative eigenvector, `A` being nonnegative, by Perron-Frobenius ([Perron-Frobenius theorem](https://en.wikipedia.org/wiki/Perron%E2%80%93Frobenius_theorem), and [Seneta 2006](https://doi.org/10.1007/0-387-32792-4) for the Collatz-Wielandt form). The **growth exponent** of the rule is `log_2 rho`. At `k = 1` the matrix is `[card W]`, so the exponent is `log_2 card W`, today's `log(fill)/log(base)`. (**Proved**.) That matrix is the standard object and not a private one. A width-`k` rule is a `(k-1)`-step shift of finite type on the digit alphabet, and passing to windows of `k-1` digits turns it into a `1`-step shift, a vertex shift on exactly the graph above ([Lind and Marcus 1995](https://doi.org/10.1017/CBO9780511626302), Theorem 2.3.2 and Proposition 2.3.9(3), both read at source). **Proved by [Lind and Marcus 1995](https://doi.org/10.1017/CBO9780511626302)**, restated here without a theorem number and not reproved: the growth rate of such a shift is the Perron eigenvalue of its transition matrix. In house and not resting on it: `max_(x,y) (A^n)[x,y] <= 1^T A^n 1 <= S^2 max_(x,y) (A^n)[x,y]` with `S` the number of states, so `lim_level N_W(level)^(1/level) = rho` whenever `rho > 0`. (**Proved**, `lab/py/memory-census`.) That `log_2 rho` is also the Hausdorff dimension per axis of the accepted set is **Conjecture**: it is a growth rate of a word count here, with no measure behind it.

### The coupling

Define the **coupling** of a width-`k` rule, the memory number of `lab/py/memory-census`, as

```
kappa(W) = log_2(card W) / k - log_2 rho,
```

`card W` the allowed windows. A dead rule, `rho = 0`, carries no coupling; the empty rule, `card W = 0`, carries none either, where `mrlynum::memory::kappa` returns `0.0` as a convention and not as a value of the formula, and code `0` is dead at every `(dim, k)`.

**Proved, `kappa >= 0`.** In an accepted word of length `mk` the `m` windows starting at positions `1, k+1, ..., (m-1)k+1` are disjoint, each lies in `W`, and together they are the whole word, so `N_W(mk) <= card W^m`. In the other direction `rho^n = rho(A^n)` is at most the largest row sum of `A^n`, which is at most the sum of all its entries, so `rho^(level-k+1) <= N_W(level)`. Combining at `level = mk` and letting `m` grow gives `k log_2 rho <= log_2(card W)`. **Proved, `kappa = 0` on non-empty products.** If `W = G^k` for a non-empty subset `G` of the alphabet - the window allowed exactly when each of its digits lies in `G` - then the accepted words are exactly the words over `G`, so `N_W(level) = card G^level`, `rho = card G` and `card W = card G^k`, whence `kappa = log_2(card G^k)/k - log_2 card G = 0`. Every memoryless design of a non-empty digit set is such a product, so today's whole catalog sits at coupling zero.

`kappa` is a scalar saying how much of the digit independence a rule spends, and today's catalog spends none of it. **Conjecture.** `kappa = 0` only on non-empty products, at every `(dim, base, k)`, so the coupling vanishes exactly on the memoryless designs and on nothing else. **Verified** across the whole census at base 2 for `(dim, k)` in `{(1,1), (1,2), (1,3), (1,4), (2,1), (2,2)}`: `kappa = 0` holds on exactly the non-empty product classes, `2` of them at every `(1,k)` and `5` at every `(2,k)`, with `0` counterexamples over `19563` live classes. The test is exact and not numeric - `kappa = 0` iff the minimal polynomial of `rho` divides `x^k - card W`, checked by integer polynomial division (`lab/py/memory-census`).

**Verified, for `k >= 2`.** The largest `kappa` in that census is attained at `rho = 1`, by the largest rule of zero entropy, and the maximiser is not unique: the tie has `1, 3, 4, 3` classes and its least codes are `log_2(3)/2 = 0.792481` on code `11` at `(1,2)`, `log_2(6)/3 = 0.861654` on code `175` at `(1,3)`, `log_2(13)/4 = 0.925110` on code `49071` at `(1,4)` and `log_2(10)/2 = 1.660964` on code `36079` at `(2,2)`. At `k = 1` every live rule is a product, so `kappa` is identically `0` and the maximum is attained on every live class, the full rule at `rho = 2^dim` included (`lab/py/memory-census`). **Verified.** The window budget of the maximiser reads `2, 3, 6, 13` at `dim 1` for `k = 1..4` and `4, 10` at `dim 2` (`lab/py/memory-census`, column `kappa_max_windows`), and the largest `card W` a live rule of `rho = 1` allows reads `1, 3, 6, 13` and `1, 10` (column `rho1_windows`). A rule may allow that many windows and still accept only subexponentially many words, never finitely many: code `11` at `(1,2)` allows `00, 01, 11`, so it accepts every `0^a 1^b` and `N_W(level) = level + 1`. What `1, 3, 6, 13` continues to, and whether it has a closed form, is open here.

### The census

**Proved, width `k` in dimension `dim` is a subset of the `k dim`-cube.** A window is an element of `({0,1}^dim)^k = {0,1}^(k dim)`, so a width-`k` rule in dimension `dim` is a subset of the corners of the `k dim`-cube and nothing else. The raw census is therefore already printed: `2^(2^(k dim))` rules, which is [core](core.md)'s design count with `dim` replaced by `k dim`. What does not transport is the quotient. Cube symmetry acts on the `k` windows diagonally, so the group is `B_dim` of order `2^dim dim!`, not `B_(k dim)` of order `2^(k dim) (k dim)!`, and the class count is a [Burnside](/wiki/burnsides-lemma/) sum over the smaller group. The raw count is inherited; the classification is a new census.

The right group is `G_(dim,k)`: the signed permutations `B_dim` applied by the *same* element to every digit of a window, together with window reversal `(d_1, ..., d_k) -> (d_k, ..., d_1)`. Both preserve `N_W(level)` at every `level` - a diagonal `B_dim` element relabels the alphabet and so conjugates `A` by a permutation matrix, and reversal is a bijection of accepted words that transposes `A`, and `A` and `A^T` share a characteristic polynomial. (**Proved**, `lab/py/memory-census`.) Its order is `2^(dim+1) dim!` for `k >= 2`, reversal commuting with every diagonal element and equalling none of them once a window has two digits; at `k = 1` reversal is trivial and the order is `2^dim dim!`. (**Proved**, `lab/py/memory-census`.) Whether reversal belongs in the group is a choice, so both quotients are printed. Every width-`k` rule at base 2 is enumerated below.

| `(dim, k)` | rules | classes under `G_(dim,k)` | classes under diagonal `B_dim` alone | dead classes, `rho = 0` | distinct minimal polynomials of `rho` |
|---|---|---|---|---|---|
| `(1,1)` | 4 | 3 | 3 | 1 | 3 |
| `(1,2)` | 16 | 9 | 10 | 2 | 4 |
| `(1,3)` | 256 | 88 | 136 | 13 | 10 |
| `(1,4)` | 65536 | 16960 | 32896 | 2093 | 177 |
| `(2,1)` | 16 | 6 | 6 | 1 | 5 |
| `(2,2)` | 65536 | 4660 | 8548 | 53 | 185 |

(**Verified** by `lab/py/memory-census`: a direct orbit walk over every code agreeing with an independent Burnside average on every row, and the characteristic polynomials taken by exact integer Faddeev-LeVerrier and factored over `Q` in PARI. The `k = 1` rows are today's design census, `3` at `dim 1` and `6` at `dim 2`, the two groups agreeing there because reversal is trivial; those are A000616 at `1` and `2`. The live classes total `19563`.)

**Verified.** Read against [A000616](https://oeis.org/A000616) at `k dim`, the design census of the `k dim`-cube under the full group `B_(k dim)`, the class count of a width-`k` rule is larger by the factors `1, 3/2, 4, 42.19` at `dim 1` for `k = 1..4` and `1, 11.59` at `dim 2`, and equal at `k = 1`, where reversal is trivial and the two censuses coincide (`lab/py/memory-census`). **Proved.** `G_(1,4) < G_(2,2) < B_4` as permutation groups of the `4`-cube: flipping all four bits is the diagonal `B_2` element that flips both axes, and the width-`4` window reversal is the `(2,2)` block swap composed with the diagonal axis swap. So one cube carries three nested groups, and its class counts nest the other way, `16960 > 4660 > 402`, the last of them A000616 at `4` (`lab/py/memory-census`).

**Proved.** At `dim 1` with no reversal the class count is `2^(2^k - 1) + 2^(2^(k-1) - 1)`: the digit flip acts on the `2^k` windows as `w -> 2^k - 1 - w`, in `2^(k-1)` two-cycles, so Burnside on the group of order two gives `(2^(2^k) + 2^(2^(k-1)))/2`. The closed form reproduces `3, 10, 136, 32896` (`lab/py/memory-census`).

**Proved.** Under `G_(1,k)` itself the class count closes on two parities, `a(2m) = 2^(2^(2m)-2) + 2^(2^(2m-1)-2) + 2^(2^(2m-1)+2^(m-1)-1)` for `m >= 1` and `a(2m+1) = 2^(2^(2m+1)-2) + 2^(2^(2m)-1) + 2^(2^(2m)+2^m-2)` for `m >= 0`: Burnside over the order-4 group, where the digit flip fixes no window, reversal fixes the `2^ceil(k/2)` palindromes, and flip-reversal fixes the `2^(k/2)` antipalindromes at even `k` and none at odd `k`. The form carries `3, 9, 88, 16960` on to a `616`-digit term at `k = 11` (`lab/py/memory-census`, verb `burnside`, the cycle index and the closed form agreeing at `k = 1..11`).

### The famous constants are one notch in

The four named algebraic integers appear at the first two notches of the dial, each on the least code of its class.

| root | minimal polynomial | `rho` | least code at `dim 1` | least code at `(2,2)` |
|---|---|---|---|---|
| golden | `x^2 - x - 1` | `1.618033988749` | `7` at `k = 2` | `19` |
| supergolden | `x^3 - x^2 - 1` | `1.465571231876` | `23` at `k = 3` | `323` |
| plastic | `x^3 - x - 1` | `1.324717957244` | `54` at `k = 3` | `326` |
| tribonacci | `x^3 - x^2 - x - 1` | `1.839286755214` | `127` at `k = 3` | `327` |

(**Verified** by `lab/py/memory-census`, PARI `factor` and `polrootsreal` on the exact characteristic polynomial, `rho` truncated to 12 digits. All four recur in dimension two at width two, on the codes in the last column, so they belong to the dial and not to dimension one.)

**Proved.** Every Perron root occurring at width `k` occurs again at width `k + 1`: the rule `W' = {(d_1 ... d_(k+1)) : (d_1 ... d_k) in W and (d_2 ... d_(k+1)) in W}` accepts the same words of length `k + 1` and above, which is all `rho` needs; at `level = k` exactly the two part company, `W'` having no window there and accepting every word. **Verified** with `0` missing on all four tested steps (`lab/py/memory-census`). **Verified.** A Perron root that fails to dominate its conjugates strictly is always `p(x^m)` for some `m >= 2` with `p` the minimal polynomial of a strict root already in the census: the non-strict roots number `12` of the `177` at `(1,4)` and `5` of the `185` at `(2,2)`, and `x^4 - x^2 - 1` and `x^6 - x^3 - 1` are the golden ratio's square and cube roots (`lab/py/memory-census`; strictness is decided numerically, PARI complex roots against a `1e-20` gap). The reason is not proved here. A nonnegative matrix has its peripheral spectrum equal to `rho` times roots of unity, but these transfer matrices are reducible in general - every dead rule is nilpotent - and the step from a peripheral eigenvalue to the minimal polynomial of `rho` being a polynomial in `x^m` needs the conjugate set of `rho` to be stable under `x -> zeta x`, which is nowhere argued. **Verified.** Every root of a live rule is either `1` or a radical of a strict Perron number in `(1, 2^dim]`; the dead rules carry `rho = 0` and lie outside that statement, `1, 2, 13, 2093` classes at `dim 1` and `1, 53` at `dim 2` (`lab/py/memory-census`).

**Verified.** None of `3, 9, 88, 16960`, `6, 4660`, `3, 4, 10, 177` or `3, 6, 23, 431` appears in the local OEIS dump, each grepped as its own comma-delimited string; `3, 10, 136, 32896, 2147516416` greps [A055708](https://oeis.org/A055708), [A056006](https://oeis.org/A056006) and [A191363](https://oeis.org/A191363), three lists of integers with a `sigma` property that agree with it only through the closed form `2^(m-1)(2^m + 1)` at `m = 2^(k-1)`, and none of them is this census (`lab/py/memory-census`). Absence is absence from that dump, which is not the same as absence from OEIS.

### What the dial buys

At `k = 1` the growth exponent is `log_2` of an integer between `1` and `base^dim`, so at fixed `(dim, base)` the whole catalog has at most `base^dim` distinct growth exponents, the dead rule carrying none. (**Proved**, the matrix is `[card W]`.) At width `k` it is `log_2` of an algebraic integer, the spectral radius of a nonnegative integer matrix, and the supply grows fast: the distinct minimal polynomials of `rho` number `3, 4, 10, 177` at `dim 1` for `k = 1..4` and `5, 185` at `dim 2` for `k = 1, 2`, against `3, 6, 23, 431` and `5, 333` distinct characteristic polynomials. (**Verified**, `lab/py/memory-census`.) Both counts carry a structure lemma. **Proved.** At `dim 1` and `k >= 2` every [transfer matrix](/wiki/transfer-matrix/) has determinant in `{-1, 0, 1}`, so the constant term of every characteristic polynomial is `0`, `1` or `-1`: rows `s` and `s + 2^(k-2)` are both supported on the columns `2s` and `2s+1` taken modulo `2^(k-1)`, those column pairs partition the columns as `s` runs over `0..2^(k-2)-1`, and the matrix is therefore a row permutation of a block diagonal matrix with `2^(k-2)` blocks of size `2 x 2` over `{0,1}`, whose determinant is a signed product of `2 x 2` determinants of `0-1` matrices (`lab/py/memory-census`, verb `lemmas`, over every rule at `k = 2, 3, 4`). **Proved.** Distinct minimal polynomials of `rho` are distinct `rho`, so `3, 4, 10, 177` counts growth rates and not only polynomials: every conjugate of `rho(W)` is a root of the characteristic polynomial of `A_W` and so an eigenvalue of `A_W`, hence at most `rho(W)` in modulus, so two conjugate Perron roots are equal in modulus and, both being nonnegative, equal (`lab/py/memory-census`, verb `lemmas`, over all `463` characteristic polynomials at `dim 1` and `k = 1..4`). **Conjecture.** The set of growth exponents attainable at fixed `(dim, base)` as `k` grows becomes dense in `[0, dim]`, the attainable `rho` being exactly the Perron numbers below `base^dim`; the census reaches `k = 4` and settles nothing past it.

### What the dial does not buy

**Proved.** Memory does not leave the lattice class. A width-`k` rule still contracts by the single ratio `1/base` at every level. **Proved:** the counting series `sum_level N_W(level) x^level` is rational with denominator `det(I - x A)`, since `N_W(level) = 1^T A^(level-k+1) 1` and `sum_n A^n x^n = (I - x A)^(-1)`. This page takes the string equation of such a rule to be that denominator at `x = base^(-s)`, `det(I - base^(-s) A) = 0`, the graph-directed replacement of the scalar Moran equation `card F base^(-s) = 1` of [dimensions](dimensions.md), "The string of a design"; that replacement is a definition made here, carried by no source on this tree, and nothing below rests on more than its algebra. Its solutions are `base^(-s) lambda = 1` for a nonzero eigenvalue `lambda` of `A`, that is `s = log_base|lambda| + i(arg lambda + 2 pi m)/log base` for `m` in `Z`. Whatever `A` is, they sit on finitely many vertical lines, one per eigenvalue modulus, and the whole solution set is invariant under `s -> s + 2 pi i / log base`, the period the memoryless case already has, so each line carries a finite union of arithmetic progressions of that gap. The gap on a line can be smaller: at `(1,2)` code `6` allows only `01` and `10`, `A = [[0,1],[1,0]]` has eigenvalues `1` and `-1`, and on the line `Re s = 0` the solutions are spaced `pi / log base` (`lab/py/memory-census`). Leaving the lattice class needs unequal ratios inside one level, which is not this dial.

**Proved by [Coons 2010](https://doi.org/10.5802/jtnb.718), restated here and not reproved.** A width-`k` rule is a finite automaton over the digit alphabet with `base^(dim(k-1))` states reading the address once, so every sequence it defines is automatic in that base. That paper carries Theorem 2.3, credited to Allouche: `(mu(n))` is automatic in no base, because `1/zeta(s)` has `asymp T log T` poles up to height `T` and those cannot sit on finitely many left semi-lattices, and its Theorem 3.1 carries the same conclusion from automatic to regular sequences. [Mullner 2017](https://doi.org/10.1215/00127094-2017-0024) proves that automatic sequences fulfil the Sarnak conjecture. So [the Mobius function](/wiki/mobius-function/) is beyond every finite memory at every width, and no dialling of this slot reaches it.

### The carry of a Collatz step

A Collatz step in base 2 splits into a skeleton over `GF(2)` and a carry, and only the skeleton is a rule. Read the digit word of an integer `n` least significant digit first, so `2n` is a shift towards the higher digits. For every `n`, `3n + 1 = n + 2n + 1`, and the ripple adder gives digit `i` of the sum as `s_i = n_i + n_(i-1) + c_i` over `GF(2)` with `n_(-1) = 0`, `c_0 = 1` and `c_(i+1) = MAJ(n_i, n_(i-1), c_i)`. Dropping the carry leaves the skeleton `n xor 2n xor 1`, and the substitution `M = 2n + 1` clears its constant: `M xor 2M = 2 (n xor 2n xor 1) + 1` for every `n`, so in the `M` coordinate the carry-free step is `M -> M xor 2M`, whose digit `i` is `M_i + M_(i-1)` and nothing else. That is elementary rule 60 read least significant digit first, mirroring to rule 102 in the most significant digit first render, and [automata](automata.md), section 4, names the design its space-time diagram from one seed draws, `bang dim 2, code 13`. (**Proved**; **Verified** with `0` mismatches on all three identities over every `n < 2^18`, `lab/rs/carry-skeleton`.) Every affine map `n -> a n + b` splits into a skeleton and a carry the same way, by the definition of the ripple adder, so the skeleton on its own is not about this map.

**Proved.** The carry is a four-state Mealy transducer and not a rule of any width. Its state is `(n_(i-1), c_i)`, it reads one digit per tick from the least significant end, its output digit is `n_i + n_(i-1) + c_i`, and its carry alphabet is `{0, 1}` because a column of the sum reads at most `1 + 1 + 1`. Its dependence radius is unbounded. Fix `level`, let `u` carry digits `u_0 = 1` and `u_j = 1 - (j mod 2)` for `1 <= j < level`, and let `v` differ from `u` in digit `0` alone. Then `c_1 = MAJ(u_0, 0, 1) = u_0` and `c_2 = MAJ(u_1, u_0, u_0) = u_0`, and `u_j != u_(j-1)` for `2 <= j < level` makes every later majority propagate its incoming carry, so `c_i = u_0` for `1 <= i <= level`: two inputs differing in one digit give `3u + 1` and `3v + 1` differing in every digit from `2` to `level`. (**Verified** at every `level 2..40`, `lab/rs/carry-skeleton`.) A MrlyMath automaton is a triple `(dim, mask, kind)` whose mask is a **finite** set of offsets ([automata](automata.md), section 7), so no rung of that ladder computes this step at any level. This dial grades acceptors and not transducers, so what lands on it here is not the step but the set of words on which the step fires no carry, read next.

The set where no carry fires is a rule of this dial, at every odd multiplier. Write `m` for an odd multiplier, `supp m` for the exponents of the `1` digits of `m` and `deg m` for the largest of them, so `m n + 1` adds the shifts `n << j` for `j in supp m` and the constant `1`. Digit `0` of that sum reads `n_0 + 1` and digit `i >= 1` reads `sum_(j in supp m) n_(i-j)`, so no carry fires exactly when `n` is even and no two `1` digits of `n` sit at a distance in the difference set `{|j - j'| : j, j' in supp m}`. Every such distance is at most `deg m`, so that condition is a width-`(deg m + 1)` rule `W` of this dial and nothing wider, and the zero-carry set of `m n + 1` is exactly the even integers whose digit word `W` accepts. (**Proved**; **Verified** as a set equality with `0` mismatches below `2^16` at `m = 3, 5, 7, 9, 11, 15`, `lab/rs/carry-skeleton`.) The rule depends on the difference set alone, so `m = 11` and `m = 15` carry one rule between them.

| `m` | `supp m` | difference set | `k` | code | `card W` | `rho` | `kappa` |
|---|---|---|---|---|---|---|---|
| 3 | `0, 1` | `1` | 2 | `7` | 3 | `1.618034` | `0.098239` |
| 5 | `0, 2` | `2` | 3 | `95` | 6 | `1.618034` | `0.167412` |
| 7 | `0, 1, 2` | `1, 2` | 3 | `23` | 4 | `1.465571` | `0.115204` |
| 9 | `0, 3` | `3` | 4 | `22015` | 12 | `1.618034` | `0.201999` |
| 11 | `0, 1, 3` | `1, 2, 3` | 4 | `279` | 5 | `1.380278` | `0.115524` |

(**Verified**, `lab/rs/carry-skeleton`: every code is rebuilt from the difference set under this page's own convention, which is `mrlynum::memory::Rule::new(1, k, code)` with `Rule::allowed(w)` true when bit `w` of the code is set, and `rho` and `kappa` are `mrlynum::memory::perron` and `mrlynum::memory::kappa` on the rule so built. A word shorter than `k` holds no window, so an integer is padded with leading zeros past the width before the equality is tested; a leading zero closes no forbidden pair.)

Two of those codes are the ones `### The famous constants are one notch in` already names. `m = 3` gives code `7`, the golden rule, and `m = 7` gives code `23`, the supergolden rule, and `mrlynum::memory::kappa` reads `0.098239` and `0.115204` on them, the two couplings `### The memory meter` prints. The multiplier route reaches them from the difference set of `supp m` and shares no code with the census that first printed them. (**Verified**, `lab/rs/carry-skeleton`.)

**Proved, the carry fires with density exactly `1/2`.** On uniform independent digits the state `(n_(i-1), c_i)` is a Markov chain on `{(0,0), (0,1), (1,0), (1,1)}`, the next digit `c` taking the state `(prev, carry)` to `(c, MAJ(c, prev, carry))` with probability `1/2` for each of `c = 0, 1`. Its balance equations are `2 pi_(0,0) = pi_(0,0) + pi_(0,1) + pi_(1,0)`, `2 pi_(0,1) = pi_(1,1)`, `2 pi_(1,0) = pi_(0,0)` and `2 pi_(1,1) = pi_(0,1) + pi_(1,0) + pi_(1,1)`, solved by `(1/3, 1/6, 1/6, 1/3)` in that order and by nothing else up to scale; the chain is irreducible and `(0,0)` carries a self-loop, so it is aperiodic and the digit-wise law converges to that vector. The carry-on mass is `pi_(0,1) + pi_(1,1) = 1/6 + 1/3 = 1/2`. (**Verified**: the mean of `d_loc(n) = popcount((3n + 1) xor (n xor 2n xor 1))` over every `n < 2^level` reads `level/2 + 1/3 - (-1)^level/(3 * 2^level)`, asserted as an exact integer identity with residual `0` at every `level 8..22`, and `mean/level` falls `0.541504, 0.527771, 0.520833, 0.515152` at `level 8, 12, 16, 22`, `lab/rs/carry-skeleton`.)

**Proved, the carry is the whole of the growth.** Let `T_free(n) = n/2` for even `n` and `(n xor 2n xor 1)/2` for odd `n`, the step with the ripple add replaced by the carry-save add. For odd `n` of `level` digits, `n xor 2n` has digit `level` equal to `n_(level-1) = 1` and digit `0` equal to `n_0 = 1`, so `n xor 2n xor 1` has exactly `level + 1` digits and is even and `T_free(n)` has exactly `level`; for even `n` the digit count drops by one. The digit count never rises, so every orbit stays in a finite set and is eventually periodic, and a cycle has constant digit count and therefore holds only odd values. Read an odd `n` as `f` in `GF(2)[x]` with `f(0) = 1`: then `T_free` is `A(f) = ((1 + x) f + 1)/x`, affine over `GF(2)[x, x^(-1)]` with multiplier `a = (1 + x)/x` and offset `b = 1/x`, and `a + 1 = b`, so `A(f) + 1 = a (f + 1)` and `A^t(f) + 1 = a^t (f + 1)` at every iterate count `t`. Then `A^t(f) = f` forces `(a^t + 1)(f + 1) = 0` in a domain, and `a^t = 1` would need `(1 + x)^t = x^t`, false at every `t >= 1` by the constant term, so `f = 1`. **`T_free` has exactly one cycle on the positive integers, `{1}`, and every orbit reaches it.** (**Verified**, `0` digit-count increases and `0` values failing to reach `1` over every `n < 2^20`, `lab/rs/carry-skeleton`.) The carry-free odd step gains one digit and the halving takes it back, so the carry-free drift is exactly zero while the true odd step `n -> (3n + 1)/2` multiplies by more than `3/2` and the digit count grows: the skeleton is a digit shuffle and every digit of growth is carry.

**Refuted.** `d_loc` is no function of popcount, of the longest run of `1` digits, of `v_2`, of the digit count, nor of all four read at once: `19` and `25` agree on all four and carry `d_loc` `3` and `4`, and the unordered pairs agreeing on all four and disagreeing on `d_loc` number `9331881` below `2^16` (`lab/rs/carry-skeleton`, one row per statistic with its own least clashing pair). The carry is the whole word and no scalar summary of it. [Cellular automata](/wiki/cellular-automaton/) for the same map are cited here and never claimed: [Bruschi 2005](https://arxiv.org/abs/nlin/0502061) gives two automata mimicking the map and [Chen 2013](https://arxiv.org/abs/1301.3125) gives three, in bases 2, 3 and 4; [Kari 2012](https://doi.org/10.1007/978-3-642-31653-1_5) pairs cellular automata with the Collatz conjecture and powers of `3/2` in its title, its text sitting behind the publisher. A carry count is read off the pair (map, base), the way `kappa` is read off the pair (rule, base) everywhere else on this page.

**Proved.** Restricted to the two carry-on states the transfer matrix is `[[0, 1], [1, 1]]`, whose characteristic polynomial `x^2 - x - 1` is the golden rule's own, so a carry-on run survives one further digit at rate `phi/2`. **Conjecture.** The longest carry run over `level` digits grows like `log_(2/phi) level`, base `2/phi = sqrt 5 - 1 = 1.236068`. The constant is not established here: sampled mean depths `6.338, 12.116, 18.462, 24.967, 31.481, 38.029` at `level 16, 64, 256, 1024, 4096, 16384` over `200000` uniform digit strings each, standard error at most `0.014` per mean, give increments per quadrupling `5.778, 6.346, 6.504, 6.514, 6.548` against the predicted `6.541119`, rising towards it from below while the offset `mean - log_(2/phi) level` settles at `-7.74, -7.77, -7.76` over the last three rows, with no exponent fitted (`lab/rs/carry-skeleton`). **Proved.** The worst case is `level + 1` digits of carry, attained at `n = 2^level - 1`, where every majority carries at least two `1`s. (**Verified** at `level 1, 2, 4, 8, 16, 32, 40`.)

The falsification of this whole subsection is recomputation from the other end. `lab/rs/carry-skeleton` builds every code from the difference set of `supp m` rather than reading one off this page, reaches `rho` and `kappa` through `mrlynum::memory` alone, and asserts each identity as an exhaustive set equality, so a wrong code, a wrong coupling, a wrong density or a wrong cycle count shows as a mismatch count above zero and not as a disagreement of readings.

### The memory meter

The section above says only that the Mobius function is beyond every rule on this dial. The accepted sets are sets of integers, so the question can be turned around and asked of them. Write `S_W` for the integers whose minimal base-2 word the rule accepts, coarsest digit first, no leading zero and `0` excluded, `A_W(x)` for `card(S_W intersect [1, x])` and `M_W(x)` for the sum of `mu(n)` over `n` in `S_W` with `n <= x`. [Mullner 2017](https://doi.org/10.1215/00127094-2017-0024) gives `M_W(x) = o(x)` for every rule, the accepted set being automatic, and gives no rate at all. What is read here is the meter against the set's own mass rather than against `x`, which is the reading [mobius](mobius.md) takes of the memoryless designs.

Two readings of a rule are kept apart before any number is printed. `rho` and `kappa` belong to the word language; `A_W` and `M_W` belong to the integer set, and the minimal word of `n` carries no leading zero. Prepending one zero adds exactly one window, `(0, d_1, ..., d_(k-1))`, and removes none; call a rule **zero-closed** when that changes no membership. **Verified.** The zero-closed codes number `3` of `4` at `k = 1`, `8` of `16` at `k = 2` and `64` of `256` at `k = 3`, and are exactly the codes allowing the digit `0` together with the empty code, the codes allowing `01`, and the codes allowing both `010` and `011`, asserted code for code below `2^20` (`lab/rs/memory-meter`). Allowing any number of zeros is the stronger test, and there the word language agrees with the integer set only when `000`, `001`, `010` and `011` are all allowed. **Verified.** That is `2` of `4`, `4` of `16` and `16` of `256` codes, tested on every word to length `14`, so at width three the two readings part company on `240` of `256` (`lab/rs/memory-meter`). Every number below is the integer reading, and `k = 3` code `5` is the warning: its word language grows on the self-loop `000` and carries `rho = 1`, while its integer set holds three elements up to `2^30`.

The whole dial is read at once. **Verified.** `A_W(x)` and `M_W(x)` for all `276` rules at `(dim, k) = (1,1), (1,2), (1,3)`, at the `89` phases `x = floor(2^(level + j/4))` with `level 8..30` and `j = 0..3`, the three points past `2^30` dropped, by one ascending pass over `n <= 2^30` carrying the bitmask of the `2^3` windows the word of `n` contains (`lab/rs/memory-meter`). The controls are pinned by assertion and not by eye. The full line, `k = 1` code `3`, accepts every integer, so its meter is [the Mertens function](/wiki/mertens-function/) and reads `-1, 1, 2, -23, -48, 212, 1037, 1928` at `10^1..10^8`, which is [A084237](https://oeis.org/A084237). The memoryless base-3 designs of [mobius](mobius.md) are recomputed from the same sieve and read `(M, max abs M) = (11, 105)`, `(149, 173)` and `(-30, 312)` for digits `{0,1}` at `level 14, 16, 18` and `(-1461, 1582)` for `{1,2}` at `level 18`, those four pairs read at source in `lab/py/design-meter`, which computes them and cites `lab/rs/mobius-designs` as their census; digits `{0,2}` at `level 20` wants `3^20`, past the sweep, and is printed unpinned. The window-profile pass agrees with a direct digit recount on all `276` rules below `2^20` and with the crate's own acceptance test below `2^12`.

Three rules are named before any spread is read. **Verified.** The golden rule, code `7` at `k = 2`, forbidding the window `11`, opens exactly the fibbinary integers [A003714](https://oeis.org/A003714) without its zero and its mass up to `2^level` is a Fibonacci number, `2178309` up to `2^30`; its digit flip, code `14`, forbidding `00`, carries the same `rho = 1.618033989` and opens `3524576`; code `11`, forbidding `10`, opens exactly the Mersenne numbers [A000225](https://oeis.org/A000225) without its zero, one element per level and `30` up to `2^30` (`lab/rs/memory-meter`).

No exponent is fitted anywhere below, and every ratio is a reading at a named phase. What is printed per rule and phase is the **normalised peak**, `max abs M_W(t)/sqrt(A_W(x))` over `t <= x`, which is `1` when the meter is the square root of its own mass. The census is the `53` rules of all three widths holding at least `10^4` integers up to `2^30`, a floor fixed before any reading, because a rule of thirty elements has a ratio and not a meter. **Verified.** At phase `30.00` the full line reads `A = 1073741824`, `M = -10374` and `max abs M = 11173`, so `M/sqrt(A) = -0.316589` and the normalised peak is `0.340973`; over the census that peak spans `[0.293624, 1.239625]`, least on `k = 3` code `125` and largest on `k = 3` code `127` (`lab/rs/memory-meter`). **Verified.** Over all `89` phases the same quantity spans `[0.500000, 2.169240]`, the top a four-way tie on `k = 3` codes `232`, `233`, `234` and `235` at phase `16.75`, so the last-phase leader and the sweep-wide leader are different rules and no one rule is the dial's widest excursion (`lab/rs/memory-meter`). The golden rule, `kappa = 0.098239`, reads `0.485125` on its `2178309` elements at phase `30.00`, and the three named width-3 least codes read `0.731125` on the supergolden code `23` at `kappa = 0.115204`, `0.677943` on the plastic code `54` at `kappa = 0.260981` and `1.239625` on the tribonacci code `127` at `kappa = 0.056639`.

**Verified.** Read against the full line at the same phase, which needs neither a grid nor a band, the factor of one normalised peak over the other runs `[0.861136, 3.635552]` at phase `30.00` over the census and reaches `6.375774` on `k = 3` code `190` at phase `12.75` over all phases (`lab/rs/memory-meter`). That is the instrument the rest of this subsection is read with.

The coupling orders none of it. **Verified.** Grouped by `kappa` over the census at phase `30.00`, the mean normalised peak reads `0.340973` on `kappa = 0`, whose three rules are the full line under its three codes, then `0.622171` on `6` rules, `0.581446` on `14`, `0.644840` on `12` and `0.645966` on `18` for the bands `[10^-9, 0.1)`, `[0.1, 0.2)`, `[0.2, 0.3)` and `[0.3, 0.5)`; restricted to `k = 3` the same bands read `0.340973, 0.698386, 0.581446, 0.644840, 0.645966` on populations `1, 4, 14, 12, 18` (`lab/rs/memory-meter`). Every band of positive coupling sits above the `kappa = 0` band, and among the positive bands the means are not monotone in `kappa`, so memory costs the meter something and how much is not a function of how much memory.

The falsification of the whole reading is a rule whose normalised meter leaves the full line's own band at every phase, and it fires. **Verified.** The full line's peak runs `[0.272410, 0.500000]` over the grid, and five census rules never enter that interval at any phase where they hold `10^4` elements, all of them above it: `k = 3` codes `159`, `182`, `190`, `218` and `250`, holding `211116`, `13607`, `31535`, `59860` and `4126645` integers (`lab/rs/memory-meter`). The band is weak evidence on its own, because its ceiling is the grid's first point and not a property of the full line. **Verified.** `max abs M(t)/sqrt(x)` reads `0.500000` at `x = 256`, where the grid starts, and below the grid it reads `1.000000` at `x = 1`, `0.894427` at `5`, `0.832050` at `13`, `0.718421` at `31` and `0.565685` at `200`, so starting the grid one level lower moves the ceiling and with it the list of rules outside (`lab/rs/memory-meter`). What carries the five instead is the same-phase factor above, which needs no grid.

**Verified.** Sixteen of the `53` census rules attain their sweep-wide normalised peak in the last quarter of the phases, from `24.75` on, so most of the dial peaked earlier and is not growing at the end of the sweep (`lab/rs/memory-meter`). The monotone test beside it, a rule of at least `1000` elements whose ratio rises at every one of the last eight phases, is empty at every width, but it asks `max abs M_W` to grow about `9%` per quarter-level across two whole levels, so the late-peak count is the informative statistic and the empty answer is not.

One coincidence earns a line because it says the mass is not the set. **Verified.** Code `14` at `k = 2`, forbidding `00`, and code `126` at `k = 3`, forbidding `000` and `111`, hold equally many integers, `28655` up to `2^20` and `3524576` up to `2^30`, and carry the same `rho = 1.618033989`, but they are different sets: they share `1077` of those `28655`, the symmetric difference is `55156`, and `4` is the least integer the second holds and the first does not. Their meters read `-466` and `435` and their normalised peaks `0.454355` and `0.594444` at phase `30.00` (`lab/rs/memory-meter`).

What this says about the square-root conjecture of [mobius](mobius.md) is bounded, and is said as such. The question the dial puts is whether memory keeps, beats or loses the memoryless meter, and as far as the ratios go it keeps it up to a bounded factor: the sweep-wide maximum of every census rule lies in `[0.500000, 2.169240]`, so no rule climbs off the square-root scale, while the same-phase factor against the full line runs `[0.861136, 3.635552]` at phase `30.00` and tops at `6.375774` over the whole sweep, so a rule may beat the full line at a phase and may lose to it by a factor under seven, and none does more. **Verified** at finite depth, `2^30` and `89` phases, with no exponent fitted (`lab/rs/memory-meter`). **Conjecture.** Every width-`k` rule at `dim 1`, base `2`, with `rho > 1` has `M_W(x) = O(A_W(x)^(1/2 + eps))` for every `eps > 0`. A band at finite depth is not a rate and nothing here bounds the constant, so [Mullner 2017](https://doi.org/10.1215/00127094-2017-0024)'s `o(x)` with no rate is still the only theorem standing behind it.

### The memory zeta

`### What the dial does not buy` proves that `det(I - x A)` is the denominator of the counting series and then names `det(I - base^(-s) A) = 0` the string equation of a rule, the Moran replacement, a naming made there and carried by no source. The same polynomial does more than count. `S_W` is a set of integers, so it has a Dirichlet series `zeta_W(s) = sum_(n in S_W) n^(-s)`, and that series continues to the whole plane with a pole set contained in the solution set of the string equation shifted by whole `m >= 0`. Throughout, `S_W` is read off the minimal string at base `base` with no leading zero, as `### The memory meter` reads it, and a word shorter than `k` holds no window and is accepted, so every integer below `base^(k-1)` with a nonzero leading digit sits in `S_W` whatever the rule forbids; every value below depends on that convention. `A` is the transfer matrix of `### The transfer matrix`, and the ladder indexes by the arriving state, so it runs on `A` transposed, which has the same spectrum.

**Proved.** Write `E_j(w)` for the vector whose entry `u` sums `n^(-w)` over the accepted words of exactly `j` digits ending in the state `u`, and `G_P = sum_(j >= P) E_j`. An accepted word of more than `k-1` digits is `base m + a` with the window closing on `a` allowed, so expanding `(base m + a)^(-w)` binomially and collecting by arriving state gives `E_(j+1)(w) = sum_(l >= 0) binom(-w,l) base^(-w-l) Gamma_l E_j(w+l)` with `Gamma_l(u',u) = sum a^l` over the letters `a` carrying `u` to `u'`, and `Gamma_0 = A^T`. Summing `j >= P` gives `(I - base^(-w) A^T) G_P(w) = E_P(w) + sum_(l >= 1) binom(-w,l) base^(-w-l) Gamma_l G_P(w+l)`, and `zeta_W(w) = 1^T D_(P-1)(w) + 1^T G_P(w)` for the Dirichlet polynomial `D_(P-1)` over the accepted words of at most `P-1` digits. That is the scalar recursion of [zeta](zeta.md) with the transfer matrix where `card F` stood, and it is the digit-splitting mechanism of [Allouche, Mendes France and Peyriere 2000](https://doi.org/10.1006/jnth.1999.2487) applied to this alphabet. Every level of the walk divides by `det(I - base^(-w) A)`, so the poles of `zeta_W` lie where `base^(-s) lambda = base^m` for a nonzero eigenvalue `lambda` of `A` and a whole `m >= 0`, and nowhere else. That is containment and not equality: which of those points carries a nonvanishing residue is a separate question, settled below for six teeth at `m = 0` on one rule and open everywhere else.

The abscissa is the growth exponent and not the window budget. **Proved:** the tail obeys `sum_(j >= P) E_j(sigma) <= base^(-(P-1)sigma) (I - base^(-sigma) A^T)^(-1) c_P` entrywise, with `c_P` the per-state count of accepted words of `P` digits with a nonzero leading digit, and the inverse is the Neumann series exactly when `base^(-sigma) rho < 1`. So the series converges absolutely on `Re s > log_base rho` and the abscissa is the growth exponent of `### The transfer matrix`, which by the definition of `### The coupling` sits `kappa` below the window budget `log_base(card W)/k`. At code `7` it is `0.6942419136306174`, the exact Perron root read through `mrlynum::memory::perron` and not off any enclosure (`mrlynum::automaton`).

The pole set is a comb per eigenvalue and the combs interleave. **Verified.** At code `7` the matrix is `[[1,1],[1,0]]`, `det(I - x A) = 1 - x - x^2`, and the eigenvalues are `phi` and `-1/phi`: one comb on `Re s = log_2 phi = 0.6942419136306174` with teeth spaced `2 pi / log 2 = 9.064720283654388`, one on `Re s = -log_2 phi` with teeth at the odd multiples of `pi / log 2 = 4.532360141827194`, offset half a tooth by the argument `pi` of the negative eigenvalue. Both are genuine at `m = 0`. The residues on the first at `j = 0, 1, 2` are `0.946743395641970`, `0.210170579042708 - 0.581938842807736i` and `0.062192494764692 - 0.051732573832335i` to bounds near `1.3e-13`, and on the second `-0.259501222742937 - 0.592535006433179i`, `0.896350590641921 + 1.403072744223695i` and `0.491379388883393 - 3.790264223035055i` to bounds near `4.1e-9`; none is zero. Each is met by a contour average around its own pole, the first at `j = 0` by the level digit sums, `0.946743410426742` at length `24`, and all six by an arbitrary-precision peel written in the other lane, which agrees to `4.3e-12` on the second comb where the double-precision bound is `4.1e-9` (`mrlynum::automaton`, `lab/py/memory-zeta`).

**Proved.** The residue needs no eigenvector. With `x = base^(-s)` the resolvent is `adj(I - x A^T)/det(I - x A^T)`, and Faddeev-LeVerrier gives both as polynomials in `x` with integer matrix and integer scalar coefficients, so at a simple root `x_0` the residue of `zeta_W` is `1^T adj(I - x_0 A^T) N(s_0)` over `-x_0 log base det'(x_0)`, for `N` the right side of the peel identity. The adjugate is the spectral projector in polynomial form; at a multiple root it is not, the pole order exceeds one, and the formula dies.

The Lyndon cofactor becomes the determinant. **Proved.** `Z_W(s) = det(I - base^(-s) A) zeta_W(s)` is analytic on `Re s > log_base rho - 1`, since the level-`m` denominator is `det(I - base^(-s-m) A)` and only `m = 0` is cancelled, and one peel level gives it in closed form as `det(I - base^(-s) A) D_(P-1)(s) + 1^T adj(I - base^(-s) A^T) N(s)`, which never divides by the vanishing determinant and so reads on the comb itself. On the full rule at any width the determinant is `1 - base^(1-s)` exactly, the other eigenvalues being `0`, so `Z_W` is `zeta(s)(1 - base^(1-s))` and is entire. At code `7` it reads `0.991729890316722` at `s = 3`, `0.973380053858285` at `s = 2` and `0.913335748872126` at `s = 0.8`, each to a bound near `1e-13`, rising to `1` as `Re s` grows because the least element of `S_W` is `1`, while `zeta_W(0.8) = 9.536379694275015` is already climbing the pole at the abscissa (`mrlynum::automaton`).

The spine of [zeta](zeta.md) transfers in three pieces. **Proved**, every line of the checklist from the determinant's form and the paragraphs above, restating them and adding no separate result.

- Survives verbatim: the meromorphic continuation, the one-digit recursion carrying it, the peeled form carrying the small tail directly, the log-periodicity of every counting function on the set, the genuineness of the off-real poles at `m = 0`, and `Z_W(s) a_min^s -> 1` to the right with the least element of `S_W` for `a_min`.
- Survives with `A` in place of the scalar `fill base^(-s)`: the abscissa as `log_base rho`, the pole lattice as one comb per eigenvalue modulus, the factor that carries every comb at once and has no zeros as `1/det(I - base^(-s) A)`, the cofactor as `det(I - base^(-s) A) zeta_W(s)` with its closed form, and the zero transfer, which needs one more escape clause, the eigenvalues distinct, a repeated root of the determinant giving `Z_W` a zero the series does not see.
- Dies: simplicity and confinement to the single lattice `s_(m,j) = alpha - m + 2 pi i j / log base`, since one comb sits per nonzero eigenvalue and simplicity needs that eigenvalue simple; and the universal Bernoulli column `1/(u log base) + 1/2 + (u log base)/12 - (u log base)^3/720` reading the residue off `Z` alone, since the periodic factor is now `det(I - base^(-u) x_0 A)`, still independent of the tooth index because the determinant is a function of `base^(-s)` alone, but with a reciprocal whose expansion depends on the whole spectrum.

The Euler wall of [zeta](zeta.md) stands here too, and its proof does not travel. **Refuted**, that `S_W` carries a multiplicative indicator: the fibbinary integers hold the coprime pair `5` and `9`, and `5 * 9 = 45 = 101101` carries adjacent ones and is outside the set, so no Euler product over primes exists; `45` is the least such product over all coprime pairs of `S_W` below `2^16` (`mrlynum::automaton`). What does not travel is the construction: [zeta](zeta.md) builds its witness from the repunits of the least missing digit, and a memory rule has no missing digit to take the least of, so each rule needs its own witness or its own argument.

Every number above is printed beside a bound. **Verified.** The double-precision matrix ladder carries the truncation bound entrywise as a nonnegative vector through `(I - base^(-w) A^T)^(-1)`: right of the abscissa the inverse is majorised by its own Neumann series `sum_(i >= 0) (base^(-Re w) A^T)^i`, which is a sum of nonnegative matrices and so needs no norm and no primitivity, and the remainder closes on the guide `v = (I + A^T)^60 1`, which satisfies `A^T v <= mu v` for the upper end `mu` of a Collatz-Wielandt bracket. Left of the abscissa there is no free analogue of `abs(1 - fill base^(-s))`, and the level closes instead on the computed inverse certified by its own residual, which is why the second comb of code `7` is read at `4e-9` where the first is read at `1.3e-13`. The controls are the full rules at `k = 2` and `k = 3`, which reproduce the base 2 full design of [zeta](zeta.md) to `7.2e-11` at `s = 2` and `2.1e-14` at `s = 0.3 + 40i`, the product rule `W = {1}^2`, which reproduces a direct Mersenne sum to `1.2e-16`, a direct fibbinary sum with a Fibonacci tail bound, and the arbitrary-precision rewrite of the peel, which meets the four `zeta_W` values to `3.0e-15` and holds all fourteen rows of its control inside their own bounds, the largest gap `1.134e-11` against `7.348e-11` (`mrlynum::automaton`, `lab/py/memory-zeta`).

What the matrix ladder adds is a second pole comb. **Proved**, from the determinant's form: on a design the denominator is `1 - fill base^(-s)`, one root and one comb, so the cofactor strips the only comb there is and [zeta](zeta.md)'s second family is everything that comb does not claim. Here the denominator is `det(I - base^(-s) A)`, one root per nonzero eigenvalue, the cofactor strips every `m = 0` comb in a single factor, and each comb's teeth are then separately occupied or empty. The determinant's form gives the comb and not its residue: that the second comb's teeth carry nonvanishing residues is **Verified** above, at six teeth of one rule, and is proved nowhere. A rule with two combs is the smallest object on which the question can be put at all.

The cofactor's zeros are a resolved census on a printed box. **Verified.** At code `7` the box is `-0.95 < Re s < 2`, `0.02 < Im s < 43.1`, cut into `45` cells whose column edges are the midpoints of the comb and pole lines, subdivided so no column is wider than `0.75`, and whose row edges are the midpoints of the tooth and pole heights, so each cell holds at most one tooth. `Z_W` is meromorphic there with exactly `4` simple poles, the level-one teeth on `Re s = -0.305758086`, and none on either `m = 0` comb; each cell count is its winding plus the level-one teeth inside it. Those four poles are read and not assumed: a `48`-point circle mean gives residues `-1.990368154340-0.795661945868i`, `-0.350975872907-0.436714265460i`, `-3.135030562964-2.032376530959i` and `-1.028888122837+2.036528502776i`, the radius `0.05` and the radius `0.02` agreeing to `7.3e-14`, each simple to `5.1e-05` against `(s - s_0) Z_W` at `1e-5`, while a blank point on the same line reads `4.6e-16`. The box holds `20` zeros, all `20` located, the largest `abs(Z_W)` at a located zero being `9.694e-12`, the largest surviving phase step `0.999894` radians against a cap of one, and the largest propagated bound met anywhere on the census `1.474e-10`. No zero and no pole sits within `0.02` of an outer box edge; the tightest clearance on the census is `0.024768`, from the zero `0.091020460327+38.500293583162i` to an internal cell edge, and an internal edge cannot move the total, being sampled at the same points and bisected the same way from both sides, so the two cells' phase contributions cancel and only the split between neighbours could move. Contour seeds `0.1`, `0.05` and `0.025`, at `7298`, `11777` and `21599` evaluations, give identical cell rows and identical zeros. The right edge is a wall and not a choice. **Proved:** the least element of `S_W` is `1` and the coefficients are nonnegative, so `zeta_W(2) = 1.415825532885 < 2` gives `abs(zeta_W(s) - 1) < 1` on `Re s >= 2`, where the determinant has no root either. The cuts are `0 < Im s < 0.02`, `Im s > 43.1` and `Re s < -0.95`, so `20` is exact on the box and a lower bound for the half plane. The count is resolved and not certified: nothing here bounds `Z_W'/Z_W` on the contour, so a pair closer than the surviving contour spacing would stay invisible (`lab/py/memory-zeta`, verb `census`).

The first comb carries a zero comb and the second does not. **Verified.** At the radius `0.45` of [zeta](zeta.md)'s family census, all `4` teeth of the comb on `Re s = log_2 phi` below the height carry a zero, at distances `0.317490225`, `0.045406362`, `0.143076282` and `0.070233751`, while none of the `5` teeth of the comb on `Re s = -log_2 phi` does, the least distance from a second-comb tooth to any zero being `0.666213518` and the largest `0.758440773`. The radius is not what decides it: no radius below `0.666213518` occupies a second-comb tooth and none above `0.317490225` empties a first-comb one. Nor is the left edge: the radius `0.45` disc around a second-comb tooth reaches `Re s = -1.144241913631`, outside the box, so the same census is run on `-1.2 < Re s < 2`, which admits no new pole line before `-1.305758086369`, and returns the same `20` zeros, nineteen of them to twelve decimals and the twentieth to eleven, the same `4` of `4` and `0` of `5`, and the same five distances, so every point of every disc is counted. The first-order tooth law `u_1 = -r/R`, with `r` the residue of `zeta_W` at the tooth and `R` its regular part, holds on the first comb to a vector miss `abs(z - t - u_1)` of `0.062287774`, `0.000951131`, `0.020403749` and `0.003342909` in tooth order, and on the second it predicts `abs(u_1)` of `0.501975708`, `0.398920848`, `0.301764481`, `0.270277007` and `0.250378071` and misses by `0.214394685`, `0.645682670`, `0.408924841`, `0.489190529` and `0.519744494` in the plane, `0.200640774`, `0.348697913`, `0.364449037`, `0.488163765` and `0.477057669` in modulus, so on four of the five teeth it predicts a zero inside a radius that holds none. That law is read beside the census and not in place of it: `R` is a circle mean of radius `0.3`, so a prediction of `abs(u_1)` at or beyond `0.3` is read outside the disc that built it, which is the case on three of the five second-comb teeth, and on the first comb the one tooth predicting past `0.3` carries the worst miss, `0.062287774`, against `0.020403749` and better on the three below `0.153`. The emptiness is carried by the census (`lab/py/memory-zeta`, verb `census`).

The second comb's line carries zeros where its teeth do not. **Verified.** Three of the `20` sit within `0.05` of `Re s = -log_2 phi`, at `0.000322593`, `0.043369824` and `0.014258173` from it, and their distances to the nearest tooth of that comb are `4.104099275`, `0.747618761` and `4.283371881`; three more sit within `0.05` of `Re s = log_2 phi`, at `0.021128430`, `0.028888693` and `0.038082042`, and those three are teeth. Stripping the `4` teeth leaves a second family of `16` with real parts in `[-0.737611737911, 0.540957439322]`. The sample is small and the excess is stated as one: three zeros in a window of width `0.1` on a box `2.95` wide against the `0.68` that `20` uniformly spread real parts would put there is a factor of `4.4` on a sample of `20` (`lab/py/memory-zeta`, verb `census`).

An empty second comb is code `7` and not a law. **Refuted.** The supergolden rule, code `23` at width `3`, has `det(I - x T) = 1 - x - x^3` and three combs, one on `Re s = log_2 psi = 0.551463089746` and two interleaved on `Re s = -0.275731544873`, carried by the conjugate pair of eigenvalues of modulus `psi^(-1/2)`. Its census on `-0.75 < Re s < 2` at the same height reads `24` zeros in `70` cells, `4` poles on `Re s = -0.44853691`, largest phase step `0.998514` and largest bound `1.093e-10`; at radius `0.45` the first comb carries `3` of its `4` teeth, and the second line carries `7` of its `10`, `2` on the comb offset by `2.678332385297` and `5` on the comb offset by `6.386387898357`, with least distance `0.170257380`. So a second comb can carry a full zero comb, and what code `7` shows is that it need not (`lab/py/memory-zeta`, verb `census`).

Nothing in the spectrum decides which comb is occupied. **Refuted.** Of the `88` width-`3` rule classes under `G_(1,k)`, `9` carry two pole lines and none has a repeated eigenvalue, and all nine are censused on one box, `-1.15 < Re s < 2`, `0.02 < Im s < 20`, cut from the `43.1` of the single-rule census and holding every radius `0.45` disc of every second line, the deepest reaching `Re s = -1.144241913631`. Each reads `9` to `14` zeros in `20` to `36` cells, every zero located, largest residual `3.236e-11`, largest surviving phase step `0.999909` radians against a cap of one, and largest propagated bound `9.110e-09`. That left edge is the one the contour guard allows: no pole of `Z_W` comes within `0.02` of any contour on any of the nine, the least clearance being exactly `0.02`, which is the cut `Im s > 0.02` against the level-`m` pole on the real axis, while the `-1.2` that the widened single-rule census uses runs `0.011370462752` from a pole line of code `223` inside the box and `0.002842615688` from a pole line of codes `54` and `62` outside it and so uncounted. What `-1.15` does not clear is two zeros, `-1.134547677+3.580553251i` on code `127` and `-1.143621954+17.814806003i` on code `63`; the two boxes fail the same guard on disjoint objects and read the same occupancy on every rule, `50` teeth and `34` occupied, differing only off the discs, code `23` at `11` zeros against `13` and code `31` at `13` against `14`. The count is resolved and not certified: nothing here bounds `Z_W'/Z_W` on the contour. The table is the rule, its class size, `abs(lambda_2)/rho`, the arguments carried on the second line, the teeth and the teeth occupied at radius `0.45` on each line, the zeros in the box and the zeros lying off every tooth.

| rule | class | `abs(lambda_2)/rho` | `arg lambda_2` | line 1 teeth | occupied | line 2 teeth | occupied | zeros | off |
|---|---|---|---|---|---|---|---|---|---|
| `54` | `2` | `0.655865618` | `+-2.437735` | `2` | `2` | `4` | `3` | `14` | `8` |
| `62` | `4` | `0.655865618` | `+-2.437735` | `2` | `1` | `4` | `4` | `13` | `8` |
| `23` | `2` | `0.563624162` | `+-1.856479` | `2` | `1` | `4` | `4` | `11` | `6` |
| `31` | `4` | `0.563624162` | `+-1.856479` | `2` | `1` | `4` | `2` | `13` | `10` |
| `123` | `2` | `0.563624162` | `+-1.856479` | `2` | `2` | `4` | `3` | `13` | `8` |
| `223` | `2` | `0.430159709` | `+-1.407715` | `2` | `2` | `4` | `0` | `9` | `7` |
| `127` | `2` | `0.400890565` | `+-2.176234` | `2` | `2` | `4` | `2` | `10` | `6` |
| `55` | `2` | `0.381966011` | `+3.141593` | `2` | `2` | `2` | `1` | `9` | `6` |
| `63` | `4` | `0.381966011` | `+3.141593` | `2` | `2` | `2` | `0` | `9` | `7` |

The pair `(abs(lambda_2)/rho, arg lambda_2)` does not determine the row. Codes `55` and `63` at width `3` and code `7` at width `2` all carry `det(I - x T) = 1 - x - x^2`, so all three have the comb on `Re s = log_2 phi` at argument `0` and the comb on `Re s = -log_2 phi` at argument `pi`, teeth at the same heights, and they read `1` of `2`, `0` of `2` and `0` of `2` occupied on the second line, least tooth-to-zero distances `0.264392586`, `1.259215316` and `0.702616482`. Codes `23`, `31` and `123` agree in the same pair and read `4`, `2` and `3` of `4`. It is not the pair that fails but every function of the spectrum: codes `54` and `62` carry the same characteristic polynomial `det(I - x T) = 1 - x^2 - x^3`, hence the same eigenvalues, the same lines and the same teeth, and they differ on both lines, `2` against `1` and `3` against `4`. One spectrum reading two occupancies leaves no invariant of it to read, monotone, threshold or otherwise; the ratio alone is neither: code `223` at `0.430159709` is empty while code `127` at the smaller `0.400890565` reads `2` of `4` and code `55` at `0.381966011` reads `1` of `2`, and at the top code `62` at `0.655865618` is full while code `31` at `0.563624162` reads `2` of `4`. The argument fares no better, `+-1.856479` carrying `4`, `2` and `3` of `4` on three rules (`lab/py/memory-zeta`, verb `teeth`).

The two rules that separate occupancy differ by one integer. **Proved.** Code `55` at width `3` forbids exactly the windows `011`, `110` and `111`, which is exactly the ban on an adjacent pair of ones inside a `3`-window; for length at least `3` every adjacent pair sits inside one, and the word `11` carries no window and is accepted, so `S_55` is `S_7` with `3` adjoined and nothing else, `3` being the only difference either way over `1 .. 262143`. The minimal-string convention of the opening paragraph carries the whole of this: padded to the window width the two sets are equal and there is nothing to separate. Hence `zeta_55(s) = zeta_7(s) + 3^(-s)` and, the determinants being equal, `Z_55(s) = Z_7(s) + det(I - 2^(-s) T) 3^(-s)`, met at seven points to `1.168e-13`, each inside its own bound. That identity crosses widths, the `4`-state ladder, adjugate and peel meeting the `2`-state ones, and it settles the third candidate in one line: `zeta_55 - zeta_7 = 3^(-s)` is entire, so the two rules carry the same poles, the same orders and the same residues at every `m >= 0` and not only on the `m = 0` combs. The census reads that back through the determinant, which vanishes at every `m = 0` tooth, so `Z_55 = Z_7` there exactly, `0.201323625971-0.557442618567i` at `log_2 phi + 2 pi i / log 2` and `-0.650784966602-1.485977099821i` at `-log_2 phi + pi i / log 2` read from both, the residue at a simple root being that value over `-x_0 log base det'(x_0)`. Their zero sets differ all the same, code `55` having a zero at `-0.442302243578+4.612546440182i` where code `7` reads `-0.097731686660-0.868473160333i`, and reading `1` of `2` against `0` of `2` on the second line. Neither the eigenvalue nor the residue at a tooth, at any level, can select that tooth's occupancy (`lab/py/memory-zeta`, verb `bridge`).

What is left is the residue against the regular part, and it tracks. **Conjecture:** a tooth is occupied when the first-order quantity `u_1 = -r/R` is small, with `r` the residue of `zeta_W` at the tooth and `R` the mean of `Z_W/det` on a circle of radius `0.3`. Over the `50` teeth of the nine classes, `34` teeth occupied at radius `0.45`, the `23` whose prediction `abs(u_1)` falls below `0.3`, inside the disc that builds `R` and so where the reading is self-consistent, are occupied `22` times, and the `15` with `abs(u_1)` at or above `0.45` are occupied `4` times. The `12` in between are occupied `8` times, so the band is not a cut. The one exception inside `0.3` is code `55`'s second-line tooth at `Im s = 13.597080`, `abs(u_1) = 0.267301885` against a nearest zero at `0.497761908`, and the census prints two misses at every tooth, the modulus miss `abs(d - abs(u_1))` and the vector miss `abs(z - t - u_1)`, whose largest values are `0.739013203` and `1.287895060`, both at code `63`'s second-line tooth at `Im s = 13.597080`, `abs(u_1) = 0.520202113` against a nearest zero at `1.259215316`. Occupancy is a per-tooth Boolean and one tooth of the `50` hides a double: code `54`'s second-line tooth at `Im s = 14.612532` holds `0.213711738933+14.629308261174i` at `0.416892021` and `-0.597460129789+14.668266829134i` at `0.398533940`, so the `34` occupied teeth hold `35` zeros, and the `abs(u_1) = 0.631828588` there is in the bin the law reads as empty. `R` is a circle mean and `u_1` a first-order prediction, so this is a reading and not a theorem, and it is not a cheap test either: reading `R` costs more evaluations of `Z_W/det`, in the same disc, than locating the zero does. What it does say is that the selector is not a spectral invariant, since `r` and the pole lattice are shared by rules that disagree, and that what would make it one is `R` in closed form off the peel numerator (`lab/py/memory-zeta`, verb `teeth`).

A finite set is a knob on the zero set and on nothing else. **Proved.** Let `F` be a finite set of positive integers disjoint from `S_W` and write `S_W + F` for `S_W u F`. Then `zeta_(W+F)(s) = zeta_W(s) + P_F(s)` with `P_F(s) = sum_(n in F) n^(-s)`, a Dirichlet polynomial and so entire, hence the two series carry the same abscissa, the same poles, the same orders and the same residues at every point of the plane, while `Z_(W+F)(s) = Z_W(s) + det(I - base^(-s) A) P_F(s)`. Two consequences are exact. At every `m = 0` tooth `t` the determinant vanishes, so `Z_(W+F)(t) = Z_W(t)`: the knob cannot move the cofactor's value at a tooth, only the zeros around it. And the principal part of `zeta_W` at `t` is fixed while the constant term becomes `R + P_F(t)`, so the first-order zero position of the paragraph above becomes `u_1(F) = -r/(R + P_F(t))`; the higher coefficients of the regular part move too, the linear one by `P_F'(t)`, which that reading does not carry. The case `F = {3}` at code `7` is the one-integer bridge above, where the perturbed rule is again a memory rule, code `55` at width `3`; for a general `F` it is not, and nothing in the argument needs it to be. Two of the three probes that test the invariance cannot fail: a `48`-point circle mean annihilates an entire addition and the determinant vanishes at a tooth, so the residue gap `1.776e-15` and the tooth gap `1.250e-13` are an aliasing floor and a determinant residual. The probe that measures the added part is the identity read off the teeth, missing by at most `2.384e-15` at code `7` and `4.003e-16` at code `23` against an added part of up to `1.912203` and `1.708983` in modulus, and the four-state ladder reads the shift directly: at `Im s = 9.064720` code `55` carries code `7`'s residue `0.210170579-0.581938843i` digit for digit and `R = 1.313430833+1.119663028i` against `1.714940435+0.882338583i`, a difference that meets `3^(-t) = -0.401509601+0.237324445i` up to one unit in the last place of the two nine-decimal prints it is read from (`lab/py/memory-zeta`, verbs `dial`, `bridge` and `census`).

Every empty tooth is one integer away from occupied. **Verified.** Occupancy under the knob is read by the argument principle on the occupancy circle itself, the winding of the perturbed cofactor on a `40`-point circle of radius `0.45` about the tooth with the level-`m` poles inside added back, counted again at radius `0.43` and `0.47` so that a zero within `0.02` of the circle prints as a seam. The baseline reproduces the cell census exactly and with no seam, `4` of `4` and `0` of `5` at code `7` and `3` of `4` and `7` of `10` at code `23`. The perturbed grid does carry seams, and a seam whose inner count is `0` is an undetermined occupancy: `9` of the `110` cells of code `7`'s second comb, `10` of the `108` of code `23`'s abscissa comb and `9` of the `270` of its second line, so every minimum over a candidate row is read on both conventions and both are printed. Against the `22` integers of `2 .. 40` outside `S_W`, every one of code `7`'s five empty second-comb teeth is occupied by a single added integer at `Im s = 4.532360`, `13.597080`, `22.661801`, `31.726521` and `40.791241`, so the smallest `F` that occupies a tooth has one element there and that element is at most `11` on either convention; the least singleton itself is `{3}`, `{6}`, `{7}`, `{11}`, `{11}` on the inner reading and `{3}`, `{6}`, `{3}`, `{11}`, `{6}` on the outer. Code `23` moves both ways against its `27` candidates: the empty first-comb tooth at `9.064720` is occupied by `{7}` or by `{6}`, the three empty second-line teeth at `20.807773`, `29.872493` and `38.937214` by `{5}`, `{7}` and by `{15}` or `{11}`, while two occupied second-line teeth are emptied off the seam, `2.678332` by `{6}` and `42.645269` by `{6}` and by `{7}`, so `6` of the `14` teeth of that box change under a one-element perturbation on either convention. One direction is not reached, and the search for it is exact and not greedy: the minimum of `abs(R + P_F)` over all `4158861` subsets of size at most `16` is `1.095277075`, `0.784350607`, `1.295268436` and `1.662786204` at the four abscissa-comb teeth of code `7`, and the disc at each minimiser keeps its zero off the seam, the tooth at `18.129441` gaining a second instead of losing its first (`lab/py/memory-zeta`, verb `dial`).

The first-order quantity is not a selector under perturbation. **Refuted**, the claim that `u_1(F) = -r/(R + P_F(t))` predicts occupancy across the perturbed family. The grid is one row per tooth and one column per candidate, and each line is scored against the constant `occupied` predictor and not against chance. On code `7`'s second comb the grid holds `110` cells of which `77` read occupied, the first-order law calls `75` right and the constant predictor `77`; on code `23`'s second line, `270` cells, `222` occupied, the law `218` against `222`. Reading every undetermined cell as occupied only widens both deficits, to `80` against `86` and `219` against `231`, so neither subdominant reading turns on the convention. The abscissa comb does not rescue the law. Its apparent margin at code `23`, `105` of `108` against `84`, sits entirely on one tooth of the four, the other three being `27` of `27` occupied and scored alike by both predictors, and that tooth carries `10` of the line's undetermined cells, so the other convention reads `95` against `94`. And on code `7`'s abscissa comb the law fails on a determined cell: at `Im s = 9.064720` the exact minimiser drives `abs(R + P_F)` to `1.095277075`, below the emptying threshold `abs(r)/rho = 1.374951382`, so the law predicts `abs(u_1) = 0.564905571` and an empty disc, and the disc reads one zero with no seam. What the exact search establishes is a bound on its own objective and not on occupancy. This does not touch the unperturbed reading on the nine two-line classes, which is a statement about nine rules and not about a family; it removes the perturbed family as a route to promoting it (`lab/py/memory-zeta`, verb `dial`).

What the grid does show is a strength and a phase. **Conjecture:** the knob's strength at a tooth `t` is `abs(n^(-t)) = n^(-Re t)` and its direction is the phase `-Im(t) log n` modulo `2 pi`, so on a line with `Re t < 0` the strength grows in `n` and the largest candidate still reading empty rises with the tooth height, while on the abscissa comb, where `Re t = log_base rho > 0`, the strength decays and the candidates that flip a tooth are confined to a bounded range of `n` inside which the phase selects. On code `7`'s second comb the largest candidate reading empty is `11`, `25`, `28` and `35` at `Im s = 13.597080`, `22.661801`, `31.726521` and `40.791241` on the inner convention and `11`, `24`, `28` and `35` on the outer, increasing under both. **Refuted**, the stronger reading that the flippers are the smallest candidates: code `23`'s empty first-comb tooth at `9.064720` is occupied by `{7}`, `{13}` and `{14}` and by none of the smaller `5`, `6`, `10`, `11` and `12`, and the two teeth a singleton empties are emptied by `{6}` and by `{7}` while the smaller candidate `5` occupies both. The phase is `2 pi log_base n` against the tooth index, which is the same log-periodicity the pole lattice carries, and the threshold is read on a candidate range that stops at `40`, so it is a reading of the four heights above and not of the limit (`lab/py/memory-zeta`, verb `dial`).

Neither zero set reflects in the axis of its own comb lines. **Refuted.** Code `7`'s two combs sit symmetrically about `Re s = 0` and code `23`'s about `Re s = 0.137865772436`, and no zero of either census has a partner other than itself within `0.05` in both coordinates under reflection in that line: `0` of `20` and `0` of `24`. The exclusion is printed because it bites once: code `7`'s zero `-0.023033432741+33.122746617086i` sits `0.046066865482` from its own reflection and is the only self-match inside the tolerance on either census, code `23`'s nearest missing at `0.075316339787`. Symmetric poles do not give symmetric zeros, there being no functional equation on either side (`lab/py/memory-zeta`, verb `census`).

One question is left open and it is not the meter: the residue column at `m >= 1`. The peel reads the `m = 0` combs through its numerator and cannot reach below the first tooth, where the scalar ladder of [zeta](zeta.md) closes the gap with a separate recursion in `m` whose matrix analogue is not built here. The census reads the level-one residues it subtracts, by a circle mean at each of those poles, so what it counts out of a cell is a read quantity and not an assumption; what is missing is the closed form at every `m`, and no residue below level one is read anywhere.

## The radix dial

The place slot is dialled by changing the ring the addresses live in. Fix a ring `R`, either [the Gaussian integers](/wiki/gaussian-integers/) `Z[i]` or [the Eisenstein integers](/wiki/eisenstein-integers/) `Z[omega]` with `omega^2 = -1 - omega`, and a base `base` in `R` with norm `N(base) >= 2`. Throughout this section the norm `N(base)` counts the digits and is not a side length: at a rational base `m` the norm is `m^2`.

- **Residues.** A complete residue system mod `base` has `N(base)` elements. Take it canonically: the `N(base)` representatives of least norm, ties broken by argument in `[0, 2 pi)`. The choice is part of the definition and is printed with every design.
- **Digit set.** A digit code names a subset of the canonical residue system, one bit per residue in that order, and a digit set is one representative per named class, the canonical system being the reference the representatives are read against. Today's plane codes are read in box row-major order instead, which is the canonical order only at `m = 2`.
- **Twist.** Each digit `d` carries a unit `u_d` of `R`. The units are the four powers of `i` in `Z[i]` and the six powers of `-omega` in `Z[omega]`.
- **Place.** The place map of digit `d` is `phi_d(x) = (u_d x + d) / base`, and the word `d_1 ... d_level` lands on `phi_(d_1)(phi_(d_2)( ... phi_(d_level)(0)))`.

Unfolding the composition gives the closed form `sum_(j=1..level) (prod_(i<j) u_(d_i)) d_j base^(-j)`, which at every twist equal to `1` is plain place value `sum_j d_j base^(-j)`. (**Proved**, by induction on `level` from the definition of `phi_d`.) Today's designs are the untwisted real-base row. Take `R = Z[i]`, `base` the rational integer `m >= 2`, so `N(base) = m^2`, take the box digits `{x + y i : 0 <= x, y < m}`, and take every `u_d = 1`. Then the place map is `x -> (x + d)/m` on each coordinate and the word `d_1 ... d_level` lands on the cell at level `level` of the plane design of the same digit code at base `m`, cell for cell, the code read in box row-major order, bit `y m + x` at row `y` and column `x`. (**Proved**, the two place maps are the same formula. **Verified** at `m = 2` and `m = 3` on all `528` plane codes at level `2` with `0` mismatches, by `lab/rs/radix-designs`.) The box is not the canonical residue system past `m = 2`: it holds `m-1`, of norm `(m-1)^2 >= 4`, where the canonical system holds `-1`, of norm `1`. (**Proved**.) At `m = 3` the canonical system is `0, 1, i, -1, -i, 1+i, -1+i, -1-i, 1-i`. So the code does not name the design. A code names a set of residue *classes*, and a design also fixes one representative per class; replacing `d` by `d + base m` shifts the image of `phi_d` by `m` and moves the attractor. A radix design is therefore a quintuple, ring, base, digit code, representative vector, twist vector, and the canonical system is the reference the representative vector is read against. (**Proved**, from the definition of `phi_d`.)

### The fill law, and where it stops

**Proved.** The accepted words of length `level` number `card F^level` at every base, every digit set and every twist: the accept slot is the full shift on `F` and the twists are not in it. **Proved, no twist.** With every `u_d = 1` the word `d_1 ... d_level` lands on `base^(-level) sum_(i=1..level) d_i base^(level-i)`, and distinct words land on distinct points. Reduce the integer `sum_i d_i base^(level-i)` modulo `base`: every term but the last is divisible by `base`, so the residue is `d_level`, which recovers the last digit because the digits are pairwise incongruent; subtract it, divide by `base`, and induct. So the fill law `fill(level) = card F^level` of [core](core.md) survives the dial word for word as long as no digit turns. The generator carries that hypothesis too: `mrlynum::radix::Radix::new` refuses a digit list holding two digits congruent modulo the base, as `from_code` and `tile` already did. It guards the digit hypothesis alone: it accepts any unit twist, and the twisted witness below is built by it.

**Refuted for a twisted design.** In the closed form above a turn early in the word rescales every digit after it, and two words of one length can then collide. Witness, by the arithmetic printed here: `R = Z[i]`, `base 2`, `N(base) = 4`, canonical residues `0, 1, i, 1+i`, digit set `F = {0, 1}`, twists `u_0 = 1` and `u_1 = -1`. Then `01` lands on `phi_0(phi_1(0)) = phi_0(1/2) = 1/4` and `11` lands on `phi_1(phi_1(0)) = phi_1(1/2) = (-1/2 + 1)/2 = 1/4`. Two words of length two, one point, so the cell count is `3` where `card F^level` is `4`. A twisted design owes its fill law a proof of its own; it does not inherit one. That witness is **Verified** exactly as written by `lab/rs/radix-designs`: fill `4` and `3` distinct points at level `2`. **Proved.** Its distinct-point count is `2^(level-1) + 1` at every level: scaled by `base^level`, the word whose `1`s sit at positions `j_1 < ... < j_t` lands on `sum_(k=1..t) (-1)^(k-1) 2^(level - j_k)`, an alternating sum of strictly decreasing powers of two with top exponent at most `level-1`; such a sum is `0` or lies in `[1, 2^(level-1)]`, the alternating tail being smaller than its leading term, and every integer of `[1, 2^(level-1)]` is reached by exactly one choice, the greedy one taking `2^a` for the least `a` with `2^a >= n` and recursing on `n - 2^a`. So the counts read `2, 3, 5, 9, 17, 33, 65, 129` at levels `1` to `8` against the fill `2^level`, printed and asserted to level `16` (`lab/rs/radix-designs`).

Each `phi_d` is a similarity of ratio `|u_d| / |base| = N(base)^(-1/2)`, since a unit has modulus `1`, so all `card F` maps contract by the same ratio and the similarity dimension is the `s` solving `card F N(base)^(-s/2) = 1`, that is

```
s = 2 log(card F) / log N(base).
```

(**Proved**, from the definitions; the exponent is unique because `sum_d r_d^t` falls from `card F` to `0`, [Hutchinson 1981](https://doi.org/10.1512/iumj.1981.30.30055) 5.1(2), and 5.1(3) names it the similarity dimension.) At the real-base row above, `N(base) = m^2` and this reads `log(card F) / log m`, [core](core.md)'s dimension. **Proved by [Hutchinson 1981](https://doi.org/10.1512/iumj.1981.30.30055) 5.1(4)(i)**, which gives `H^s(K) < infinity` and `dim_H K <= s` for arbitrary contractions with no hypothesis at all: the Hausdorff dimension of a radix design is at most `s`. Equality is not free. It needs the open set condition, a non-empty open `O` with `union_d phi_d(O)` inside `O` and the images pairwise disjoint (5.2(1)), under which `0 < H^s(K) < infinity` and `dim_H K = s` (5.3(1) Theorem). That condition is a hypothesis per base, per digit set and per twist, and `lab/rs/radix-designs` checks it at no base. So for every named object below: **Conjecture**, its Hausdorff dimension equals the similarity dimension printed for it.

### The twist law

**Proved.** A twist keeps every count the accept slot computes and every ratio, and moves only the place. The accept slot of a radix design is the full shift on `F` and mentions no `u_d`, so the accepted word count is `card F^level` whatever the twists; every `phi_d` has ratio `N(base)^(-1/2)` whatever the twist, since `|u_d| = 1`, so the similarity dimension `s` is untouched; and the twists enter the definition only through where an image sits. What they can change, and the witness above shows they do, is which words land together, which is the glue slot and not a count of the accept slot. That is the exact complement of weights, which move mass and never geometry ([weights](weights.md)): twists move geometry and never mass.

### The named objects

A radix design is the quintuple `(ring, base, digit code, representative vector, twist vector)`, and the classical self-similar curves are entries in that list rather than separate constructions. Each is tested by `lab/rs/radix-designs` against an independent `f64` iterated function system, word for word. The Sierpinski gasket is the untwisted `(Z[omega], 2, 7)` with `card F = 3` and similarity dimension `log 3 / log 2 = 1.584963`. **Verified**: against the three similarities of ratio `1/2` fixing the vertices of an equilateral triangle, written out independently, its `3^9 = 19683` words agree to `4.441e-16` after the translation and positive scaling that the statement leaves free, pinned by the two corresponding words `0^9` and `2^9` and then measured at every word.

The terdragon is `(Z[omega], 2+w, 7)` with `card F = 3`, twisted by `1, w, 1`, and it is not the untwisted design of that code. Reading the terdragon's own L-system `F -> F + F - F` at `120` degrees as a turtle and normalising by the endpoint gives the `3^8 = 6561` segment starts at level `8`: the twisted design matches them to `7.511e-16` (**Verified** against that reading) and the untwisted code misses by `1.060` (**Refuted**). That the L-system reading is the terdragon is carried by no source read here, so the name is **Conjecture**.

The twindragon is the untwisted `(Z[i], 1+i, 3)` with `card F = 2` and the flowsnake is the untwisted `(Z[omega], 3+w, 127)` with `card F = 7`, the full residue system of a base of norm seven; both have similarity dimension exactly `2`. Each is compared only against the maps `(z + d)/base` over the residues of its own base, which is its definition as a radix set, so those comparisons are self-checks, at `0` and `2.259e-16`, and both names are **Conjecture**.

The Koch curve is `(Z[omega], 3, 147)` with `card F = 4` and similarity dimension `log 4 / log 3 = 1.261860`, and it is the first object here that needs a nontrivial twist: digits `0, 1, 2+w, 2` and twists `1, 1+w, -w, 1`. **Proved**, coefficient for coefficient: `e^(i pi/3) = 1 + w`, `e^(-i pi/3) = -w` and `(2 + w)/3 = 1/2 + i sqrt(3)/6`, so its four `phi_d` are `z -> z/3`, `z -> e^(i pi/3) z/3 + 1/3`, `z -> e^(-i pi/3) z/3 + 1/2 + i sqrt(3)/6` and `z -> z/3 + 2/3`. [Hutchinson 1981](https://doi.org/10.1512/iumj.1981.30.30055) 3.3(2) gives the Koch curve as the attractor of four similitudes each carrying `a_1 a_5` to `a_i a_(i+1)` with positive determinant, and those are exactly those four for the polyline `0, 1/3, 1/2 + i sqrt(3)/6, 2/3, 1`, which is read from its Figure 3.2 and not from its text; so the name is **Conjecture**. A float evaluation of the same four maps agrees with the crate's ring arithmetic to `1.241e-16` at level `5`, which is a self-check and not an identification. Its digit `2` is not the canonical representative of its class, which is `-1`, so the code `147` alone does not name it. Distinct words still name distinct points at every level reached: the distinct-point count equals the fill for code `7` at base `2` to level `11`, code `3` at `1+i` to `17`, code `7` at `2+w` to `11`, code `127` at `3+w` to `6` and the twisted code `147` at `3` to `8`, so the Koch twist glues nothing inside that reach. (**Verified**, `lab/rs/radix-designs`.)

**Proved by [Lagarias and Wang 1997](https://doi.org/10.1007/BF02649100)**, Corollary 6.2 with Lemma 2.1, restated here and not reproved, read in the verbatim restatement of Steiner and Thuswaldner: for an expanding integer matrix *with irreducible characteristic polynomial* and `D` a complete set of coset representatives of `Z^n / A Z^n`, the attractor `T(A, D)` tiles `R^n` by the smallest `A`-invariant sublattice containing `D - D`. A base `base` acting on `Z^2` has the minimal polynomial of `base` as its characteristic polynomial, irreducible exactly when `base` is not a rational integer. So the theorem covers the twindragon, the terdragon and the flowsnake, whose digit sets are the full residue systems of their bases; it does not cover the gasket, whose `3` digits of `4` are not a complete set; and it does not cover the real-base row that today's designs live on, whose base is a rational integer.

### How many digit codes a base carries up to its unit group

The group of a base is the units acting on the residues by multiplication, joined by conjugation exactly when `conj(base)` is an associate of `base`. Multiplying every digit by a unit `v` carries the attractor to `v` times the attractor over the same base, since `v phi_d(v^(-1) x) = phi_(v d)(x)`, so the units always act; conjugation carries base `base` to base `conj(base)`, which is the same radix system only under that condition. (**Proved**.) It holds at `2` and `1+i` on `Z[i]` and at `2`, `2+w` and `3` on `Z[omega]`, and fails at `2+i` and `3+w`. The abstract group is `R^* semidirect <conj>`; what acts on the residues is its image, which is smaller, and at `1+i` every element of the group acts as the identity.

| ring | base | `N(base)` | abstract order | image order | codes `2^N(base)` | digit-code classes |
|---|---|---|---|---|---|---|
| `Z[i]` | `2` | 4 | 8 | 2 | 16 | 12 |
| `Z[i]` | `1+i` | 2 | 8 | 1 | 4 | 4 |
| `Z[i]` | `2+i` | 5 | 4 | 4 | 32 | 12 |
| `Z[omega]` | `2` | 4 | 12 | 6 | 16 | 8 |
| `Z[omega]` | `2+w` | 3 | 12 | 2 | 8 | 6 |
| `Z[omega]` | `3` | 9 | 12 | 12 | 512 | 84 |
| `Z[omega]` | `3+w` | 7 | 6 | 6 | 128 | 28 |

(**Verified** by `lab/rs/radix-designs`, a Burnside count over the abstract group and a direct orbit walk over all `2^N(base)` codes agreeing at every base; Burnside is correct over the abstract list even where the action is not faithful, the list carrying each element of one abstract group once.)

**Proved.** Conjugating the place maps of an untwisted design at base `base` by an invertible real affine `h(x) = H x + s` gives `(y + H d + s(base - 1))/base`, again an untwisted place map at base `base` exactly when `H` commutes with multiplication by `1/base`, and `s(base - 1)` sweeps the plane because `N(base) >= 2` forces `base != 1`. So the conjugacy group of the family is the centraliser of `1/base` extended by translations. At a non-real base that centraliser is `C`, the group is the similarity group `x -> v x + t`, and the two quotients below agree; at a real base `1/base` is the scalar `(1/base) I`, it commutes with every `H`, and the group is the whole real affine group `GL_2(R)` semidirect `R^2`. **Proved.** The mirror `x -> v conj(x) + t` preserves the untwisted family at base `base` exactly when `conj(base) = base`, since a direct conjugacy keeps the derivative `1/base` and a mirror one sends it to `1/conj(base)`, and being an associate of `base` is not enough. So the mirror acts at `2` on `Z[i]` and at `2` and `3` on `Z[omega]` and at none of `1+i`, `2+i`, `2+w`, `3+w`, though the code group of the table above admits conjugation at two of those, `1+i` and `2+w`. At a real base it is one element of the full affine group and not the only new one, so it is load-bearing for the similarity quotient alone.

**Verified.** The census of digit codes is a census of neither quotient. Counting untwisted canonical digit sets at every base and every `card F`, up to similarity and up to the conjugacy group above, gives the two columns beside the code classes.

| ring | base | code classes | similarity classes | affine classes |
|---|---|---|---|---|
| `Z[i]` | `2` | 12 | 5 | 5 |
| `Z[i]` | `1+i` | 4 | 3 | 3 |
| `Z[i]` | `2+i` | 12 | 8 | 8 |
| `Z[omega]` | `2` | 8 | 6 | 5 |
| `Z[omega]` | `2+w` | 6 | 4 | 4 |
| `Z[omega]` | `3` | 84 | 117 | 88 |
| `Z[omega]` | `3+w` | 28 | 22 | 22 |

(**Verified** by `lab/rs/radix-designs`, verb `affine`, in exact arithmetic over `Q(i)` and `Q(w)`. The affine column repeats the similarity column at the four non-real bases by the lemma above and is computed over `GL_2(Q)` semidirect `Q^2` at the three real ones, against two explicit conjugating matrices asserted in the study, with the similarity classes asserted to refine the affine classes pair by pair in every cell. Both columns count untwisted canonical digit sets and nothing else: the representative vector and the twist vector are not quotiented here.)

**Verified.** No two of the three quotients are comparable, and neither design count bounds the code count: both sit below it at six bases and above it at base `3` on `Z[omega]`, where `512` codes give `84` code classes, `117` similarity classes and `88` affine classes. Split by `card F = 0` to `9` at that base the similarity classes are `1, 1, 1, 9, 23, 30, 29, 16, 6, 1`, the affine classes `1, 1, 1, 2, 11, 23, 26, 16, 6, 1` and the code classes `1, 3, 7, 13, 18, 18, 13, 7, 3, 1`; the code row is palindromic because complementing a code commutes with the residue action, and neither design row is, complementation being neither a similarity nor an affine invariant. Over the `41` cells of the seven bases the similarity count is below the code count in `17`, equal in `19` and above it in `5`, and the affine count is below in `19`, equal in `18` and above in `4` (`lab/rs/radix-designs`, verb `affine`).

**Verified.** The crossing is a property of the similarity quotient and dissolves in the affine one. At base `3` on `Z[omega]` and `card F = 3` the `84` three-digit codes fall in `13` orbits, `9` similarity classes and `2` affine classes, the collinear triples against the rest: codes `131`, digits `0, 1, 2+w`, and `137`, digits `0, w, 2+w`, share an orbit and are not similar, squared side lengths `1, 1, 3` against `1, 3, 4`, yet `H = [[0, 2], [1, -1]]` carries the first onto the second, while codes `7`, digits `0, 1, 1+w`, and `42`, digits `1, w, -1-w`, are similar and sit in different orbits. The unimodular `H = [[1, 1], [0, 1]]` carries code `7` onto code `131`, so those two lie in one affine class as well, and it is an automorphism of the lattice, which closes the escape of demanding that a conjugacy preserve the ring, the base or canonicity (`lab/rs/radix-designs`, verb `affine`).

**Verified.** Twists multiply the count and are quotiented by nothing: over the `512` codes, not over the `84` classes, the twist vectors number `sum_k binom(9, k) 6^k = 7^9 = 40353607`, and that counts only designs whose representative vector is canonical. No action of the group on twist vectors is defined here.

### What a plane lattice will not carry

**Proved.** A unit of `R` is an element of norm `1`. In `Z[i]` that is `a^2 + c^2 = 1` with four solutions, the powers of `i`; in `Z[omega]` it is `a^2 - a c + c^2 = 1` with six, the powers of `-omega`. So every twist this dial offers is a rotation of order `1, 2, 3, 4` or `6`, and never of order `5` or `8`. **Proved.** The ambient will not supply one either. A rotation that maps a rank-2 lattice onto itself is an automorphism of it, so in a lattice basis it is an integer matrix and its trace is an integer; a rotation by `theta` has trace `2 cos theta`, so `2 cos theta` lies in `{-2, -1, 0, 1, 2}` and `theta` is a multiple of `2 pi / n` with `n` in `{1, 2, 3, 4, 6}`. That is the classical crystallographic restriction. So no rotation of order `5` or `8` is available to a plane radix design from either side, as a twist or as a symmetry of the lattice it is built on. That no attractor of such a design carries a fivefold or eightfold symmetry of its own does not follow: a symmetry of the attractor need not carry the lattice to itself, and nothing here rules one out. Fivefold and eightfold order in the twist need a lattice of rank `4`, which is a different ambient and not this dial.

## The glue slot

The third slot is not a dial here. Glue is induced: two words name one point exactly when the place map sends them to the same point of the ambient, and nothing else identifies them. There is no second automaton on this page and no relation to choose. The collision in the radix dial's witness, counted level by level by `lab/rs/radix-designs`, is glue of that kind - a consequence of the place map, read off it, never set. A construction in which two words are *declared* to name one point - self-similar groups and their limit spaces, Julia sets read through digit itineraries - is a different object with a different census, and it is not built on this tree. It is named here only so that the slot is not mistaken for a free choice on the pages that use it.

## Where the numbers live

- `lab/py/memory-census` enumerates every width-`k` rule at base 2 for `(dim, k)` in `{(1,1), (1,2), (1,3), (1,4), (2,1), (2,2)}`, builds every transfer matrix, and prints the class counts under both groups, the exact characteristic and minimal polynomials, `rho`, the growth exponent, `kappa` and the two window budgets, with the `k = 1` rows reproducing [core](core.md)'s census as its control.
- `lab/rs/memory-meter` reads the Mobius meter of every width-`1`, `2` and `3` rule at `dim 1`, base `2` in one ascending pass to `2^30`, and prints `A_W`, `M_W`, the running maximum and the normalised peak at `89` phases, with the Mertens function, the memoryless base-3 designs, a direct digit recount and the crate's acceptance test as its pinned controls.
- `lab/rs/carry-skeleton` splits `m n + 1` in base 2 into its `GF(2)` skeleton and its carry, rebuilds the zero-carry code of every odd multiplier from the difference set of `supp m`, reads `rho` and `kappa` off `mrlynum::memory`, and pins the carry density, the carry-free cycle census and the six refutations of `d_loc` as exhaustive set equalities.
- `mrlynum::automaton` carries the matrix ladder of `### The memory zeta` in double precision, `zeta_W`, its cofactor, its residues and its denominator, every value beside the bound propagated with it, and `lab/py/memory-zeta` is the arbitrary-precision control it is met by, a rewrite of the peel at `dps = 40` sharing the mathematics and none of the arithmetic and reaching the second pole comb from outside the branch that produces it.
- `lab/rs/radix-designs` enumerates `(ring, base, digit code, representative vector, twist vector)`, prints the canonical residue system of each base first, reproduces today's plane designs cell for cell, compares each named object against an independently written map list, counts the distinct points a twist glues, and quotients the codes of a base by its residue action and by affine conjugacy.
- The memory dial is drawn by the [memory demo](../../site/demos/memory/), which picks `dim`, `k`, the code and the level and draws, counts and measures the accepted words, and the radix dial is drawn by the [radix demo](../../site/demos/radix/), which picks the ring, the base, the digits and their twists, draws the words and counts the ones the place maps glue. The memory demo runs to the crate's span `k dim <= 6`, so it offers `(dim, k) = (2, 3)`, which the census above stops short of at `(2, 2)`: that corner is drawn and counted and is classified nowhere on this page.
- Every number on this page is printed by one of those studies or by the crate function named beside it, and the definitions and proofs are the object they measure.