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.