Meaning

bind(role, filler) = multiply; unbind = multiply by the meadow inverse, the pseudo-inverse x′ with x·x′·x = x and 0′ = 0 defined on the whole ring at once, which is what makes division total on a squarefree rung. Binding is exact for every unit role and every filler; chained roles unbind in either order. Every element is both datum and operator: op_x = multiply-by-x, read back by op_x(1) = x, and the operator's reach is its window support — the meadow pseudo-inverse undoes unit actions exactly and recovers the surviving windows for the rest. The contrast: in holographic reduced representations (HRR) and the Semantic Pointer Architecture, circular convolution binds and correlation unbinds approximately — the unbound filler returns at cosine ~0.7, never 1 — so every retrieval needs a cleanup memory and is probabilistic. (Binary XOR binding is also exactly self-inverse; what the ring adds is the guaranteed cleanup below and the datum-as-operator structure.)

Scope. Follows from the meadow construction; confirmed exhaustive at Z/210, sampled at Z/510510.

verifier: explore_meaning_codeword.py

A Gestalt is a codeword: d = 4 — the split is MDS, maximum distance separable, its distance meeting the Singleton bound — makes the perceptual basin of attraction a theorem. Any one corrupted window snaps back to the whole, guaranteed (exhaustive: all 210 concepts × all 51 corruptions), and any 3 erased windows reconstruct it (all 35 patterns). Two corrupted windows are always detected and never mis-snapped — the view, the tuple as received, sits 2 from its own whole and a mis-snap needs it within 1 of another, putting two wholes 2 + 1 < d apart, forbidden at d = 4. Three can produce an illusion — the view snaps to a different valid whole, never to garbage — but rarely: 0.58% of 5000 random views carrying three corrupted windows snapped; the rest were detected and refused. Basins are disjoint, exactly 52 tuples per concept: beyond radius 1 the decoder refuses rather than hallucinates.

Scope. Proved from d = 4, with the censuses exhaustive: 210 concepts × 51 single corruptions, and all 35 three-erasure patterns. The illusion rate is measured over 5,000 random three-corruption views.

verifier: explore_meaning_codeword.py

The bundle of the classical vector-symbolic architectures — an elementwise sum of bound pairs — carries no cleanup here, and for codeword fillers the failure is exact: unbinding a two-item sum returns the true filler plus a noise element sharing the second filler's support, and every nonzero codeword is nonzero on at least d = 4 windows, so whenever the second item is nonzero the query sits outside the true concept's radius-1 basin — retrieval is provably 0 (verified 0/2000), the one escape being an empty second item, whose noise vanishes. The same d that guarantees the snap forbids the sum. What rescues the sum classically — quasi-orthogonality, bundle noise nearly invisible to a dot product in high dimension — is archimedean concentration-of-measure geometry, not a ring resource: a wall of the deletion read at the representation level. The cure is ring-native: bundle = direct sum. Idempotent slots (roles = channel windows) retrieve every stored item exactly at hard capacity = the channel partition, and multiplicative binding composes inside a slot.

Scope. The limits: capacity is hard on both of its axes — slots per bundle end at the channel partition, and the scene inventory at 210 for this rung; both scale only by rungs or designed towers — and codewords carry no archimedean similarity gradient — what the ring's own gradings still carry exactly, and the precise boundary of what a learned embedding must supply, are the similarity carrier and the readable hull. The HRR contrast is a contrast of kind, not a benchmark: on self-inverse substrates exact unbinding is the shared floor, not an edge, and the published factorization benchmarks run on per-coordinate partial credit — exactly the archimedean concentration resource this wall names as missing, and one no rung can buy.

verifier: explore_meaning_codeword.py

Agreement depth hosts tree-shaped similarity exactly. A rooted taxonomy embeds by path: give each level a block of windows, each branch an invertible digit on that block, and each leaf x the element φ(x) holding its path's digits — then depth(φ(x), φ(y)) is exactly the depth of the leaves' lowest common ancestor (276 pairs, zero mismatches), and one element carries the whole ancestor chain, each level read back by a partial congruence with no second embedding. A depth-d ball — everything agreeing with a given element through level d — is a congruence class mod the prefix's modulus: members agree to depth ≥ d, non-members below it, and the two ranges cannot overlap — so a label constant on balls is read exactly from whichever stored exemplar agrees deepest with the query, any of them, no margin and no tie-break. Nearest-neighbour class readout, a heuristic in a metric embedding, is a theorem here: on a paradigm — a table of words by inflected forms, each form one transform of the word — whose word classes share no surface structure, the case that defeats the concatenative embedding, six words held out of the store complete every unseen form, 24 cells of 24, from tree placement and one attested form alone — the cells keyed to two class granularities, coarse and fine, one embedding serving both — where a per-word codebook covers none and a scrambled embedding scores 0 of 24. What agreement depth refuses is the chain: the strong triangle forbids it under every assignment of ring elements (zero realizations in all 27,000 triples of Z/30). Trees are native; a learned metric is needed at most for the non-ultrametric residue.

Scope. The embedding identity, the ball-read and the chain refusal are proved, the refusal with an exhaustive control at Z/30; the completion rates are verified at one 24-leaf taxonomy on Z/510510. Where an item's tree placement comes from is a data-side question outside the claim.

verifier: explore_similarity_carrier.py

