The substrate door

Whether S resolves a pair depends on nothing about the pair but the difference between its two inputs: S fails exactly when the product of its primes divides that difference. So a task's entire demand is carried by its difference set — the differences of the pairs it requires separated — and least-new growth is a hitting-set cover of that set taken smallest-first, a prime p hitting a difference d precisely when p does not divide d. The same rule written from scratch as a cover algorithm — take the smallest prime that hits anything still uncovered — reproduces the grower step for step. The cover reading also prices the rule: smallest-first is myopic, its grown set strictly above the minimum cover in 40 of 40 random small instances, because it takes 2 — odd differences are always present — where a single larger prime would cover the whole demand at once, as the hand demand {1, 770} grows {2, 3} against a minimum cover of {3}. Reaching the substrate the data actually calls for costs lookahead.

Scope. The difference-set reduction proved, and its product form checked against the per-prime test on 4000 sampled substrates and pairs; the from-scratch cover algorithm checked against the grower on a random task; the myopia rate an observation over 40 random instances on the first six primes. Toy scale.

verifier: explore_collision_growth.py

Demand every distinction there is — all of {0, …, M−1} pairwise separated — and the grown substrate is forced. Least-new takes 2, 3, 5, … in order and halts as soon as their product passes M−1, so what it grows is the primorial prefix, the first k primes with none skipped: depth 3, 4, 5 and 6 at M = 30, 210, 2310 and 30030. Nothing about the task enters but how fine a resolution it asks for. Unstructured data does the same thing: a prime resolves any difference it does not divide, so in a task with no structure every prime resolves something and smallest-first walks the prefix — 24 random tasks over one range grow one identical substrate, 2, 3, 5, 7. That is destination universality again, one level up from the reader. Where the reader adapts to its metabolism and not to its data, a substrate grown on data carrying no structure to exploit adapts to the resolution demanded and not to what is demanding it — a counter, whose depth the task sets and whose content it does not. What structure does to that is the flip condition.

Scope. The all-distinct prefix law proved; the generic verdict an observation over 24 random tasks of 8 classes each on {0, …, 209}, with a pool of twelve primes. These task families, toy scale.

verifier: explore_collision_growth.py

Structure in the data does move the substrate — and not far enough to pick a destination. A task living on the multiples of q has every difference divisible by q, so q resolves nothing and is never taken (proved) — the multiples of 3, of 5 and of 7 grow {2, 5, 7, 11}, {2, 3, 7, 11} and {2, 3, 5, 11}, three different substrates. A prime skipped is what makes a designed tower rather than a prefix, and here the data does the designing, where the growth laws have it done by a capability demand. Yet those substrates transfer to each other near-intact: the one grown on the multiples of 3 leaves 0 of the multiples-of-5 task's 125 differences unresolved, and the reverse direction leaves 1 of 209 — that lone residual being the single difference equal to the product of the resolving substrate's own primes, the one value it therefore cannot resolve. Redundant small primes still cover, so a different substrate is not a data-picked destination. What would be one is a unique-need difference, divisible by every pool prime but one: within the first five primes, 770 = 2·5·7·11 is resolvable only by 3, and a task needing it grows exactly {3} while a sibling on the multiples of 3 never demands 3 and leaves that one distinction unresolved. So structure alone does not open the door, and what opened it in the one construction built to was a conjunction: a difference only one pool prime resolves, and a sibling task that skips exactly that prime.

Scope. The skipped-prime law proved; the transfer figures and the flip condition observations on hand-designed toy tasks — the sublattice ensembles on {0, …, 629} against a pool of twelve primes, the unique-need pair on {0, …, 299} against a pool of five.

verifier: explore_collision_growth.py

Build the tasks in grammar's own terms — stems against affixes, a paradigm of lexemes against cells, a fusional table of feature values — then embed each surface form by the obvious reading, its symbols as the digits of an integer in base B, and grow. What decides the answer is the base. Where the affix is a single symbol, a task whose labels are the cells never produces a difference divisible by B — a cross-cell difference is congruent to the difference of two distinct symbols, which is nonzero and smaller than the base — so for squarefree B the prime factors of B suffice, every distinction the task asks for being resolved by one of them (proved). Which of them least-new actually takes is a separate question, and its answer is where they sit in the pool, since least-new walks the pool smallest-first and halts as soon as what it holds divides none of the demand: B = 30, whose factors are the pool's three smallest, grows exactly {2, 3, 5}; B = 35, whose factors sit higher, grows {2, 3, 5, 7} rather than {5, 7} — the pool below them, then the one it needs; and the prime base 29 has no factor in the pool at all and grows the whole pool, which is what a structureless task grows. In all three, two tasks over one base grow the identical set and transfer with nothing left over. Compositionality — one fixed transform per cell, shared across every lexeme — is visible in the arithmetic and not in the substrate: the same-lexeme demand collapses onto the differences between the transforms alone, four values across five cells, and the whole difference set shrinks with it, 431 differences against a matched non-compositional control's 644 — yet both grow that same prefix. Compression is not unique-need. Natural grammar does carry unique-need differences, in every family tried, and the door stays shut anyway — every sibling pair transfers near-intact, worst residual 0.625% of the demand and most exactly zero. So the flip condition is sharper than the presence of a unique-need difference: opening the door needs one and a sibling that skips its sole resolver, and the gap is only as wide as the count of differences uniquely needing that skipped prime. Grammatical distinctions are local, hence small differences, hence divisible by few primes and redundantly covered, and only a handful ever land on one prime. Pushing the transforms out to primorial scale by hand raises the number of unique-need differences from 1 to 17, which reaches the door only by designing the transforms to be unique-need — the hand-built pair above, not an escape from it.

