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: mrlyrs::math::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 of the accepted set, at every dim, on every width-k rule with rho >= 1, is Proved by Mauldin and Williams 1988, the statement carried from the restatement of Abram and Lagarias 2012, Section 2.1, read at source. The upper bound is the cover in house, the cells of level L meeting the accepted set growing like rho^L, so dim_B = log_2 rho at every dim; the citation carries the lower bound, the accepted set being a finite union of similar copies of the construction object of a graph directed construction on the rule's live graph, the dead states pruned, one similarity of ratio 1/2 per edge, whose ratio matrix at exponent beta is 2^(-beta) times the live block of A, so Theorem 4 puts the dimension at the beta with 2^(-beta) rho = 1. ## The question mark writes the derivation, checks the hypotheses, cross-checks it at dim 1 against Furstenberg's theorem read in two restatements, and proves it by a second route, Hutchinson's, on every run-length rule, 18 of them in the census at widths 2 to 4. At rho = 0 the accepted set is empty and there is nothing to measure.

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 mrlyrs::num::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. The same split is the reading of Cloney, Goles and Vichniac 1987, whose Section 2 writes the even step as rule 170 and the odd step as equation (2.2) with two carry bits, and names the carry as what breaks the speed of light of a cellular automaton, propagating over a distance limited only by the bit structure of the argument, their witness 85 = 1010101 the alternating word u above. (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 mrlyrs::num::memory::Rule::new(1, k, code) with Rule::allowed(w) true when bit w of the code is set, and rho and kappa are mrlyrs::num::memory::perron and mrlyrs::num::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 mrlyrs::num::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.)

Every row of the table is a gasket ray of coprime: a word avoids the distances of the difference set exactly when its base-3 reading z puts (z, t z) on the gasket with t = sum_(j in supp m, j > 0) 3^j, so the dial's counts(W, L) equals the ray mass M_(L + deg m)(1, t) + 1 for every L >= deg m + 1, code 7 being the golden ray (1, 3) with F(n+1) - 1, code 23 the supergolden ray (1, 12) with A000930(n) - 1, code 279 the ray (1, 30) whose mass c(n-3) - 1 that page records at (7, 3), and codes 95 and 22015 the Fibonacci-product rays (1, 9) and (1, 27). (Proved, mrlyrs::num::memory::counts against lab/rs/dimension-one-ladder census.)

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. That is the theorem of Hicks, Mullen, Yucas and Zavislak 2008, whose polynomial 3n + 1 map is this same A with the halving written as a separate step, so their unique cycle is {1, x} where this page's is {1}; they bound the stopping time by deg(f)^2 + 2 deg(f), and their text sits behind the publisher, the statement read through Alon, Behajaina and Paran (arXiv 2401.03210). 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 mrlyrs::num::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 factor itself has one: 1/det(I - z A) at z = base^(-s) is the Artin-Mazur zeta of the subshift the rule accepts, exp(sum_(n >= 1) tr(A^n) z^n/n) = prod_gamma (1 - z^abs(gamma))^(-1) over its primitive periodic orbits, rational by Bowen and Lanford 1970, and on a design, where A is the scalar fill, it is the zeta 1/(1 - fill z) of the full shift on fill symbols that zeta writes as a Lyndon product. 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 mrlyrs::num::memory::perron and not off any enclosure (mrlyrs::num::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 (mrlyrs::num::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 (mrlyrs::num::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 (mrlyrs::num::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 (mrlyrs::num::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 question mark

The memory dial above and the radix dial below each turn one slot. This section reads two classical objects in the three-slot language: the Stern-Brocot tree, a base-2 design whose cell carries a 2 x 2 matrix product instead of a bit, and Minkowski's ?, which keeps the address word, swaps the continued fraction place slot for the dyadic one, and turns the reals whose partial quotients are restricted to a finite or cofinite alphabet into run-length rules of the memory dial. The mathematics of the second part is classical; the reading, the dimension lemma on the run-length rules and the table are the ink. Every number is lab/py/question-mark.

Stern-Brocot is a design with a rank-2 carry

Write s for the Stern diatomic sequence A002487, s(0) = 0, s(1) = 1, s(2n) = s(n), s(2n+1) = s(n) + s(n+1), and v(n) = (s(n), s(n+1)) for the row of two consecutive values. Reading n in base 2, v(2n + b) = v(n) M_b with M_0 = [[1,1],[0,1]] and M_1 = [[1,0],[1,1]], so v(n) = (0, 1) M_(d_1) M_(d_2) ... M_(d_L) over the digits of n most significant first, a leading zero changing nothing since (0,1) M_0 = (0,1). Proved. v(n) M_0 = (s(n), s(n) + s(n+1)) = (s(2n), s(2n+1)) and v(n) M_1 = (s(n) + s(n+1), s(n+1)) = (s(2n+1), s(2n+2)), the two lines of the recursion. (Verified with 0 mismatches on both forms below 2^16 and against the first 92 terms of the OEIS entry, lab/py/question-mark.) That is a linear representation, the matrix form of a 2-regular sequence in the sense of Allouche and Shallit 1992. The Calkin-Wilf row at depth d is s(n)/s(n+1) for 2^d <= n < 2^(d+1), and the Stern-Brocot row is the same list under bit reversal of the position (Verified, 0 mismatches through depth 12, lab/py/question-mark), so the tree at depth d is the level-d cells of a dim 1, base 2 design carrying at cell n the vector v(n) in place of a bit.