The overlap represents the chain at its first opportunity — 0, 6, 16 in Z/30 overlap pairwise 2, 2, 1 — so the residue has a native carrier; the question is what retrieval can read of it. Store a set of elements and join two by an edge where their overlap reaches a threshold t — the threshold graph. Deepest-overlap readout — the stored exemplar of greatest overlap read as the answer — is exact and tie-break-free — for every query and every admissible pool, one holding at least one neighbour of the query — iff the label is constant on that graph's connected components. One line each way: an exemplar at overlap ≥ t is itself a neighbour, hence in the query's component, and every tied exemplar likewise; a label non-constant on a component breaks across some edge, and querying one endpoint against the other alone is admissible, deepest, and wrong. Exhaustively confirmed: all 243 labelings, with up to three labels, of a five-element store on six channels, every admissible pool for every query, zero exceptions in either direction. The structure behind the criterion: components merge as t falls even though fixed-t neighbourhoods do not nest in general, so the component partitions form a nested family — an ultrametric u(x, y) = the largest, over paths from x to y, of the path's weakest overlap (single linkage), and the least ultrametric dominating the overlap. That is the readable hull: what deepest-overlap retrieval reads of any similarity grading is precisely its hull, and chains live in the grading–hull gap — a label that separates a chain's ends forces an exact overlap tie between disagreeing labels behind some query. Component-grade readout is live — two words held out of the store complete every unseen form, 6 cells of 6, every deepest-overlap tie yielding the true form — and nothing finer exists. And the overlap's readable classes are properties of the stored world, not of the ring: on the full ring the threshold graph is connected at every threshold below k — changing one window at a time walks anywhere — while agreement depth reads its congruence classes on the full ring as it stands, nothing stored. Exact readout is ultrametric-shaped no matter the carrier; the deleted metric is needed not to represent chains but for any reading finer than the hull.

Scope. The criterion is proved, necessary and sufficient, with the exhaustive confirmations above and the same verdict at Z/30 (27 labelings); the hull is its proved corollary, computed two ways and equal on that world and 20 seeded random worlds; the full-ring connectivity is proved for every k, exhaustive at Z/30; the completion rates are verified at the one world.

verifier: explore_overlap_carrier.py

A CA rule built from ring operations (+, ×, constants — hence every power map, every gate, the meadow inverse) is a polynomial, hence channel-local — its value mod p a function of the input mod p alone — so the automaton is the direct product of k independent mod-p automata, channel p's entire future a function of channel p's initial plane alone. Conversely, any k-tuple of arbitrary per-channel rules is one polynomial rule (Lagrange interpolation per channel, coefficients CRT-glued degreewise): pure-ring automata are exactly the products of arbitrary per-channel automata. Coupled dynamics is therefore bought, not built, and the toll is priced in bits crossing the channel boundary per cell-read: an aliveness bit ([x = 0], or any channel quantifier) costs 1, the support grade [|supp(x)| ≥ t] (supp x = the channels where x is nonzero) costs log₂(k+1), size comparison costs log₂ N — no polynomial computes any of them, and the content never crosses: only quantifier bits do. Conway's Life threshold is bought at the support grade's price, and the toll is real — a graded Life on Z/30 paying one grade-read per cell per step builds cross-channel mutual information from a channel-independent soup within 20 steps, while its decoupled twin never leaves the sampling floor.

Scope. The rule-equals-polynomial leg needs a squarefree modulus (it fails at Z/4); locality ⇒ product holds for any product ring. Exhaustive rule batteries at Z/6 with three-cell neighborhoods; channel-locality checked across whole trajectories at Z/30 — soups equal mod 5 keep equal mod-5 planes at every step; the converse construction exact; the Life runs are observations, recorded in the script.

verifier: explore_ring_ca.py

The same isolation quarantines damage. The tower-split code (the Gestalt basin above) survives no arithmetic — under a sum rule its minimum distance degrades as the running values climb rungs, 4 → 3 (values from 210) → 2 (2310) → 1 (30030) → 0 (510510), and the repair is a per-step base extension — a borrow the recovery chart prices, paid every step — so make the invariant a dictionary closed under the dynamics instead. Binding-closed dictionaries of units are exactly the subgroups of the unit group; channels being cyclic, a subgroup is a linear code over the exponent space ∏_p Z/(p−1) with window distance = exponent Hamming distance: classical coding theory imports wholesale through the index transform. Binding never spreads an error across windows — wrong(xy) ⊆ wrong(x) ∪ wrong(y), wrong(x) the set of corrupted windows — and two guarantees follow. Eager — snap each cell to its nearest word before binding: at most t corrupted windows per cell per step gives an exact trajectory forever (verified at the full 3-of-7 budget). Lazy — correction waits until readout: three stuck lanes — windows wedged at wrong values — open loop, zero maintenance, one snap per cell reads out exactly. Instances: binary linear codes bind-closed as ±1-per-channel words (Hamming [7,4,3] on a designed tower over the first seven odd primes corrects any one window); a designed tower on places p ≡ 1 (mod 8) holds an order-8 unit whose powers sit at pairwise distance 7, correcting three.

Scope. The fault model is noisy value registers under reliable control — the algorithm-based fault-tolerance stance. The dictionary-closed-under-a-group-action form with coset correction is Beckmann–Musicus and Hadjicostis–Verghese; universal computation on coded data at polylog overhead is Spielman. Binding is the classical transversal gate set, and the decoupling law is the matching wall. This rung's own maximum-order unit generates a dictionary at minimum distance 1 — two words 120 exponent steps apart differ in channel 17 alone, and channel 2 never separates units at all — so a dictionary is constructed, never inherited.

verifier: explore_snapback_ca.py