Changing the encoder does not move the verdict either. Take Z/510510, the integers modulo the product of the first seven primes — the pool stays the first five of them — and build the paradigm multiplicatively — a form is a lexeme L times a cell value K, both units, meaning residues coprime to the modulus and so invertible there. A same-lexeme difference across two cells is then congruent to L·(K′ − K) modulo every prime in the pool, and a pool prime divides it exactly when it divides the cell difference, since a unit carries no pool factor. So given the same cell values in both — the qualifier the identity needs, and without which the two grow different sets — the multiplicative and the additive encoder grow the identical substrate (proved), the multiplicative one losing only the compression: 180 differences where the additive has 15. Its siblings transfer near-intact as well, residual 0.134%, and the door opens only for a cell gap chosen to be unique-need. What the multiplication buys is capability rather than a destination. Fix one cell as the reference and one lexeme as the anchor: a cell's transform is then the ratio of the anchor's two forms, and because the anchor's lexeme factor cancels out of that ratio, the same transform applied to any other lexeme's reference form lands on that lexeme's form in that cell — every pair the extraction never saw, 55 of 55, where a non-compositional control scores 0. That capability is priced in unit membership and degrades by degrees rather than at once: an encoder whose forms are mostly non-units completes 3 of the 55 exactly and still recovers 0.719 of the individual prime remainders, precisely those on which its anchor is invertible.

Scope. The sufficiency of the base's own factors and the encoder-invariance of same-lexeme resolvability are rules, mechanism-proved; which set least-new lands on is read off three bases, and the transfer verdicts, the completion rates and the difference-set counts are observations at toy scope — these grammar families and encodings, the first five primes as the pool, which is where a unique-need difference is cheapest to reach and so the fairest shot the door gets, and Z/510510 for the multiplicative half.

verifiers: explore_grammar_growth.py, explore_vsa_encoder.py

Both readings above took their embedding as given — symbols read as digits in the first, forms handed over as ring elements in the second. The map that does the arranging is the embedding, and the natural candidate is the one that respects concatenation: give each alphabet symbol a unit and send a string to the product of its symbols'. For concatenative morphology that is free. The image of a stem followed by an affix is the product of their images, so the transform extracted for a cell is the affix's alone, and completion runs from raw strings at 55 of 55 against 0 of 55 for a control that hands each distinct string its own unrelated unit. The lift rides the homomorphism and not the format: no per-lexeme table is learned and no notion of similarity between stems is used.

Its price is order, and the price is forced rather than chosen. Multiplication commutes, so the map cannot see the sequence of symbols at all, only which occur and how often — 13 forms collapse onto 3 values, and gluing a fixed group of symbols to the front of a stem is indistinguishable from gluing it to the back. No choice of units repairs that. Every homomorphism from strings under concatenation into the multiplicative structure of a commutative ring factors through the abelianization, the quotient in which any two symbols may be exchanged freely, so all of the order lives in exactly what that quotient forgets and no commutative target can hold it. Tagging each symbol with its position separates the anagrams that had collided, and breaks the shared transform, because the affix then sits at a place that depends on the stem's length: completion holds at 33 of 33 where the stems share a length and falls to 0 of 33 where they do not — 0 rather than a fraction because the anchor is given a length no other stem shares, so nothing can transfer at all. The two natural embeddings pay opposite halves of one exchange, and the same trade sits under the tower itself, between an exact test for zero and a native reading of order (crown and blind spot) — an echo across two constructions, not a second impossibility proof. Fusional morphology settles on the same side. A cell whose change is idiosyncratic per lexeme shares no transform, so the homomorphism completes 0 of 33 forms it was not shown, and each rescue supplies what the ring does not hold: an embedding built to respect the relation restores 33 of 33, and a table read off the lexemes it did see scores 15 of 15 on those and 0 of 18 on the rest.

Scope. The homomorphism identity and the position-length trade are rules, mechanism-proved. The completion rates, the collision counts and the fusional verdict are observations at toy scope — Z/510510, a Latin alphabet, these paradigm families, and the fusional extreme taken as cells whose forms share no symbols with one another at all. What is claimed of order is a statement about commutative targets, not about every embedding: nothing here rules out a native rule that holds both order and a shared transform.

verifier: explore_embedding.py