Beneath a design

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

A design is three slots.

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

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

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

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

The memory dial

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

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

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

The transfer matrix

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

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

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

The coupling

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

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

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

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

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

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

The census

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

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

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

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

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

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

The famous constants are one notch in

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

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

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

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

What the dial buys

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

What the dial does not buy

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

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

The carry of a Collatz step

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

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

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

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

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

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

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

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

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

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

The memory meter

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

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

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

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

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

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

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

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

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

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

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

The memory zeta

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The radix dial

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

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

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

The fill law, and where it stops

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

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

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

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

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

The twist law

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

The named objects

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

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

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

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

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

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

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

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

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

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

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

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

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

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

What a plane lattice will not carry

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

The glue slot

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

Where the numbers live

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