Where that sits on the dial. A width-k rule carries a state of k - 1 digits, finitely many, and its transition appends a digit and tests a window; the Collatz carry of ### The carry of a Collatz step carries two bits and reads the word once. Here the state is a vector in Z^2, unbounded, the transition is a matrix product, and the output is a weight and not a yes or no: a carry of rank 2 with infinitely many states. What it breaks is digit independence. M_0 M_1 = [[2,1],[1,1]] and M_1 M_0 = [[1,1],[1,2]], so the value of a word depends on the order of its digits: s(5) = 3 and s(6) = 2 on the words 101 and 110, the least such pair when a word is the digits of n without a leading zero, and s(3) = 2 against s(5) = 3 on 011 and 101 when the words are the 2^L cells of a level, leading zeros included. (Proved by the two products; Verified, lab/py/question-mark.) A level of a design is the Kronecker power of its rule, and a Kronecker power f(d_1) f(d_2) ... f(d_L) is invariant under every permutation of the digits, so from L = 3 on no level of s is a Kronecker power of any one-digit table; at L = 2 the cells read 0, 1, 1, 2, which no f(d_1) f(d_2) fits either, f(0)^2 = 0 and f(0) f(1) = 1 being incompatible. (Proved.)

The question mark swaps the place slot

Minkowski's ? sends the Farey subtree of [0,1] to the dyadic addresses: with the row at depth d the 2^d fractions inserted as mediants at that depth, sorted, node i goes to (2i + 1)/2^(d+1), the centre of cell i at level d + 1. (Verified with 0 mismatches through depth 12 on 8193 nodes, the mediant recursion ?((p+p')/(q+q')) = (?(p/q) + ?(p'/q'))/2 run exactly, lab/py/question-mark.) In three-slot terms ? keeps the address word and swaps the place slot: one word d_1 d_2 ... d_d names the Stern-Brocot node on one side and the dyadic cell on the other. Its closed form is Denjoy's, ?([0; a_1, a_2, ...]) = 2^(1 - a_1) - 2^(1 - a_1 - a_2) + 2^(1 - a_1 - a_2 - a_3) - ..., read in the restatement of Boca and Linden 2018, and that sum is the binary word 0.0^(a_1 - 1) 1^(a_2) 0^(a_3) 1^(a_4) ...: the partial quotients are the run lengths. Two consequences are exact. Proved. ?(1/(a + x)) = 2^(-a)(2 - ?(x)): the quotient a prepends 0^(a-1) 1 and complements what follows, so the continued fraction branch x -> 1/(a + x) becomes the similitude y -> 2^(-a)(2 - y) of ratio 2^(-a), a dyadic place map of a digits with a twist. Proved. ? conjugates the Farey map F(x) = x/(1-x) on [0, 1/2], (1-x)/x on [1/2, 1] to the tent map T(y) = 2y, 2 - 2y: at a_1 >= 2 both sides drop one leading zero, at a_1 = 1 both complement. (Both Verified exactly on the same 8193 nodes, the branch law at a = 1..5, lab/py/question-mark.) None of this is new; the reading is.

Let A be a set of positive integers and E_A the reals in (0,1) whose partial quotients all lie in A. Then ?(E_A) is the set of binary words whose runs, after the first, all have length in A, and that is a rule of the memory dial whenever A is finite or cofinite. At finite A with m = max A it is the width-(m+1) rule forbidding the windows 0^(m+1) and 1^(m+1), and 1 0^j 1 and 0 1^j 0 for the j < m outside A; at A = N \ F with f = max F it is the width-(f+2) rule forbidding 1 0^j 1 and 0 1^j 0 for j in F. At A = {1, ..., m} the rule forbids the two runs 0^(m+1) and 1^(m+1) and nothing else, and at m = 2 that is code 126, the rule ### The memory meter prints beside code 14. Call these the run-length rules. On the accept slot ? recodes the full shift over the alphabet A into a run-length rule over {0,1}, and on the place slot it turns x -> 1/(a + x) into y -> 2^(-a)(2 - y), a design-to-design map slot by slot. The run-length rules number 2^(k-1) - 1 + 2^(k-2) at width k, 2, 5, 11 at widths 2, 3, 4, on 11 distinct alphabets. The identification is exact up to the first run. Proved. Every word of ?(E_A) is accepted, and an accepted word lies outside ?(E_A) exactly when its leading run refuses the alphabet: a leading 0^j with j + 1 outside A, or a leading 1^j with 1 or j outside A. At A = {1, ..., m} the surplus is exactly the cylinder [0^m], which by the branch law at a = m + 1 is 2^(-m-1)(2 - ?(E_A)), an affine copy of ratio 2^(-m-1). (Verified at level 14 on all 18 codes with 0 accepted words missing: at code 126 the surplus is the 233 words opening on 00 among 1220 accepted, the 987 others the prefixes of ?(E_A); at code 219, A = N \ {1}, it is the 610 words opening on 1, lab/py/question-mark.) So the accepted set is ?(E_A) together with affine images of it, one per refused leading run, finitely many at finite A and countably many at cofinite A, and every dimension below is shared.

Proved, rho of a run-length rule. Write C(x) = sum_(a in A) x^a, and B(x) = x + ... + x^m at finite A, B(x) = x/(1-x) at cofinite A. An accepted word is a single run, or a first run, inner runs in A and a last run, so sum_L N_W(L) x^L = 2 (B + B^2/(1 - C)), whose least positive singularity is the root x_0 in (0,1) of C(x_0) = 1, B being finite there; by ### The transfer matrix rho = 1/x_0, the largest real root of the polynomial P_A cleared from sum_(a in A) rho^(-a) = 1, which is x^m - sum_(a in A) x^(m-a) at finite A and x^(f+1) - 2x^f + (x-1) sum_(j in F) x^(f-j) at cofinite A. (Verified on all 18 codes: P_A divides the exact characteristic polynomial of the transfer matrix and rho is its largest root, lab/py/question-mark.) A = {1,2} and A = N \ {1} are both the golden x^2 - x - 1, {1,3} and N \ {1,2} both the supergolden x^3 - x^2 - 1, {2,3} the plastic x^3 - x - 1 and {1,2,3} the tribonacci x^3 - x^2 - x - 1: the four constants of ### The famous constants are one notch in return as alphabets of partial quotients, at width 4 for the last three.

Proved, the Hausdorff dimension of a run-length rule is log_2 rho. Upward is a cover: the accepted set lies in N_W(L) cells of length 2^(-L) at every L, so dim_H <= log_2 rho for every rule of the dial. Downward, at finite A, ?(E_A) is compact and is the union of its images under the similitudes y -> 2^(-a)(2 - y), a in A, so it is their attractor; the images of (0,1) are the disjoint intervals (2^(-a), 2^(1-a)), so the open set condition holds and by Hutchinson 1981, 5.3(1), dim_H ?(E_A) is the D with sum_(a in A) 2^(-aD) = 1, which is log_2 rho by the polynomial above. At cofinite A the truncations A_n = A intersect [1, n] put ?(E_(A_n)) inside ?(E_A) with rho(A_n) increasing to rho(A), C_n increasing to C. That is the dimension identity of ### The transfer matrix, proved at every dim by citation in ### Every rule is a graph-directed continued fraction set and proved here by Hutchinson's route on every run-length rule at every width, 18 of them in the census at widths 2 to 4.

Two dimensions, one word count. The continued fraction side has its own Hausdorff dimension dim_H E_A, the zero of the pressure s -> log lambda(s) with lambda(s) the leading eigenvalue of L_(A,s) f(x) = sum_(a in A) (a + x)^(-2s) f(1/(a + x)) on [0,1], Lemma 1 of Jenkinson and Pollicott 2018 at finite A, read at source; its Theorem 1 gives dim_H E_2 = 0.53128050627720514162446864736847178549305910901839... and its Remark 3 restates the estimate 0.5312805062772051416 of Hensley 1996, not read here. ? sends E_2 to a set of dimension log_2 phi = 0.694241913630. Word counts and Perron roots travel with the address word; metric data do not, ? being Holder of order log 2 / (2 log phi) = 0.720210 and of no better order, Salem's theorem read in the restatement of Boca and Linden 2018. Proved. A Holder map of order alpha raises no Hausdorff dimension by more than the factor 1/alpha, a cover of E by sets of diameter d_i going to a cover by sets of diameter at most c d_i^alpha, so dim_H E_A >= alpha log_2 rho on every run-length rule, and at A = {1,2} the floor is alpha log_2 phi = 1/2 exactly. (Verified on all 18 rows, lab/py/question-mark.)

The two dimensions of a run-length rule

Every run-length code of the dim 1 census at widths 2 to 4, with rho from the code's own transfer matrix, log_2 rho, the pressure zero dim_CF and the Holder floor alpha log_2 rho. The pressure zero is found by bisection on the leading eigenvalue of L_(A,s) collocated on 40 Chebyshev-Lobatto points of [0,1], the map values read by barycentric interpolation; at cofinite A the sum runs to a = 2000 and the tail is the Taylor terms of the eigenfunction at 0 through order four against Hurwitz zeta. The controls run before the table and stop it on failure. Verified. A = {1,2} reads 0.5312805062772050, gap 1.1e-16 to the value above and at most 8.9e-16 between 24 and 56 modes; A = N reads 1.0000000000000000, the Gauss density 1/(1+x) being the eigenfunction at s = 1; A = N \ {1} reads 0.84088458641455 at every cut from 500 to 4000; and the transfer matrix convention is pinned on the four named codes 7, 23, 54, 127 before any row prints (lab/py/question-mark). Twelve digits are printed, truncated. At finite A the dim_CF column is dim_H E_A; at cofinite A it is dim_H E_A too, the theorem of Mauldin and Urbanski for an infinite alphabet read and its hypotheses checked in ### The pressure zero is the dimension, so every value is Verified as a number and Proved by citation as a dimension. A one-letter alphabet is the single point [0; a, a, a, ...], lambda(0) = 1 exactly, and prints 0 on both sides.

(Verified, lab/py/question-mark, 18 codes on 11 alphabets, every row passing its three assertions.) The same alphabet at two widths prints one row, which is the lift of ### The famous constants are one notch in read on the alphabet: {1} at codes 6, 36, 1056, {2} at 90, 4680, {1,2} at 126, 15996, N at 15, 255, 65535 and N \ {1} at 219, 54219. Two alphabets with one rho and two dimensions: {1,2} and N \ {1} share log_2 rho = 0.694241913630, because 2^(-2s)/(1 - 2^(-s)) = 1 and 2^(-s) + 2^(-2s) = 1 are one equation, and read 0.531280506277 against 0.840884586414 on the continued fraction side. The dyadic side sees an alphabet only through sum_(a in A) 2^(-as) = 1; the continued fraction side sees where the quotients sit.

What has no clean alphabet

Every run-length rule is fixed by the digit flip and by reversal, a run constraint reading both symbols and both directions alike, and the codes fixed by both number 4, 8, 64 at widths 2, 3, 4, so 2, 3, 53 symmetric codes carry no alphabet. (Verified, lab/py/question-mark.) At widths 2 and 3 the orphans are the dead code 0 and codes 9, 129, 165, which allow only the constant words or those and the alternating words (01)^n: their preimages under ? are finite sets, rho = 1, and the only finite E_A are the one-letter points. At width 4, 19 of the 53 carry rho > 1, the least being code 11892, which forbids 0000, 1111, 0001, 1000, 0111, 1110, 0011, 1100: runs of length 1 or 2 with two consecutive 2s forbidden, the alphabet {1,2} under a pair constraint, at the supergolden rho = 1.465571231876. On the continued fraction side that is {x : a_i in {1,2}, (a_i, a_(i+1)) != (2,2)}, a Markov set and not an E_A, whose pressure zero on the matrix transfer operator ### Every rule is a graph-directed continued fraction set builds is 0.416817764433. The codes not fixed by the flip put one alphabet on the odd quotients and another on the even. In general a forbidden window x^(r_1) y^(r_2) ... reads as a bounded-window constraint on consecutive partial quotients, the outer runs as lower bounds and the inner runs exact, with the parity of the position tracked, so every dim 1 rule of the census is a graph-directed continued fraction set, and the table above is the 18 rows where that constraint is one alphabet on every position.

Every rule is a graph-directed continued fraction set

This subsection closes two threads: the dimension of the accepted set of any rule with a cycle, by citation at every dim and by a second citation at dim 1, and the continued fraction side of the orphans, by the graph-directed form the last subsection named and did not build. Every number is lab/py/question-mark, verb graph.

Proved by Mauldin and Williams 1988, the Hausdorff dimension of the accepted set of a width-k rule with rho >= 1 is log_2 rho, at every dim. Read a width-1 rule as the width-2 rule allowing the windows (d, d') with both digits in W, the same accepted set and the same rho, so that k >= 2 and a state is a nonempty word. Let X_W be the infinite words all of whose windows lie in W, K_W the accepted set, the intersection over L of the union of the closed cells of the accepted words of length L, and pi(w) = sum_j d_j 2^(-j) in [0,1]^dim. K_W = pi(X_W): a point of K_W lies at every L in the closed cell of an accepted word, those words form a finitely branching infinite tree under prefix, Konig's lemma gives an infinite branch, accepted since each of its windows is a window of a prefix, and its cells shrink to the point. Prune the dead states, those from which no cycle is reachable: they are closed under successors and carry no cycle, so the transfer matrix is block triangular with a nilpotent dead block, the live block has the same rho, and rho >= 1 says the live block is nonempty. For a live state u let F_u be the set of pi(t) over the infinite walks t from u, nonempty and compact; then F_u is the union over the edges u -> v of (d + F_v)/2, d the digit vector the edge appends, and K_W is the union over u of pi(u) + 2^(1-k) F_u, a finite union of similar copies of the F_u. Seed one unit cube per live state, J_u = c_u + [0,1]^dim with the c_u spaced apart, and put on each edge u -> v the similarity T_(uv)(x) = c_u + (x - c_v + d)/2 of ratio 1/2: the seeds are nonoverlapping compact sets with interior, every live state has an edge out, each ordered pair carries at most one edge since v is u shifted with d appended, T_(uv)(J_v) = c_u + (d + [0,1]^dim)/2 lies in J_u, and for fixed u the images over distinct d are among the 2^dim subcubes of J_u, nonoverlapping. That is the geometric graph directed construction of Mauldin and Williams as Abram and Lagarias 2012, Section 2.1, restate it, Definition 2.1 and Propositions 2.2 to 2.4 attributed to Theorems 1, 3, 4 and 5 with page numbers, read at source, Mauldin and Williams's own text being reached here only through restatements; the nonoverlapping images are also the open set condition in the graph directed wording of Edgar and Golds 1998, Definition 3.11, read at source, with U_u the interior of J_u, a citation that carries no part of the claim. Its construction object is the list c_u + F_u, the unique nonempty compact invariant list. Two hypotheses of the restated definition need a word. It asks the underlying undirected graph to be connected, which the live graph may fail, code 9 at (1,2) being two loops with no edge between them: apply the theorem to each undirected component, whose objects sit apart, K_W being the finite union of their similar copies, its dimension the largest over the components and rho the largest of their Perron roots, so the value does not move; Baker, Dajani and Jiang 2014, Section 5.1, restate the definition without that condition, read at source, so whether it is Mauldin and Williams's own stays unread. And a loop, which the same restatement prints as allowed in its Definition 2.1 and reads as forbidden in its commentary, is removed by splitting its state into two copies joined both ways with the same exits, which changes neither the tails nor the growth rate of the walk count. The ratio matrix at exponent beta is 2^(-beta) A on the live block, A the transfer matrix, so on a strongly connected component H with a cycle its spectral radius is 2^(-beta) rho_H; Theorem 4 puts the dimension of the construction object at the largest beta_H with 2^(-beta_H) rho_H = 1 over the components with a cycle, a live state off every cycle being a trivial component with nothing to solve, which is log_2 max_H rho_H = log_2 rho, the radius of a block triangular nonnegative matrix being the largest over its diagonal blocks; Theorem 3 as restated, on the whole live matrix, gives the same beta. A finite union of similar copies has the dimension of its largest piece, so dim_H K_W >= log_2 rho. The citation carries only that lower bound: the closed cells of level L meeting K_W number between the accepted words of length L that extend to an infinite accepted word and 3^dim times them, a point lying in at most 3^dim closed cells of a level, and those words grow like rho^L as the dim 1 paragraph below counts them, so dim_B K_W = log_2 rho in house at every dim and dim_H <= log_2 rho is free. That is the dimension identity of ### The transfer matrix at every dim and every width on the rules with a cycle; at rho = 0 the accepted set is empty. At k = 1, dim 2, all four digits, the construction is the square and reads log_2 4 = 2: the total dimension in [0,1]^dim, not one per axis.

Proved by Furstenberg 1967, the dim 1 case again, on the circle. The statement is read in two restatements, Furstenberg's own text sitting behind a paywall and unread here. Kenyon, Peres and Solomyak 2012, Section 1: to a subset Omega of {0, ..., m-1}^N associate the reals whose base-m digit sequences belong to Omega; subshifts then correspond to closed subsets of [0,1] invariant under x -> mx (mod 1), and it is known from Furstenberg that all such sets have Hausdorff dimension equal to Minkowski dimension, equal to (log m)^(-1) times the topological entropy of the shift on Omega. Austin 2021, Section 3, names Proposition III.1 for dim A = dim_B A = h / log a on a closed A forward invariant under x -> ax with h the topological entropy of (A, x -> ax). The hypotheses hold on every width-k rule at dim 1 with rho >= 1. K_W = pi(X_W) is compact, is the set of reals with a binary digit sequence in X_W, and 2 K_W = pi(sigma X_W) subset K_W modulo 1: on the circle it is closed and forward invariant, and the quotient [0,1] -> R/Z identifies one pair of points and is an isometry on each half, so both readings of dim_H K_W agree. Its entropy is log rho. The topological entropy of a subshift is the growth rate of the number of words of length L occurring in it, an (n, 2^(-m))-separated set of {0,1}^N being a set of distinct words of length n + m; the words occurring in X_W lie between the accepted words that extend to an infinite accepted word and all accepted words, and with S = 2^(k-1) states every accepted word of length L >= k - 1 + S is an extendable word of length L - S followed by S digits, a state with a walk of S edges ahead having a cycle ahead and so an infinite walk; both counts therefore grow like rho^L by ### The transfer matrix. In house, the same count is the Minkowski dimension: the closed cells of level L meeting K_W number between the extendable words and three times them, a cell meeting K_W only at an endpoint sharing it with an extendable neighbour, so dim_B K_W = log_2 rho with no citation, and the citation carries dim_H = dim_B. The dyadic rationals of K_W with a second, refused expansion are countably many and move no dimension. Two routes, one number, and the second stays on the circle: at dim >= 2 the digit vectors live on T^dim, which the statement read does not cover. One corollary is exact. Proved. The Holder floor of ### The question mark swaps the place slot holds on every dim 1 rule with rho >= 1 and not only on the run-length rules: dim_H ?^(-1)(K_W) >= alpha log_2 rho with alpha = log 2 / (2 log phi).

Proved, every dim 1 rule is a finite graph-directed continued fraction set. Fix a width-k rule and, for a state u of ### The transfer matrix, a word of k - 1 digits with last digit u', let E_u be the set of x = [0; a_1, a_2, ...] such that feeding from u first a_1 copies of b = 1 - u', then a_2 copies of 1 - b, and so on, closes only allowed windows. The first run decides everything: E_u is the union over the edges u -a-> v of 1/(a + E_v), the edge existing exactly when the a copies of b close allowed windows and v being the state they leave. For a >= k the state left is b^(k-1) and the windows closed are those closed at a = k, so the labels from u to b^(k-1) are a subset of {1, ..., k-1} alone or together with every a >= k: a graph on 2^(k-1) states, each edge labelled by a finite or cofinite set of quotients, each label the branch x -> 1/(a + x), distinct labels sending (0,1) to the disjoint intervals (1/(a+1), 1/a). The parity of the position is the last digit of the state: the odd quotients are the runs of 0, the even ones the runs of 1, and a code not fixed by the digit flip constrains the two parities differently. The set R_W of x whose run word 0^(a_1 - 1) 1^(a_2) 0^(a_3) ... is accepted is a countable union of bi-Lipschitz images 1/(a_1 + 1/(a_2 + ... + E_u)) of the E_u, the quotients read until k - 1 digits are in, and each E_u is such a piece with the runs of u as its quotients, so dim_H R_W = max_u dim_H E_u; an infinite path from u ends inside one strongly connected component, so E_u is a countable union of bi-Lipschitz images of the limit sets of the components reachable from u, and dim_H E_u is the largest of their dimensions. ? sends R_W onto K_W less the words with finitely many runs, a countable set.

The dimension of a component is read from its pressure. The matrix transfer operator of the graph is (L_s F)_u(x) = sum_(u -a-> v) (a + x)^(-2s) F_v(1/(a + x)), which is L_(A,s) with the alphabet moved onto the edges, and dim_CF of a rule is the s at which the spectral radius of L_s over the recurrent states is 1; the radius of a block triangular operator is the largest over its diagonal blocks, so that zero is the largest of the component zeros, and a component that is a single labelled cycle, one point, has radius 1 at s = 0 and prints 0 without bisection. That this zero is dim_H of a component's limit set is the graph-directed Markov theorem of Mauldin and Urbanski, read in restatement with its hypotheses checked on these graphs in ### The pressure zero is the dimension: every dim_CF below is Verified as a number and Proved by citation as the dimension of its component's limit set, exactly as the cofinite rows of ### The two dimensions of a run-length rule. The collocation is that table's, 40 Chebyshev-Lobatto points per state, and a cofinite edge sums to a = 2000 with the same Hurwitz zeta tail; the graph itself is finite and never truncated. Two controls run before any row prints. Verified. On the 18 run-length codes the graph form recovers the table's pressure zero with a largest gap of 8.9e-16, the states whose last exact run lies in A carrying a copy of L_(A,s) and the others being dead. Verified. On code 11892 at level 14, 378 accepted words, 277 of them prefixes of ?(M) for M = {x : a_i in {1,2}, (a_i, a_(i+1)) != (2,2)}, 0 missing, and the 101 others opening on the leading runs 0 and 00, the leading run being a_1 - 1 and not a_1. By hand: 0000 and 1111 cap every run at 3, 0001, 1000, 0111, 1110 refuse a run of 3 beside any other digit, so an infinite accepted word has every run in {1,2}, and 0011, 1100 refuse two consecutive runs of 2; conversely a word with runs in {1,2} and no two consecutive 2s contains none of the eight, so the accepted infinite words are exactly the run words with every run, the leading one allowed empty, in {1,2} and no 22, and R_W is M together with two bi-Lipschitz pieces of it, the leading runs 00 and 0 11. Its graph has 6 recurrent states, the words of 3 digits other than 000 and 111, 10 finitely labelled edges and no cofinite one.

The 19 width-4 orphans with rho > 1, code 11892 first: the forbidden windows, the recurrent states, whether a cofinite edge lies in a cycle, rho, log_2 rho, dim_CF and the Holder floor, twelve digits truncated. Every row passes dim_CF >= alpha log_2 rho, the floor being a theorem on every rule by the corollary above.

(Verified, lab/py/question-mark, verb graph, 19 rows, 31 seconds with the controls.) Four rows land on ### The two dimensions of a run-length rule to twelve digits and say why: 22506 and 55275 allow an inner run of 1 only beside runs of 1, so their infinite words are the two alternating words and the run words over {2,3} and N \ {1}; 48765 refuses an inner run of 3 or more and reads {1,2}; 54699 refuses an inner run of 2 and allows an inner run of 1 only beside runs of 1, so reads N \ {1,2} and the alternating words. On 22506 and 48765 the recurrent block is literally L_(A,s) at a finite alphabet beside dimension-zero cycles, so their pressure zero is the dimension by the finite-alphabet rows of that table; on 54699 and 55275 it is the dimension by the citation below, as on the table's own cofinite rows. Code 60375, runs alternating between 1 and at least 2, is two copies of code 23 under the flip and prints its 0.762395011393. Orphans differing only in 0000 and 1111, 11892 and 44661, 14940 and 47709, differ by two points and print one row. The 8 rows with a cofinite edge in a cycle lie above 0.74 and the 11 finite ones below 0.58. One rho, many dimensions: the golden rho prints six distinct dim_CF on its six orphans, from 0.531280506277 to 0.887530492554, the dyadic side seeing only how many words there are and the continued fraction side where the quotients sit.

The finite orphans are certified. The pressure zero of each of the 11 orphans with no cofinite edge on a cycle, and of code 54, lies in the bracket of the table below, and on 11 rows the bracket truncates at twelve digits to the reading in the table above, while the widest, 31710, contains that reading. Proved (computer-assisted, lab/py/periodic-determinant, verb orphans, 48 seconds, interval arithmetic but for the winding sum). Each strongly connected component with a branch, the only graphs the count below is used on, is minimised by follower language, which keeps its pressure, the paths from a state being its follower words in both graphs, and every component falls to 1 or 2 states: 11892 and 44661 to {1,2} with the pair 22 forbidden, 22506 to {2,3}, 48765 to {1,2}. The determinant of Jenkinson and Pollicott 2018 then runs on the graph, with the weights conjugated as in apollonian, ## The horocycle, on a disc D of centre c and radius r with each T_a(closed D) inside the concentric disc of radius h r, h < 1, and W_a the sup of the weight of label a on D: on H^2(D)^S the operator (L_s F)_u = sum_(u -a-> v) w_a F_v o T_a has as n-th trace the sum over the closed walks of length n, each walk contributing as a periodic word does. abs(delta_n(s)) <= [z^n] prod_(k >= 0) (1 + C h^k z)^S with C = (sum_v Sigma_v/(1 - h^2))^(1/2) and Sigma_v = sum_u (sum_(u -a-> v) W_a)^2, W_a the sup of the weight on D. Proved: L_s sends the monomial m_k in slot v to a vector of norm at most h^k Sigma_v^(1/2), so the projection onto the S(n - 1) monomials of degree below n - 1 leaves s_(S(n - 1) + 1)(L_s) <= C h^(n - 1) by their Proposition 1, and their Lemma 2 gives the product, the elementary symmetric sums being increasing in each argument. At real s, when det(I - z L_s) has exactly p zeros in abs(z) < 2, p the period of the graph, D(s) < 0 exactly when the leading eigenvalue lambda_0(s) exceeds 1. Proved: scaling the slot of state u by omega^(j(u)), j the cyclic class and omega = exp(2 pi i/p), conjugates L_s to omega L_s, so lambda_0 omega^j are eigenvalues, lambda_0 = e^(P(s)) being one as on the Lipschitz functions; p zeros force lambda_0 > 1/2, so these p are all of them and each is simple, and det(I - z L_s) = (1 - (z lambda_0)^p) G(z) with G real on the axis, zero-free in abs(z) < 2 and G(0) = 1, so G(1) > 0 and D(s) has the sign of 1 - lambda_0. The generator checks the count at both ends of each bracket by the winding number on 360 arcs, the tail at radius 2 excluded on every arc; the count sums float angle steps between arc endpoints, which is sound because each arc's enclosure lies in an open half-plane, asserted, that the float endpoints share, so each step is the true one in (-pi, pi); the sign is read with the tail at radius 1. Every h and every tail in the table is an upper bound rounded up. Two rows repeat known sets, 22506 being E_(2,3) and 48765 being E_2, and two pairs share a graph, 11892 with 44661 and 14940 with 47709. Code 31710, growing at 2.73 per letter, stops at period 14 and eight digits. The eight rows with a cofinite edge on a cycle, 54699, 55275, 59799, 60375, 60855, 61431, 63903, 64479, three of the six golden rows among them, keep their collocation reading: the periodic points of an infinite alphabet cannot all be listed, and their bracket is the positivity lemma of Pollicott and Vytnova 2022, Lemma 3.3, with a Hurwitz tail.

The parity constraint shows on the codes not fixed by the flip. The four named codes of ### The famous constants are one notch in, read on the continued fraction side, the first quotient free as always:

(Verified, lab/py/question-mark, verb graph.) Code 7, the golden mean shift, is the reals whose even quotients are all 1 and prints 0.798858366966, where the run-length rules of the same rho print 0.531280506277 at A = {1,2} and 0.840884586414 at A = N \ {1}: three continued fraction sets on one word count, and three dimensions.

The pressure zero is the dimension

Two restatements carry the theorem behind every dim_CF above. Mauldin and Urbanski 1996, Theorem 3.15, is read in the restatement of Roy, Sumi and Urbanski 2008, Section 2, Theorem 2.3: for a conformal iterated function system on a countable alphabet, dim_H J = sup{dim_H J_F : F finite} = inf{t >= 0 : P(t) <= 0} with P(t) = lim (1/n) log sum_(abs(w) = n) sup abs(phi_w')^t, and if P(t) = 0 then t = dim_H J. Its graph-directed form, Mauldin and Urbanski 2003, Theorem 4.2.13, is read in the restatement of Chousionis, Leykekhman, Urbanski and Wendt 2024, Definitions 2.1, 2.3 and 2.5 and Theorem 2.7: for a finitely irreducible conformal graph directed Markov system, dim_H J = inf{t >= 0 : P(t) <= 0}, the sum running over the admissible words of the graph, an iterated function system being the one-vertex case of its Remark 2.2. The hypotheses as restated: one compact connected seed per vertex in R^n, equal to the closure of its interior; an injective contraction per edge, of Lipschitz constant at most one s < 1 for all edges; the open set condition, the images of the interiors under distinct edges disjoint; a C^1 conformal extension of every word to an open neighbourhood of the seeds, conformal meaning a C^1 diffeomorphism at n = 1; the bounded distortion abs(abs(phi_e'(p))/abs(phi_e'(q)) - 1) <= L abs(p - q)^alpha on a compact neighbourhood, one L, alpha for every edge; finite irreducibility, a finite set of words joining any two edges; and, in the 2008 restatement, a cone condition, an open cone of fixed angle and altitude inside the seed at every point of it. Neither original text is read here.

The hypotheses hold on every graph of ### Every rule is a graph-directed continued fraction set, the run-length alphabets being the one-vertex graphs. Proved. Seed the state u with X_u = 3u + [0, 1] and give the edge u -a-> v the map x -> 3u + 1/(a + x - 3v): distinct labels from one state send the interior to the disjoint intervals (1/(a + 1), 1/a), distinct states to distinct translates, and one state never carries two edges of one label, its successor being determined, so the images are disjoint. Every branch maps W = (-1/4, 3/2) into itself, 1/(1 - 1/4) < 3/2, and the compact S = [-1/8, 5/4] into itself, 1/(1 - 1/8) = 8/7 < 5/4, as a Mobius map with nonvanishing derivative, so every word extends. On S, (a + q)^2/(a + p)^2 - 1 = (q - p)(2a + p + q)/(a + p)^2 is at most abs(q - p) (2a + 5/2)/(a - 1/8)^2 <= 9 abs(q - p), so L = 9, alpha = 1 for every label, the cofinite edges included. A strongly connected finite graph is finitely irreducible, one path per ordered pair of states, and the cone condition on an interval is an open interval of length 1/2 inside the seed at every point. The contraction fails once, x -> 1/(1 + x) having derivative -1 at 0, and is restored by the coordinate y = log(1 + x), on the seed X_u by y = 3u + log(1 + x - 3u): there the branch a contracts by (1 + x)/((a + x)(a + x + 1)) <= 1/(2 + x) <= 1/2, the change of coordinate is a diffeomorphism of a neighbourhood of [0, 1], so the limit set moves to a bi-Lipschitz image of the same dimension, the disjointness and the extensions survive, the distortion bound survives with L = 2, alpha = 1, since abs(d/dy log abs(psi_a'(y))) = abs(1 - (1 + x)/(a + x) - (1 + x)/(a + x + 1)) <= 1 on the image of S, whose length is log(18/7), and every sup abs(phi_w') moves by a factor in [1/2, 2], so P does not move. The pressure of the restatements is the pressure of L_(A,s). Proved. A word w has abs(phi_w'(x)) = (q_w + q'_w x)^(-2) with q'_w <= q_w its continuants, so q_w^(-2)/4 <= abs(phi_w'(x)) <= q_w^(-2) = sup abs(phi_w') on [0, 1], and summing over the words of length n from every state, 4^(-t) Z_n(t) <= sum_u (L_t^n 1)_u(x) <= Z_n(t); hence e^(P(t)) is lim norm(L_t^n 1)^(1/n), the spectral radius of the positive operator L_t on the continuous functions, which is the leading eigenvalue lambda(t) of the tables, the largest eigenvalue modulus of L_t on the analytic functions of a disc around [0, 1]: at most the radius, its eigenfunctions being continuous, and at least it, 1 being analytic and L_t compact there for t > 1/2, the branches sending a disc around [0, 1] strictly inside itself with weights (a + z)^(-2t) summable. So dim_CF, the zero of log lambda, is inf{t : P(t) <= 0}, the Hausdorff dimension of the limit set: of E_A at every finite or cofinite A, and of every component's limit set on the orphans and the named codes. The citation carries only the lower bound. Proved. The level-n cylinders phi_w([0, 1]), of diameter 1/(q_w (q_w + q'_w)) <= q_w^(-2), cover the limit set with sum_w diam^t <= Z_n(t), which tends to 0 when P(t) < 0, so dim_H <= inf{t : P(t) < 0}; and P(t + e) <= P(t) - 2 e log phi, every q_w of length n being at least the Fibonacci number F_(n+1), makes that inf{t : P(t) <= 0}. The alphabets with sum_(a in A) 1/a = infinity, every cofinite A among them, sit above one half. Proved. sup abs(phi_a') = a^(-2), so Z_1(t) = sum_(a in A) a^(-2t) and P(t) are finite for t > 1/2; abs(phi_w') >= prod_i (w_i + 1)^(-2) gives P(t) >= log sum_(a in A) (a + 1)^(-2t), which rises to log sum_(a in A) (a + 1)^(-1) = infinity as t falls to 1/2; and the level-n cylinders being disjoint in [0, 1], min_x (L_1^n 1)(x) <= 1, so Z_n(1) <= 4 and P(1) <= 0. The zero therefore lies in (1/2, 1], the bisection bracket of lab/py/question-mark, and dim_H E_A > 1/2 for every such A, as the four cofinite rows read. A sparse alphabet sits lower: Z_n(t) <= Z_1(t)^n and Z_1(1/4) = 1 at A = {4^k} give P(1/4) <= 0 and dim_H E_A <= 1/4 by the cover above, so the bound is the divergence of sum 1/a and not the infinitude of A.

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: mrlyrs::num::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/py/question-mark carries ## The question mark: the Stern-Brocot carry and its checks against A002487 and the Calkin-Wilf row, the four laws of ? computed exactly on the Farey subtree, the run-length rules against the prefixes of ?(E_A), and the table of rho, log_2 rho and the pressure zero on every run-length code at widths 2 to 4, with the A = {1,2} and A = N controls run first.
• 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 mrlyrs::num::memory, and pins the carry density, the carry-free cycle census and the six refutations of d_loc as exhaustive set equalities.
• mrlyrs::num::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.