# The memory dial

- 2026-09-13 [Proved] A width-`k` rule `W` over the `2^dim` digit vectors has `N_W(level) = 1^T A_W^(level-k+1) 1` for `level >= k - 1`, where the states of `A_W` are the `2^(dim(k-1))` windows of width `k - 1` and `A_W[s][t] = 1` iff `s` and `t` overlap in `k - 2` digits and the `k`-window they form is allowed, with the `k = 1` case reading one state and `A_W = [#W]`; an accepted word of length `level` is exactly a path of `level - k + 1` steps (witness: lab/py/memory-census README THE TRANSFER MATRIX).
- 2026-09-13 [Proved] The memory number `kappa(W) = log_2(#W)/k - log_2 rho(W)` is nonnegative for every width-`k` rule, since an accepted word of length `mk` splits into `m` disjoint allowed windows and so `N_W(mk) <= #W^m`, giving `rho^k <= #W`; it is zero on every product rule `W = F^k` with `F` non-empty, where `N_W(level) = #F^level`, while the empty rule has `#W = 0` and `rho = 0` and carries no `kappa` at all (witness: lab/py/memory-census README THE MEMORY NUMBER).
- 2026-09-13 [Proved] Every element of `G_(dim,k)`, the signed permutations `B_dim` applied diagonally to the `k` digits of a window together with window reversal, preserves `N_W(level)` for every `level`: a diagonal `B_dim` element conjugates `A_W` by a permutation matrix and reversal transposes it, and `A` and `A^T` share a characteristic polynomial (witness: lab/py/memory-census README THE GROUP).
- 2026-09-13 [Proved] At `dim = 1` the classes of width-`k` rules under diagonal `B_1` alone number `2^(2^k - 1) + 2^(2^(k-1) - 1)`, because the digit flip acts on the `2^k` windows as `w -> 2^k - 1 - w` in `2^(k-1)` two-cycles (witness: lab/py/memory-census README THE CENSUS, Burnside).
- 2026-09-13 [Proved] The set of Perron roots occurring at width `k` is contained in the set occurring 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, while at `level = k` exactly it has no window and accepts every word (witness: lab/py/memory-census README THE PERRON ROOTS).
- 2026-09-13 [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 flipping both axes, and the width-4 window reversal is the `(2,2)` block swap composed with the diagonal axis swap (witness: lab/py/memory-census README THE GROUP).
- 2026-09-13 [Verified] Width-`k` rules at base 2 in dimension 1 fall into `3, 9, 88, 16960` classes under `G_(1,k)` for `k = 1..4`, out of `4, 16, 256, 65536` rules, the orbit walk agreeing with an independent Burnside average on every row (witness: lab/py/memory-census census.csv, orbit walk and Burnside).
- 2026-09-13 [Verified] Under diagonal `B_dim` alone with no window reversal the counts are `3, 10, 136, 32896` at `dim = 1` and `k = 1..4` and `6, 8548` at `dim = 2` and `k = 1, 2`, against `3, 9, 88, 16960` and `6, 4660` with reversal (witness: lab/py/memory-census census.csv, orbit walk and Burnside).
- 2026-09-13 [Verified] The memory dial at `k = 1` is the plain design census: `3` classes at `dim = 1` and `6` at `dim = 2`, A000616 at `1` and `2`, with the two groups agreeing because reversal is trivial (witness: lab/py/memory-census census.csv, the `(dim,1)` rows).
- 2026-09-13 [Verified] A width-`k` rule in dimension `dim` is a subset of the `k dim`-cube counted with a smaller group, so the class counts meet or exceed A000616 at `k dim`, by factors `1, 3/2, 4, 42.19` at `dim = 1` and `k = 1..4` and `1, 11.59` at `dim = 2`, equal at `k = 1` where reversal is trivial and the two censuses coincide (witness: lab/py/memory-census census.csv column a000616).
- 2026-09-13 [Verified] Code `7` at `dim = 1` and `k = 2`, the rule forbidding the window `11`, has Perron root the golden ratio, minimal polynomial `x^2 - x - 1` and `rho = 1.618033988749` (witness: lab/py/memory-census classes.csv, PARI factor and polrootsreal).
- 2026-09-13 [Verified] At `dim = 1` and `k = 3` the four named roots land on the four expected codes, each the least code of its class: code `127` gives tribonacci `x^3 - x^2 - x - 1` at `1.839286755214`, code `55` golden, code `23` supergolden `x^3 - x^2 - 1` at `1.465571231876`, code `54` plastic `x^3 - x - 1` at `1.324717957244` (witness: lab/py/memory-census classes.csv, PARI).
- 2026-09-13 [Verified] The same four named polynomials occur in dimension 2 at width 2, on least codes `327` tribonacci, `19` golden, `323` supergolden and `326` plastic, carrying `121, 588, 54, 48` classes, so the named roots are not a dimension-one accident (witness: lab/py/memory-census classes.csv).
- 2026-09-13 [Verified] Across the whole census `kappa(W) = 0` holds on exactly the non-empty product classes, `2` at every `(1,k)` and `5` at every `(2,k)`, with zero counterexamples over `19563` live classes; the test is exact, `kappa = 0` iff the minimal polynomial of `rho` divides `x^k - #W` (witness: lab/py/memory-census census.csv columns classes_kappa0 and kappa0_nonproduct).
- 2026-09-13 [Verified] For `k >= 2` the largest memory number in the census is attained at `rho = 1`, by the largest rule of zero entropy, on a tie of `1, 3, 4, 3` classes whose 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, `kappa` is identically `0` and the maximum is attained on every live class, the full rule at `rho = 2^dim` included (witness: lab/py/memory-census census.csv columns kappa_max, kappa_max_code and kappa_max_ties).
- 2026-09-13 [Verified] The window budget of zero entropy, the largest number of windows a live class with `rho = 1` allows, is `1, 3, 6, 13` at `dim = 1` and `k = 1..4` and `1, 10` at `dim = 2`: a rule may allow that many windows and still accept subexponentially many words, code `11` at `(1,2)`, which allows `00, 01, 11`, accepting every `0^a 1^b` with `N_W(level) = level + 1` (witness: lab/py/memory-census census.csv column rho1_windows).
- 2026-09-13 [Verified] The distinct characteristic polynomials number `3, 6, 23, 431` at `dim = 1` and `k = 1..4` and `5, 333` at `dim = 2` and `k = 1, 2`, and the distinct minimal polynomials of `rho` number `3, 4, 10, 177` and `5, 185` (witness: lab/py/memory-census census.csv, exact Faddeev-LeVerrier and PARI factor).
- 2026-09-13 [Verified] The Perron roots that fail to dominate their conjugates strictly number `12` of `177` at `(1,4)` and `5` of `185` at `(2,2)`, and every one of them is `p(x^m)` for some `m >= 2` with `p` the minimal polynomial of a strict root already in the census, for instance `x^4 - x^2 - 1` and `x^6 - x^3 - 1` for the golden ratio; strictness is decided numerically, PARI complex roots against a `1e-20` gap, and the `strict` column is left empty on the dead row `x` so that the live count reads `12` and `5` (witness: lab/py/memory-census census.csv columns weak_perron_polys and weak_are_radicals).
- 2026-09-13 [Verified] Burnside extends the class counts past the orbit walk at no cost: under `G_(1,k)` for `k = 1..8` they are `3, 9, 88, 16960, 1074036736, 4611686053860868096, 85070591730234617055658644612208132096, 28948022309329048855892746252171977006958709724020498949042189405102555529216` (witness: lab/py/memory-census memory.py Burnside extension, 0.01s).
- 2026-09-13 [Verified] None of `3, 9, 88, 16960`, `6, 4660`, `3, 4, 10, 177` or `3, 6, 23, 431` appears in the local OEIS dump; `3, 10, 136, 32896, 2147516416` greps three hits, A055708, A056006 and A191363, each a list of integers with a sigma property agreeing only through the closed form `2^(m-1)(2^m + 1)` at `m = 2^(k-1)` (witness: grep of the local dump for each comma-delimited string, names read at source).
- 2026-09-13 [Verified] The census, the crate and the demo read a corner the same way: `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`, bit `0` the column and bit `1` the row, and no code label moves between the three (witness: crates/mrlydemo/tests/memory.rs::width_one_is_the_plane_design_cell_for_cell, which pins codes `11` and `13`, exchanged by the axis swap and drawn differently).
- 2026-09-13 [Verified] The width-one memory rule is the plane design of the same code cell for cell, for codes `1, 7, 9, 11, 13, 14` at every level one to six (witness: `mrlydemo::memory::memory_sheet` against `mrlydemo::two::two_grid`, test `crates/mrlydemo/tests/memory.rs::width_one_is_the_plane_design_cell_for_cell`)
- 2026-09-13 [Verified] The golden rule, `dim = 1` width `2` code `7`, which forbids the window `11`, accepts `2, 3, 5, 8, 13, 21, 34, 55` words at levels one to eight, the Fibonacci numbers (witness: `mrlynum::memory::counts`, test `the_golden_rule_counts_the_fibonacci_numbers`)
- 2026-09-13 [Verified] The golden rule has Perron root `1.618034`, growth exponent `0.694242` and memory number `kappa = log_2(3)/2 - log_2(phi) = 0.098239` (witness: `mrlynum::memory::perron`, `exponent`, `kappa`, check row `memory golden growth`)
- 2026-09-13 [Verified] The supergolden rule, `dim = 1` width `3` code `23`, the sponge code read as a window rule, allows at most one `1` a window and accepts `2, 4, 4, 6, 9, 13, 19, 28` words at levels one to eight, the Narayana cow recurrence `a(level) = a(level - 1) + a(level - 3)` holding from `level = 2k = 6` on and failing at `level = 5`, where the count is `9` against `a(4) + a(2) = 10` (witness: `mrlynum::memory::counts`, test `the_supergolden_rule_counts_the_narayana_cows`)
- 2026-09-13 [Verified] The supergolden rule has Perron root `1.465571`, the supergolden ratio, the real root of `x^3 = x^2 + 1` (witness: `mrlynum::memory::perron`, check row `memory cow root`)
- 2026-09-13 [Verified] The rule that forbids a digit twice in a row, `dim = 2` width `2` code `31710`, accepts `4, 12, 36, 108` words at levels one to four, root exactly `3` since its transfer matrix is `J - I` on the four digits with minimal polynomial `x - 3`, and memory number `kappa = log_2(12)/2 - log_2(3) = 0.207519` (witness: `mrlydemo::memory::memory_read`, check row `memory no repeat`, lab/py/memory-census classes.csv row `x - 3` at `(2,2)`)
- 2026-09-13 [Verified] The full rule accepts `2^(dim level)` words at every dimension one to three and every width its span allows, and its growth exponent is the dimension (witness: `mrlynum::memory::counts` and `exponent`, test `the_full_rule_counts_every_word`)
- 2026-09-13 [Verified] The empty rule accepts every word shorter than its window and nothing at or past it, and its Perron root is exactly zero (witness: `mrlynum::memory::counts` and `perron`, test `the_empty_rule_dies_past_its_window`)
- 2026-09-13 [Proved] The memory number `kappa(W) = log_2(card W) / k - log_2 rho`, for `card W` the allowed windows, is the bits per digit a rule spends on memory and is zero on every memoryless design `W = F^k` with `F` non-empty, so every width-one rule reads zero (witness: `mrlynum::memory::kappa` and `allowed_windows`, test `width_one_is_the_memoryless_design`)
- 2026-09-13 [Verified] The plastic rule, `dim = 1` width `3` code `54`, accepts `2, 4, 4, 5, 7, 9, 12, 16` words at levels one to eight, Perron root `1.324717957` the plastic number, the real root of `x^3 - x - 1`, and memory number `0.260981` (witness: `mrlydemo::memory::memory_read`, test `the_width_three_presets_name_the_plastic_and_tribonacci_roots`, check row `memory plastic root`)
- 2026-09-13 [Verified] The tribonacci rule, `dim = 1` width `3` code `127`, which forbids only the window `111`, accepts `2, 4, 7, 13, 24, 44, 81, 149` words at levels one to eight, Perron root `1.839286755` the tribonacci constant, the real root of `x^3 - x^2 - x - 1`, and memory number `0.056639` (witness: `mrlydemo::memory::memory_read`, test `the_width_three_presets_name_the_plastic_and_tribonacci_roots`, check row `memory tribonacci root`)
- 2026-09-13 [Verified] The supergolden rule has memory number `kappa = 2/3 - log_2(1.465571232) = 0.115204` (witness: `mrlynum::memory::kappa`)
- 2026-09-13 [Proved] A width-`k` digit rule `W` in dimension `dim` at base `base` counts its accepted words by a path count: with states the `base^(dim(k-1))` words of `k-1` digit vectors and `A[x,y]` the number of allowed windows with prefix `x` and suffix `y`, `N_W(level) = 1^T A^(level-k+1) 1` for every `level >= k-1`, and at `k = 1` the matrix is `[card W]` so the count is `card W^level`, today's fill law. (witness: beneath.md, The transfer matrix)
- 2026-09-13 [Proved] A width-`k` rule in dimension `dim` is a subset of the corners of the `k dim`-cube, so the raw census `2^(base^(k dim))` is the design count at dimension `k dim` and transports unchanged, while the quotient does not: cube symmetry acts diagonally on the `k` windows, so the group is `B_dim` of order `2^dim dim!` and not `B_(k dim)` of order `2^(k dim) (k dim)!`. (witness: beneath.md, Width k in dimension dim is a subset of the k dim-cube)
- 2026-09-13 [Proved] The coupling `kappa(W) = log(card W)/(k log base) - log(rho(A))/log(base)` of a width-`k` rule is nonnegative, by cutting an accepted word of length `mk` into its `m` disjoint windows so that `N_W(mk) <= card W^m`, while `rho^(level-k+1) <= N_W(level)` by the entry sum of `A^(level-k+1)`; and `kappa = 0` on every product `W = G^k` with `G` non-empty, where `N_W(level) = card G^level` and `rho = card G`, so every memoryless design with a non-empty rule sits at coupling zero. (witness: beneath.md, The coupling)
- 2026-09-13 [Proved] Memory does not leave the lattice class: the counting series `sum_level N_W(level) x^level` of a width-`k` rule is rational with denominator `det(I - x A)`, so at `x = base^(-s)` its poles sit on finitely many vertical lines `Re s = log(abs(lambda))/log(base)` over the nonzero eigenvalues `lambda` of `A` and the pole set is invariant under `s -> s + 2 pi i / log base`, the same period as the memoryless case; one line can carry a finer progression, as at `dim = 1`, `k = 2`, code `6`, whose eigenvalues `1` and `-1` put poles at gap `pi / log base` on `Re s = 0`. (witness: beneath.md, What the dial does not buy; lab/py/memory-census, the class of code 6)
- 2026-09-14 [Proved] The class count of width-`k` binary rules under `G_(1,k)` is `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`, by Burnside over the order-4 group: 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 reproduces `3, 9, 88, 16960` and every Burnside extension term through `k = 8` (witness: lab/py/memory-census verb `burnside`, the cycle index and the closed form agreeing at `k = 1..11`, and beneath.md, The memory dial).
- 2026-09-14 [Proved] At `dim = 1` and `k >= 2` every 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}`; checked over all `16, 256, 65536` rules at `k = 2, 3, 4` (witness: lab/py/memory-census verb `lemmas`, a Bareiss determinant and the signed block product agreeing in `{-1,0,1}` on every rule at `k = 2, 3, 4`, and beneath.md, The memory dial).
- 2026-09-14 [Proved] Distinct minimal polynomials of the Perron root are distinct Perron roots: 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; the `3, 4, 10, 177` minimal polynomials at `dim = 1` and `k = 1..4` are therefore `3, 4, 10, 177` distinct growth rates (witness: lab/py/memory-census verb `lemmas`, no conjugate above `rho` on any of the 463 characteristic polynomials at `k = 1..4`, the 3, 4, 10, 177 minimal polynomials carrying 3, 4, 10, 177 distinct `rho`, and beneath.md, The memory dial).
- 2026-09-14 [Verified] Second generators reproduce the memory census whole: a cycle-index Burnside counter gives `3, 9, 88, 16960, 1074036736, 4611686053860868096` under `G_(1,k)` at `k = 1..6` and `6, 4660, 1152921592116822016` under `G_(2,k)` at `k = 1..3`, with the remaining extension terms at `k = 7, 8` and `k = 4` agreeing as well, and an exact integer Faddeev-LeVerrier enumeration over all rules, factored in PARI, gives `3, 6, 23, 431` characteristic polynomials and `3, 4, 10, 177` minimal polynomials at `dim = 1` and `k = 1..4` (witness: lab/py/memory-census verb `burnside` at `dim = 1`, the census run's Burnside extension at `dim = 2`, verb `lemmas` for the polynomial counts, every cell reproduced).
- 2026-09-14 [Verified] None of the memory-census counts is in the local OEIS dump: `3, 9, 88, 16960` with every Burnside extension term through `k = 8`, `6, 4660` with its extension through `k = 4`, `3, 4, 10, 177` and `3, 6, 23, 431` each grep to zero hits as comma-delimited runs, while `3, 10, 136, 32896` hits A055708, A056006 and A191363 through the coincidence `2^(2^k-1) + 2^(2^(k-1)-1) = A007582(2^(k-1))`, and `9` and `16960` recur inside A367526, a grid tiling count with different neighbours (witness: grep of the local OEIS dump on the runs printed by lab/py/memory-census verb `burnside`, each hit read at source).
- 2026-09-14 [Verified] The binary words of length `n` counted under the same group that the width-`n` rules are counted under, reversal together with bitwise complementation, are A005418 at `n`: `1, 2, 3, 6, 10, 20, 36, 72` at `n = 1..8` (witness: lab/py/memory-census verb `burnside`, the word orbits printed beside the class count, agreeing with the entry in the local OEIS dump).
- 2026-09-14 [Verified] The Perron root of a transfer matrix is the largest root over the strongly connected components of its digraph, each component being irreducible with a simple root, so it is exact against that component's integer characteristic polynomial; at `dim = 1`, `k = 3`, code `5` gives `1`, codes `62`, `125` and `190` give the plastic number `1.324717957`, code `91` gives `1.380277569`, code `95` gives the golden ratio `1.618033989`, and the coupling of codes `125` and `190` is `log_2(6)/3 - log_2(1.324717957) = 0.455969`; a stop comparing one scalar across two sweeps halts on a plateau of the `I + A` mass ratio and misses all six (witness: mrlynum::memory::perron and its test, lab/rs/memory-meter).
- 2026-09-14 [Verified] The memory meter's control column is the Mertens function: the width-`1` rule of code `3` at base `2` accepts every integer, and its meter reads `-1, 1, 2, -23, -48, 212, 1037, 1928` at `10^1..10^8`, asserted inside the run, which is A084237 (witness: lab/rs/memory-meter, the `control mertens` line, and beneath.md, The memory meter).
- 2026-09-14 [Verified] The same linear sieve reproduces the memoryless base-`3` design meters exactly, so the memoryless row of the dial is pinned against the existing census: digits `{0,1}` read `(M, max abs M) = (11, 105)` at `level = 14`, `(149, 173)` at `level = 16` and `(-30, 312)` at `level = 18`, digits `{1,2}` read `(-1461, 1582)` at `level = 18`, each asserted; digits `{0,2}` at `level = 20` wants `3^20`, past the `2^30` sweep, and is printed unpinned at `level = 14, 16, 18` as `(-10, 67)`, `(-124, 152)` and `(67, 249)`. The four pinned pairs are read at source in lab/py/design-meter, which computes them and cites lab/rs/mobius-designs as their census (witness: lab/rs/memory-meter, the `control design` lines, and beneath.md, The memory meter).
- 2026-09-14 [Verified] The window-profile recurrence, `profile(n)` being `profile(n >> 1)` unioned with the window `n mod 2^k`, reads the accepted integer set of every width-`1`, `2` and `3` rule at `dim = 1`, base `2`: on all `276` rules its masses agree with a direct digit recount below `2^20`, profile containment agrees with `mrlynum::memory::Rule::accepts` below `2^12`, and at every one of the `89` phases the subset-sum transform of the per-profile `mu` sums equals the independently carried per-rule meter (witness: lab/rs/memory-meter, the `control recount` line, and beneath.md, The memory meter).
- 2026-09-14 [Verified] Code `7` at `(dim, k) = (1, 2)`, the golden rule forbidding the window `11`, opens exactly the fibbinary integers A003714 without its zero, and its mass below `2^level` is a Fibonacci number, `A = 2178309` below `2^30`; code `11`, forbidding `10`, opens exactly the Mersenne numbers A000225 without its zero and holds `30` elements below `2^30`, one per level (witness: lab/rs/memory-meter, the `control code 7` and `control code 11` lines, and beneath.md, The memory meter).
- 2026-09-14 [Verified] The Mobius meter of every width `1`, `2`, `3` rule at `dim = 1`, base `2`, read to `2^30` at the `89` phases `x = floor(2^(level + j/4))`, `level = 8..30`, `j = 0..3`, no exponent fitted, each ratio at a named phase: at `30.00` the full line reads `A = 1073741824`, `M = -10374`, `max abs M = 11173`, ratios `-0.316589` and `0.340973`; the golden rule code `7` at `k = 2`, `kappa = 0.098239`, reads `A = 2178309`, `M = 551`, `max abs M = 716`, ratios `0.373329`, `0.485125`; the `k = 3` least codes `23`, `54`, `127` read normalised peaks `0.731125`, `0.677943`, `1.239625` at `kappa = 0.115204, 0.260981, 0.056639` (witness: lab/rs/memory-meter, the `rule` and `row` lines, and beneath.md, The memory meter).
- 2026-09-14 [Verified] A rule's `rho` and `kappa` are read off the transfer matrix of its word language while `A` and `M` are read off its integer set, and on a rule that is not zero-closed those are different objects: at `k = 3` code `5` the word language grows on the self-loop `000` and carries `rho = 1`, while the integer set holds `3` elements below `2^30` (witness: lab/rs/memory-meter, the `rule k=3 code=5` line, and beneath.md, The memory meter).
- 2026-09-14 [Verified] Over the census of `53` rules of all three widths holding at least `10^4` integers below `2^30`, the floor fixed before any reading, the normalised peak `max abs M_W/sqrt(A_W)` spans `[0.293624, 1.239625]` at phase `30.00`, least on `k = 3` code `125` and largest on `k = 3` code `127`, and spans `[0.500000, 2.169240]` over all `89` phases, the top on `k = 3` code `232` at phase `16.75`; the last-phase leader and the sweep-wide leader are different rules, so no rule is the dial's widest excursion (witness: lab/rs/memory-meter, the `span` lines, and beneath.md, The memory meter).
- 2026-09-14 [Verified] Read against the full line at the same phase, which needs no band and no grid, the factor `max abs M_W/sqrt(A_W)` over `max abs M/sqrt(x)` runs `[0.861136, 3.635552]` at phase `30.00` over the `53` census rules and reaches `6.375774` on `k = 3` code `190` at phase `12.75` over all phases (witness: lab/rs/memory-meter, the `factor` lines, and beneath.md, The memory meter).
- 2026-09-14 [Verified] Grouped by the coupling over the same `53` rules at phase `30.00`, the mean normalised peak reads `0.340973` on `kappa = 0` with `3` rules, then `0.622171` on `6`, `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)`; every band of positive coupling sits above the `kappa = 0` band, whose three rules are the full line under three codes, and among the positive bands the means are not monotone in `kappa`. 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` (witness: lab/rs/memory-meter, the `kappaband` lines, and beneath.md, The memory meter).
- 2026-09-14 [Verified] The full line's own normalised peak runs `[0.272410, 0.500000]` over the grid, the ceiling at phase `8.00`, and that ceiling is a property of where the grid starts and not of the full line: below the grid the same ratio reads `1.000000` at `x = 1`, `0.894427` at `5`, `0.832050` at `13`, `0.718421` at `31` and `0.565685` at `200` (witness: lab/rs/memory-meter, the `gridstart` line, and beneath.md, The memory meter).
- 2026-09-14 [Verified] The falsification fires. Five of the `53` census rules never enter the full line's band 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. The band's ceiling being grid-dependent, the same-phase factor is the instrument that carries the reading, and it is read rule by rule on the generator's `factor` lines (witness: lab/rs/memory-meter, the `band outside` lines, and beneath.md, The memory meter).
- 2026-09-14 [Verified] `16` 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. No rule at any width holding at least `1000` elements has `M_W/sqrt(A_W)` or `max abs M_W/sqrt(A_W)` rise at every one of the last eight phases, but that test asks `max abs M_W` to grow about `9%` per quarter-level across two whole levels, so its empty answer carries little and the late-peak count is the informative statistic (witness: lab/rs/memory-meter, the `latepeak` and `climbing` lines, and beneath.md, The memory meter).
- 2026-09-14 [Verified] Leading zeros move most rules' integer sets. A rule is zero-closed when prepending one zero changes no membership below `2^20`: 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 the codes allowing `0` with the empty code, those allowing `01`, and those allowing both `010` and `011`, asserted code for code. Under any number of zeros the word language agrees with the integer set on `2` of `4`, `4` of `16` and `16` of `256` codes, tested on every word to length `14`, so at `k = 3` the two readings part company on `240` of `256` (witness: lab/rs/memory-meter, the `zeroclosed` and `reading` lines, and beneath.md, The memory meter).
- 2026-09-14 [Verified] Equal mass is not the same set: code `14` at `k = 2`, forbidding `00`, and code `126` at `k = 3`, forbidding `000` and `111`, each hold `28655` integers below `2^20` and each carry `rho = 1.618033989`, yet they share only `1077` of them, the symmetric difference is `55156`, and `4` is the least integer the second holds and the first does not; below `2^30` both hold `3524576` integers while their meters read `-466` and `435` and their normalised peaks `0.454355` and `0.594444` at phase `30.00` (witness: lab/rs/memory-meter, the `pair` line, and beneath.md, The memory meter).
- 2026-09-14 [Verified] The matrix ladder of a memory design runs in double precision in the public crate. `mrlynum::automaton` carries `Automaton`, `zeta`, `cofactor`, `residue` and `denominator`, every value beside its bound. The full rules, code `15` at `k = 2` and `255` at `k = 3`, meet `mrlynum::ladder` on the base 2 full design to `7.18e-11` at `s = 2` and `2.03e-14` at `s = 0.3 + 40i`, inside bounds; the product rule code `8` meets a direct Mersenne sum to `1.12e-16`; the golden rule code `7` meets a direct fibbinary sum with its Fibonacci tail bound, and every pinned golden reading meets the arbitrary-precision control inside its own bound, the four `zeta_W` values to `3.0e-15` and the largest of the fourteen rows `1.134e-11` against `7.348e-11` (witness: mrlynum::automaton, lab/py/memory-zeta, beneath.md, The memory zeta).
- 2026-09-14 [Proved] The polynomial `beneath.md` names the string equation of a memory rule is also the denominator of the rule's Dirichlet series, strictly more than that page proves. `beneath.md` proves `det(I - x A)` denominates the counting series and names `det(I - base^(-s) A) = 0` the Moran replacement; the peel carries it to `zeta_W`, each level of `(I - base^(-w) T) G_P(w) = E_P(w) + sum_(l >= 1) binom(-w,l) base^(-w-l) Gamma_l G_P(w+l)` dividing by `det(I - base^(-w) T)`. So the poles of `zeta_W` lie in `base^(-s) lambda_i = base^m`, `lambda_i` a nonzero eigenvalue and `m >= 0` whole, and that determinant is the `m = 0` level's denominator, not the whole one (witness: mrlynum::automaton, beneath.md, The memory zeta).
- 2026-09-14 [Proved] Right of the abscissa the matrix ladder carries its bound as a nonnegative vector and needs no norm and no primitivity, which settles the Conjecture row the ladder unit left open. For nonnegative `y`, `abs((I - base^(-w) T)^(-1)) y <= sum_(i >= 0) (base^(-Re w) T)^i y` entrywise, since `abs(base^(-w)) = base^(-Re w)` and `T` is nonnegative; the remainder closes on the guide `v = (I + T)^60 1`, which meets `T v <= mu v` for the bracket's upper end `mu`, as `sum_(i > N) A^i y <= (max_u y_u/v_u) theta^(N+1)/(1 - theta) v`, `theta = base^(-Re w) mu < 1`. The seed is exact: `sum_(j >= P) E_j(sigma) <= base^(-(P-1)sigma) (I - base^(-sigma) T)^(-1) c_P` (witness: mrlynum::automaton, beneath.md, The memory zeta).
- 2026-09-14 [Proved] The residue of a memory zeta at a simple pole needs no eigenvector: the adjugate is the spectral projector in polynomial form. Faddeev-LeVerrier on `T` gives integer matrices `M_k` and integer coefficients `c_k` with `adj(I - x T) = sum_(k < n) x^k M_k` and `det(I - x T) = sum_(k <= n) c_k x^k`, so with `x = base^(-w)` and `N` the ladder numerator, `Res_(w0) zeta_W = 1^T adj(I - x_0 T) N(w0) / (-x_0 log base det'(x_0))`. The form is stable at the pole, where `det(I - x_0 T) (I - x_0 T)^(-1)` is not, and it dies exactly where the ladder unit said it would, at a multiple root, where `det'(x_0) = 0` and the pole order exceeds one (witness: mrlynum::automaton, beneath.md, The memory zeta).
- 2026-09-14 [Verified] The golden rule carries two genuine pole combs interleaving at half a tooth. `T` of code `7` at `k = 2` is `[[1,1],[1,0]]` and `det(I - x T) = 1 - x - x^2`, so one comb sits at `Re s = log_2 phi = 0.6942419136306174` with `Im s` in `2 pi Z / log 2` and one at `Re s = -log_2 phi` with `Im s` in `(2Z + 1) pi / log 2`, the argument `pi` of the negative eigenvalue shifting it half a period. The six residues at `m = 0` are under THE POLE COMB and none is zero. Comb two comes from the left-of-abscissa branch, so its path is the arbitrary-precision control and not the contour average: the six agree to `6e-16` and `4.3e-12` (witness: mrlynum::automaton, lab/py/memory-zeta, beneath.md, The memory zeta).
- 2026-09-14 [Verified] Burnol's Proposition 5.1 survives the memory dial verbatim: the residue at the abscissa is the limit of the level digit sums. For code `7` the direct sum of `n^(-alpha)` over the fibbinary integers of exactly `level` bits, over `log 2`, reads `0.946747043404283`, `0.946743630023052` and `0.946743410426742` at `level = 16, 20, 24` against the ladder's `0.946743395641970`, the gap falling like `2^(-level)` (witness: mrlynum::automaton, beneath.md, The memory zeta).
- 2026-09-14 [Verified] The matrix Lyndon cofactor is the determinant with its adjugate, and it reads on the whole `m = 0` comb where the series is singular. `Z_W(s) = det(I - base^(-s) T) zeta_W(s)` is carried as `det(I - base^(-s) T) D_(P-1)(s) + 1^T adj(I - base^(-s) T) N(s)`, so it never divides by the vanishing determinant; for 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`, while `zeta_W(0.8) = 9.536379694275015` is already climbing the pole at `0.6942419136306174` (witness: mrlynum::automaton, beneath.md, The memory zeta).
- 2026-09-14 [Proved] Left of the abscissa a matrix ladder has no free denominator bound, and the module buys one with the residual of its own inverse. `abs(1 - k base^(-w))` has no matrix analogue and the Neumann majorant diverges once `base^(-Re w) rho >= 1`, so the level closes on the computed inverse `C` certified against `R = I - (I - base^(-w) T) C`: for nonnegative `y`, `abs((I - base^(-w) T)^(-1)) y <= abs(C)(y + (max_u y_u) r/(1 - r) 1)` with `r` the max row sum of `abs(R)`, and the module raises when `r >= 1`. The second comb of code `7` is read only through that branch, at bounds near `4e-9` against `1.3e-13` on the first (witness: mrlynum::automaton, beneath.md, The memory zeta).
- 2026-09-14 [Verified] The matrix Lyndon cofactor `Z_W(s) = det(I - 2^(-s) T) zeta_W(s)` of the golden rule, code `7` at width `2`, has exactly `20` zeros in the box `-0.95 < Re s < 2`, `0.02 < Im s < 43.1`: the determinant strips both `m = 0` combs in one factor, leaving `Z_W` meromorphic there with exactly `4` simple poles, the level-one teeth on `Re s = -0.305758086`, so each cell count is its argument-principle winding plus the level-one teeth the cell holds; all `20` are located with largest `abs(Z_W)` `9.694e-12`, largest surviving phase step `0.999894` radians against a cap of one, largest propagated bound `1.474e-10`, nothing within `0.02` of an outer box edge, and identical cell rows and zeros at contour seeds `0.1`, `0.05` and `0.025`, at `7298`, `11777` and `21599` evaluations, and with `0 < Im s < 0.02`, `Im s > 43.1` and `Re s < -0.95` uncounted, `20` is exact on the box (witness: lab/py/memory-zeta, verb `census`, and beneath.md, The memory zeta).
- 2026-09-14 [Verified] The `4` poles that census adds back are read and not assumed: a `48`-point circle mean of `Z_W` at each level-one tooth of code `7` gives residues `-1.990368154340-0.795661945868i`, `-0.350975872907-0.436714265460i`, `-3.135030562964-2.032376530959i` and `-1.028888122837+2.036528502776i`, radius `0.05` against 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`, and the same read at code `23` gives four residues of modulus `2.231820`, `3.226224`, `2.438482` and `1.779516`, the two radii agreeing to `5.1e-14`, against a blank point at `6.3e-16` (witness: lab/py/memory-zeta, verb `census`, and beneath.md, The memory zeta).
- 2026-09-14 [Proved] `Z_W` has no zero in `Re s >= 2` on code `7`: the least element of `S_W` is `1` and the coefficients are nonnegative, so `abs(zeta_W(s) - 1) <= zeta_W(2) - 1 < 1` there from `zeta_W(2) = 1.415825532885 < 2`, and `det(I - 2^(-s) T)` has no root right of the abscissa `log_2 phi`, which makes the census box's right edge a wall and not a choice (witness: lab/py/memory-zeta, verb `census`, and beneath.md, The memory zeta).
- 2026-09-14 [Verified] On code `7` the first comb carries a zero comb and the second carries none: at the design family census radius `0.45` all `4` teeth of the comb on `Re s = log_2 phi` below `Im s = 43.1` carry a zero, at distances `0.317490225`, `0.045406362`, `0.143076282` and `0.070233751`, while `0` of the `5` teeth on `Re s = -log_2 phi` do, least distance `0.666213518` and largest `0.758440773`, and the emptiness holds over every point of every disc, the radius `0.45` disc reaching `Re s = -1.144241913631`, since the same census on `-1.2 < Re s < 2`, which admits no new pole line before `-1.305758086369`, returns the same `20` zeros, nineteen to twelve decimals and the twentieth to eleven, the same `4` of `4` and `0` of `5` and the same five distances (witness: lab/py/memory-zeta, verb `census`, and beneath.md, The memory zeta).
- 2026-09-14 [Verified] The first-order tooth law `u_1 = -r/R` holds on code `7`'s first comb to `0.000951131`, `0.003342909`, `0.020403749` and `0.062287774` and misses on the second by `0.214394685`, `0.645682670`, `0.408924841`, `0.489190529` and `0.519744494`, and it is a reading beside the census and not a second falsification: `R` is a circle mean of radius `0.3`, three of the five second-comb predictions of `abs(u_1)`, `0.501975708`, `0.398920848` and `0.301764481`, are read outside that disc, and on the first comb the one prediction past `0.3` carries the worst miss (witness: lab/py/memory-zeta, verb `census`, and beneath.md, The memory zeta).
- 2026-09-14 [Verified] The second comb's line carries zeros where its teeth do not: three of code `7`'s `20` zeros sit within `0.05` of `Re s = -log_2 phi`, at `0.000322593`, `0.014258173` and `0.043369824` from that line, while their distances to the nearest tooth of the same comb are `4.104099275`, `0.747618761` and `4.283371881`, and stripping the `4` first-comb teeth leaves a second family of `16` with real parts in `[-0.737611737911, 0.540957439322]`; the excess is `4.4` times the `0.68` that `20` uniformly spread real parts would put in a window of width `0.1` on a box `2.95` wide, on a sample of `20` (witness: lab/py/memory-zeta, verb `census`, and beneath.md, The memory zeta).
- 2026-09-14 [Verified] Exactly `9` of the `88` width-`3` rule classes under `G_(1,k)` carry two pole lines, none with a repeated eigenvalue, and the cofactor's zeros are a resolved census on one printed box for all nine, `S_W` read off the minimal base-`2` string: `-1.15 < Re s < 2`, `0.02 < Im s < 20`, contour seed `0.05`, which holds every radius `0.45` occupancy disc of every second line, the deepest reaching `Re s = -1.144241913631`; the nine read `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, largest propagated bound `9.110e-09`, and no pole of `Z_W` within `0.02` of any contour, the least clearance being exactly `0.02`, from the cut `Im s > 0.02` to the level-`m` pole on the real axis. Resolved and not certified: nothing bounds `Z_W'/Z_W` on the contour, and two zeros sit within `0.02` of the left contour, `-1.134547677+3.580553251i` on code `127` and `-1.143621954+17.814806003i` on code `63` (witness: lab/py/memory-zeta, verb `teeth`, and beneath.md, The memory zeta).
- 2026-09-14 [Verified] The occupancy reading is invariant across two boxes whose contours fail a `0.02` guard in disjoint ways. On `-1.2 < Re s < 2` the pole lines `Re s = -1.202842615688` of codes `54` and `62` and `Re s = -1.188629537248` of code `223` sit `0.002842615688` and `0.011370462752` from the left contour, the first pair outside the box and so never added back; on `-1.15 < Re s < 2` every pole clears `0.02` and two zeros do not. Both boxes read `50` teeth, `34` occupied at radius `0.45`, `23` teeth predicting `abs(u_1) < 0.3` occupied `22`, `15` predicting at or above `0.45` occupied `4`, `12` between occupied `8`, and the same occupancy column on all nine rules; only the totals off the discs move, code `23` from `13` zeros to `11` and code `31` from `14` to `13` (witness: lab/py/memory-zeta, verb `teeth`, at `--left -1.2` and `--left -1.15`, and beneath.md, The memory zeta).
- 2026-09-14 [Proved] With `S_W` read off the minimal base-`2` string, so that a word shorter than the window holds no window and is accepted, the width-`3` rule `55` accepts exactly the set of the width-`2` rule `7` with the single integer `3` adjoined, hence `zeta_55(s) = zeta_7(s) + 3^(-s)`. Code `55` forbids exactly the windows `011`, `110` and `111`, which is exactly the ban on an adjacent pair of ones inside a `3`-window, and for length at least `3` the window starting at `min(i, level-3)` holds the pair at `(i, i+1)`, while the word `11` carries no window and is accepted; checked over `1 .. 262143` with `3` the only difference either way. Padded to the window width instead the two sets are equal and the claim is empty (witness: lab/py/memory-zeta, verb `bridge`, and beneath.md, The memory zeta).
- 2026-09-14 [Verified] The width-`3` ladder meets the controlled width-`2` one across that gap, which is the control on a new rule: `Z_55(s) - Z_7(s) - det(I - 2^(-s) T) 3^(-s)` reads at most `1.168e-13` over seven points including three teeth and one located zero, every point inside the sum of its own two bounds, so the `4`-state ladder, adjugate and peel meet the `2`-state ones that carry the stored arbitrary-precision control, itself met to `1.134e-11` on `14` rows with none outside its bound (witness: lab/py/memory-zeta, verbs `bridge` and `control`, and beneath.md, The memory zeta).
- 2026-09-14 [Verified] One tooth of the `50` carries two zeros inside the occupancy radius, so `34` occupied teeth hold `35` zeros: code `54`, second line, tooth `Re s = -0.202842615688`, `Im s = 14.612532469`, holds `0.213711738933+14.629308261174i` at `0.416892021` and `-0.597460129789+14.668266829134i` at `0.398533940`, and `abs(u_1) = 0.631828588` there puts it in the bin the first-order law reads as empty. The other `49` teeth hold at most one, and the count is printed by the census itself as `tooth zeros 6` against `5` occupied teeth on that rule (witness: lab/py/memory-zeta, verbs `teeth` and `census --width 3 --code 54`, and beneath.md, The memory zeta).
- 2026-09-14 [Proved] For a finite set `F` of positive integers disjoint from `S_W`, the set `S_W + F = S_W u F` has `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 poles, the same orders and the same residues at every point of the plane, and `Z_(W+F)(s) = Z_W(s) + det(I - base^(-s) A) P_F(s)`; adding a finite set is a knob on the zero set alone (witness: lab/py/memory-zeta verb `dial`, the off-tooth identity `Z_(W+F)(s) - Z_W(s) - det(I - 2^(-s) T) P_F(s)` 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`).
- 2026-09-14 [Proved] The knob cannot move the cofactor at a tooth: at every `m = 0` tooth `t` the determinant vanishes, so `Z_(W+F)(t) = Z_W(t)` exactly, 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 is `u_1(F) = -r/(R + P_F(t))`; every higher coefficient of the regular part moves too, the linear one by `P_F'(t) = -log(n) n^(-t)` (witness: lab/py/memory-zeta verb `census`, code `55` at width `3` reading `r = 0.210170579-0.581938843i` at `Im s = 9.064720` digit for digit against code `7`'s and `R = 1.313430833+1.119663028i` against `1.714940435+0.882338583i`, a difference of `-0.401509602+0.237324445i` which is `3^(-t)` to nine decimals).
- 2026-09-14 [Verified] The residue and tooth probes of the dial cannot falsify the perturbation's entirety and the off-tooth identity can: a `48`-point circle mean annihilates an entire addition and the determinant vanishes at a tooth, so the printed gaps are an aliasing floor and a determinant residual and not a measurement, while the identity read off the teeth agrees to fifteen decimals against an added part of order one (witness: lab/py/memory-zeta verb `dial`, `largest residue gap over every probe 1.776e-15, largest tooth value gap 1.250e-13, largest off-tooth identity miss 2.384e-15 against an added part of up to 1.912203` at code `7`).
- 2026-09-14 [Verified] The dial's disc probe reproduces the zero census it is read against: on code `7` at width `2` it reads `4` of `4` teeth occupied on the comb at `Re s = log_2 phi` and `0` of `5` on the comb at `-log_2 phi`, and on code `23` at width `3` it reads `3` of `4` on the first comb and `7` of `10` on the second line, each occupancy an argument-principle count on a circle of radius `0.45` about the tooth with the level-`m` poles inside added back (witness: lab/py/memory-zeta verb `dial`, `edge guard splits 0` on both baselines, a guard that covers the baselines and not the perturbed grid).
- 2026-09-14 [Verified] Occupancy at radius `0.45` under the knob is undetermined wherever a zero sits within the `0.02` guard of the occupancy circle and the inner count is `0`, which is `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 code `23`'s second line, so a minimum taken over a tooth's candidate row has two readings and the reading must be named (witness: lab/py/memory-zeta verb `dial`, per-line rows `occupancy undetermined 9`, `occupancy undetermined 10` and `occupancy undetermined 9`).
- 2026-09-14 [Verified] Every empty tooth of code `7`'s second comb is occupied by a single added integer from the `22` integers of `2 .. 40` outside `S_W`, so the smallest `F` that occupies a tooth of the empty comb has one element and that element is at most `11` under either reading of the seam, while the least singleton itself is radius-dependent at two of the five teeth: `{3}`, `{6}`, `{7}`, `{11}`, `{11}` on the inner reading against `{3}`, `{6}`, `{3}`, `{11}`, `{6}` on the outer, at `Im s = 4.532360`, `13.597080`, `22.661801`, `31.726521` and `40.791241` (witness: lab/py/memory-zeta verb `dial`, per-tooth rows `smallest singleton` and `outer reading occupied ... smallest singleton`).
- 2026-09-14 [Verified] Occupancy moves both ways on code `23` and the count is stable under either reading of the seam: four empty teeth are filled, `Im s = 9.064720` by `{7}` or `{6}`, `20.807773` by `{5}`, `29.872493` by `{7}` and `38.937214` by `{15}` or `{11}`, and two occupied second-line teeth are emptied by a singleton off the seam, `2.678332` by `{6}` and `42.645269` by `{6}` and by `{7}`, so `6` of the `14` teeth of the box change occupancy under a one-element perturbation (witness: lab/py/memory-zeta verb `dial`, `occupied teeth emptied by a singleton 2`, both emptied teeth printing an empty seam list).
- 2026-09-14 [Verified] The dial meets the cross-width control exactly where one exists: `S_7 + {3}` is `S_55`, and the dial's grid at code `7` with the added element `3` reads the second comb's tooth at `Im s = 4.532360` occupied and the tooth at `13.597080` empty, which is the `1` of `2` the width-`3` four-state ladder prints for code `55` (witness: lab/py/memory-zeta verbs `dial`, `bridge` and `census`, `bridge` reading `Z_55 - Z_7 - det(I - 2^(-s) T) 3^(-s)` at most `1.168e-13` over seven points and the code `55` census reading `zeros in the disc 1` at `4.532360` and `0` at `13.597080`).
- 2026-09-14 [Verified] The exact minimum of `abs(R + P_F(t))` over all `4158861` subsets `F` of size at most `16` of the `22` integers of `2 .. 40` outside `S_W` is `1.095277075`, `0.784350607`, `1.295268436` and `1.662786204` at code `7`'s four abscissa-comb teeth, the greedy chain attains every one of them, and the disc at each exact minimiser keeps its zero off the seam, `1/1`, `2/2`, `1/1` and `1/1`, the tooth at `Im s = 18.129441` gaining a second zero rather than losing its first (witness: lab/py/memory-zeta verb `dial --deep 16`, rows `exact minimiser over the 4158861 subsets of size at most 16`).
- 2026-09-14 [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`: over all `89` phases every one of the `53` census rules has its sweep-wide maximum of `max abs M_W/sqrt(A_W)` inside `[0.500000, 2.169240]` and its same-phase factor against the full line inside `[0.861136, 3.635552]` at phase `30.00`, the sweep-wide maximum being `6.375774` on code `190` at phase `12.75`, with `16` of `53` peaking in the last quarter of the grid, against Mullner 2017, which gives `M_W(x) = o(x)` for an automatic set and no rate at all. A band at finite depth is not a rate and nothing here bounds the constant (witness: lab/rs/memory-meter, Mullner 2017, and beneath.md, The memory meter).
- 2026-09-14 [Conjecture] What selects an occupied tooth is the first-order quantity `u_1 = -r/R`, the residue of `zeta_W` at the tooth against the regular part of `Z_W/det`, and not the spectrum. Over the `50` teeth of the nine two-line classes at width `3`, `34` teeth are occupied at radius `0.45`, the `23` whose prediction `abs(u_1)` falls below `0.3`, inside the radius `0.3` 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 one exception inside `0.3` is code `55`'s second-line tooth at `Im s = 13.597080`, `abs(u_1) = 0.267301885` with the nearest zero at `0.497761908`. Occupancy is a per-tooth Boolean and the law is a law on `abs(u_1)`: the largest modulus miss `abs(d - abs(u_1))` is `0.739013203` and the largest vector miss `abs(z - t - u_1)` is `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` (witness: lab/py/memory-zeta, verb `teeth`, and beneath.md, The memory zeta).
- 2026-09-14 [Conjecture] The knob's strength at a tooth `t` is `abs(n^(-t)) = n^(-Re t)` and its direction the phase `-Im(t) log n` mod `2 pi`, so on a line with `Re t < 0` the strength grows with `n` and the largest candidate still reading empty rises with the tooth height, while on the abscissa comb, where `Re t = log(rho)/log(base) > 0`, the strength decays and the flippers are confined to a bounded range of `n` that the phase selects inside: code `7`'s second comb reads `11`, `25`, `28`, `35` on the inner seam convention and `11`, `24`, `28`, `35` on the outer, increasing under both, over a candidate range stopping at `40` (witness: lab/py/memory-zeta verb `dial`, per-tooth rows `last candidate reading empty` on both readings).
- 2026-09-14 [Refuted] The Euler wall of `zeta.md` stands over the memory dial and its construction does not. The conclusion transfers: `S_W` for code `7`, the fibbinary integers, holds the coprime pair `5` and `9` whose product `45 = 101101` carries adjacent ones and leaves the set, so the indicator of `S_W` is not multiplicative and no Euler product over primes exists; `45` is the least such product over all coprime pairs of `S_W` below `2^16`. The construction does not: `zeta.md` builds its witness from the repunits `R_c` and `R_(c+1)` of the least missing digit `c`, and a memory rule has no missing digit to take the least of (witness: mrlynum::automaton, beneath.md, The memory zeta).
- 2026-09-14 [Refuted] "A memory rule's second pole comb carries no zero comb": the supergolden rule, code `23` at width `3`, has `det(I - x T) = 1 - x - x^3`, one comb on `Re s = log_2 psi = 0.551463089746` and two interleaved on `Re s = -0.275731544873` from the conjugate eigenvalue pair of modulus `psi^(-1/2)`, and its census on `-0.75 < Re s < 2`, `0.02 < Im s < 43.1` reads `24` zeros in `70` cells, largest phase step `0.998514`, of which at radius `0.45` the first comb holds `3` of `4` teeth and the second line holds `7` of `10`, least distance `0.170257380` (witness: lab/py/memory-zeta, verb `census`, and beneath.md, The memory zeta).
- 2026-09-14 [Refuted] "Symmetric pole combs give a symmetric zero set": code `7`'s two combs sit symmetrically about `Re s = 0` and code `23`'s about `Re s = 0.137865772436`, yet under reflection in that line no zero of either census has a partner other than itself within `0.05` in both coordinates, `0` of `20` and `0` of `24`, there being no functional equation on either side; the exclusion bites once, code `7`'s zero `-0.023033432741+33.122746617086i` sitting `0.046066865482` from its own reflection and being the only self-match inside the tolerance on either census, code `23`'s nearest missing at `0.075316339787` (witness: lab/py/memory-zeta, verb `census`, and beneath.md, The memory zeta).
- 2026-09-14 [Refuted] No function of the spectrum selects an occupied comb, which is the falsification L7 named. 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 same two combs, `Re s = log_2 phi` at argument `0` and `Re s = -log_2 phi` at argument `pi`, and the same teeth; on the second line at radius `0.45` they read `1` of `2`, `0` of `2` and `0` of `2` occupied, least tooth-to-zero distances `0.264392586`, `1.259215316` and `0.702616482`. Codes `54` and `62` share the whole spectrum, `det(I - x T) = 1 - x^2 - x^3`, and differ on both lines, `2` against `1` and `3` against `4`. Two rules with one spectrum reading two occupancies kills every function of it, monotone, threshold or otherwise; the ratio `abs(lambda_2)/rho` is neither, code `223` at `0.430159709002` reading `0` of `4` while code `127` at the smaller `0.400890564601` reads `2` of `4` and code `62` at `0.655865618097` reads `4` of `4` against code `31` at `0.563624162161` reading `2` of `4` (witness: lab/py/memory-zeta, verb `teeth`, and beneath.md, The memory zeta).
- 2026-09-14 [Refuted] The pole data cannot select occupancy at all, the residue included, and one line proves it: `zeta_55 - zeta_7 = 3^(-s)` is entire, so codes `55` and `7` carry the same poles, the same orders and the same residues at every `m >= 0`, while their zero sets differ, 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. Read at `m = 0` through the determinant the residues agree digit for digit, `-0.259501222742937-0.592535006433179i` at `-log_2 phi + pi i/log 2` and `0.896350590641921+1.403072744223695i` at `-log_2 phi + 3 pi i/log 2` from both rules (witness: lab/py/memory-zeta, verb `bridge`, and beneath.md, The memory zeta).
- 2026-09-14 [Refuted] The first-order quantity `u_1(F) = -r/(R + P_F(t))` selects occupancy under perturbation on the abscissa comb: at code `7`'s tooth `Im s = 9.064720` the exact minimiser `F = [3, 6, 11, 12, 19, 22, 23, 35, 38, 39]` 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 `1/1` with no seam (witness: lab/py/memory-zeta verb `dial --deep 16`, row `exact minimiser ... predicted abs(u1) 0.564905571 emptying threshold abs(r)/rho 1.374951382 zeros in the disc 1/1`).
- 2026-09-14 [Refuted] The first-order quantity is a selector across the perturbed family on a subdominant line: on code `7`'s second comb the grid holds `110` cells of which `77` read occupied, the law calls `75` right and the constant `occupied` predictor `77`, and on code `23`'s second line, `270` cells and `222` occupied, the law calls `218` against `222`; the deficit only widens on the outer reading of the seam, `80` against `86` and `219` against `231` (witness: lab/py/memory-zeta verb `dial`, per-line rows `first-order law agrees` against `the constant occupied predictor agrees` on both readings).
- 2026-09-14 [Refuted] Only the smallest added integers flip a tooth of the abscissa comb: code `23`'s empty tooth at `Im s = 9.064720` is occupied by `{7}`, `{13}` and `{14}` and by none of the smaller candidates `5`, `6`, `10`, `11` and `12`, so the flipping set is not an initial segment of the candidate list, and the two occupied teeth a singleton empties are emptied by `{6}` and `{7}` while the smaller candidate `5` occupies both (witness: lab/py/memory-zeta verb `dial`, code `23` tooth rows `measured 001000110000000000000000000 occupied 3 of 27`, `measured 101111111111111111111111111` and `measured 100111111111111111111111111`).
- 2026-09-19 [Proved] `G_(1,4) < G_(2,2) < B_4` as permutation groups of the `4`-cube, flipping all four bits being the diagonal `B_2` element that flips both axes and the width-`4` window reversal being 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 A000616 at `4`. Witness: lab/py/memory-census.