Layer 3 — The allowed search grammars

You can only call a theory "simpler" inside a declared game. Here are the four games — and the one rule you may never break: you may not compare across them without an explicit bridge.

This is the third bridge in the anchoring stack. Layer 1 fixed how we measure simplicity (description-length, not dimension-count). Layer 2 fixed the honesty rule (no exact Standard-Model label may be used unless it is generated, charged, or marked open). Layer 3 fixes the thing both of those quietly assume: a search space. A minimality claim is only meaningful relative to a declared set of moves — the grammar of constructions you are allowed to write down. Name the grammar, and "simplest" becomes a sharp, checkable statement. Refuse to name it, and "simplest" silently means "simplest among the things I happened to think of," which is no claim at all.

The question this layer answers

When the program says "within the internal-isometry picture, the 13D shape is the strongest known survivor," a fair skeptic should immediately ask: survivor of what search? Over the space of all imaginable theories of everything? That space is not even enumerable — it is the space of all finite programs that reproduce the data, which is the home of every uncomputability theorem in the book. Over four cosets you sketched on a napkin? Then the claim is true but empty.

Layer 3 is the move that makes the claim neither empty nor impossible. It declares the grammar register: a small, explicit family of construction-languages, each with its own legal moves, its own cost ledger, and its own failure modes. Inside any one grammar the search space is finite and the comparison is decidable. Across grammars, comparison is forbidden by default — it requires a separately-proven bridge with a common cost metric. The result is a contest you can actually score.

Why a grammar is mandatory: the universal-negative wall

The naive target — "no simpler theory exists anywhere" — is a universal negative over all conceivable architectures. Make it precise and it becomes: is there any finite program $P$, of any kind, that outputs the observed physics to the relevant resolution $\Delta_0$ with fewer bits than our generator? That is the question of the Kolmogorov complexity $K(T)$ of the target data $T$, and $K(T)$ is uncomputable. There is provably no procedure that surveys all programs and certifies a minimum. The programmatic-generator schema

$$B_P \;=\; \{\,P : P \text{ is a finite program outputting } T \text{ to resolution } \Delta_0\,\}$$

contains infinitely many generators, and exact minimization over it cannot terminate. So "the shape is absolutely simplest" is not a hard claim we have failed to prove — it is a claim no one, for any theory, can ever prove. Chasing it is chasing a unicorn.

The Layer-3 move is to replace the impossible target with a reachable one. Declare a finite mechanism grammar $\mathcal G$. Now the question "is the 13D branch shortest?" becomes a finite lower-bound problem over finitely many construction classes — decidable in principle, a checklist rather than a universal negative. That conversion is the achievement. It does not, by itself, fill in the checklist — but it turns a question that cannot be asked into one that can.

Three discipline lines stay attached to everything below — they are the spine of the whole program, and Layer 3 is where the third one is enforced most literally:

• selection $\neq$ derivation — choosing the shape is not the same as forcing it;
• given-$E$ $\neq$ derivation-of-$E$ — reading structure off the shape given the observed spectrum $E$ is not deriving $E$;
• frozen / reproducible $\neq$ proven-unique — a hash-frozen, blind-reproducible candidate is still not a uniqueness theorem.

Layer 3 makes the third line operational: "proven-unique" is only ever grammar-relative-unique, and saying so out loud is the honesty.

The grammar register

A candidate theory of gauge structure lives in one of (at least) four construction-languages. Each is a legitimate way to ask "where does the Standard Model come from?" — and each charges a different currency.

Grammar A — internal-isometry geometry

Moves. Gauge forces are the isometries of compact internal factors. You build space as $M_4 \times (\text{internal})$, where the internal manifold is assembled from cosets $G/H$, folds (quotients by a finite group), and bundles; the gauge group is the isometry group, chirality and family number come from index theorems on declared bundles, and center quotients fix the charge lattice. This is the Kaluza–Klein lineage.

What it is charged. The internal geometry, the quotients, the bundle data, the measured anchors, and the rulebook that maps geometry to observables — all of it, under the Layer-1 full-generator metric.

Where the program stands. This is the program's home grammar, and its carrier-forcing results live here (the subject of Layer 4): inside "forces = isometries," cheaper carriers for the weak and hypercharge factors are eliminated by general theorems, and the one cheaper color rival was built end-to-end and breaks. The 13D branch is the strongest known survivor inside Grammar A, given $E$.

Grammar B — bundle / brane / singularity

Moves. Gauge structure comes from bundle structure-groups, branes, singularities, fluxes, and choices of vacuum — the string / M-theory / F-theory lineage. Gauge groups arise on stacks of branes or at geometric singularities; chiral matter localizes on intersections or matter curves; family number is an intersection or index count; the scales come from flux and moduli stabilization.

What it is charged. The compactification choice, the flux choice, the brane / localization data, moduli-stabilization machinery, exotics removal, and — critically — the selector / vacuum cost: which of the enormous landscape of vacua is the one we live in.

Where the program stands. Grammar B is not refuted by anything in Grammar A. These frameworks can host the Standard Model gauge content; on the bare gauge-recovery outcome they tie. What the program's in-grammar results do not do is reach into Grammar B and beat it — a different game has different legal moves. The honest standing is: Grammar B can carry the gauge content but, in every reviewed case, has not supplied a frozen, fully-charged, selected vacuum that reproduces the full target with fewer effective primitives. It remains a serious class to beat, not a beaten one.

Grammar C — 4D effective field theory

Moves. Write the gauge group $su(3)\oplus su(2)\oplus u(1)$, the representation table, the family count, the hypercharges, the masses and mixings directly, as low-energy postulates of a renormalizable 4D quantum field theory. This is the Standard Model as usually taught.

What it is charged. Everything it writes down. Under Layer 2, each exact label that is postulated rather than generated is a primitive input and costs bits. A plain 4D EFT pays roughly $I(B_{\rm EFT})\approx 25b$ in injected structural bits — it inserts the full ledger directly — versus the 13D branch's honestly-charged $I(B_{13})\approx (4 + 9\text{–}10)\,b \approx 13b\text{–}14b$ (four measured anchors plus nine-or-ten injected reals).

Where the program stands. Grammar C is cheaper under a dimension-first metric — $4 < 13$, full stop, and that is a real win on that ruler. It is not cheaper under description-length, because there it pays its postulates in full and generates none of them. And it is, by construction, not a geometric-origin solution — it answers "what are the rules?" but declines to answer "why these rules?" The honest one-liner: lower metric dimension; higher primitive-label cost; no geometric origin. Which of those matters is exactly the Layer-1 metric question — where dimension-first is already inadmissible as a record-cost ruler, and what remains open is the explicit bridge axiom that physical simplicity = minimal injected record cost.

Grammar D — algebraic / noncommutative / lattice / discrete

Moves. Structure comes from a finite algebra, a spectral triple, a lattice, a cellular automaton, or a category. The gauge group is the unitaries / automorphisms of a finite noncommutative algebra $A_F$ (the Connes–Chamseddine almost-commutative route); chirality is an index on a finite Dirac operator; family number is built into the algebra's module structure; the rulebook is the spectral action or the categorical / functorial constraints.

What it is charged. The finite Dirac operator (which in the noncommutative-geometry route carries the Yukawa couplings — so flavor is paid there), the algebra, the axioms, and a cost-translation bridge to make its bits comparable with geometric bits at all.

Where the program stands. Grammar D is a separate class. Its primitives are not geometric primitives, so a fair comparison requires translating its cost ledger into a common currency — a bridge that does not yet exist in closed form. It is among the most serious architecture-neutral rivals precisely because it naturally unfolds into the same three functional roles (a stage, a rulebook, and actors) as a geometric construction. It is not refuted; it is not yet commensurable.

The register at a glance

The universal target constraints

A grammar tells you the legal moves; it does not tell you when a candidate has actually won. For that we need a fixed, architecture-neutral specification of the target — otherwise a competitor can "win" a weaker game by reproducing a watered-down version of the Standard Model. Every serious candidate, in any grammar, must meet all of:

• exact gauge algebra $su(3)\oplus su(2)\oplus u(1)$ — no missing factor, no extra unbroken factor;
• exactly three chiral generations;
• no light mirror sector (a bare doubling of handedness is excluded by the measured LEP $Z$-width);
• the electric charge relation $Q = T_3 + Y$ with hypercharge quantized, $Y \in \tfrac{1}{6}\mathbb{Z}$;
• local anomaly admissibility (the spectrum passes the anomaly filter — see the caveat below);
• frozen-before-compare: the generator is hash-frozen before it sees the comparison data;
• no retuning and no layer-smuggling: a missing function may not be hidden inside an unexpanded phrase like "natural flux choice" or "the spectral action does it";
• all real anchors and all sector normalizations charged in the ledger;
• a declared failure mode per mechanism — each mechanism states, in advance, what would break it.

Two of these deserve emphasis because they are where weaker games quietly cheat.

First, anomaly cancellation is a filter, not a selector. That the observed spectrum satisfies $A(E_{\rm SM}) = 0$ means $E_{\rm SM}$ passes a consistency filter; it does not mean the filter picks out $E_{\rm SM}$. Upgrading filter to selector would require proving the singleton statement

$$\ker A \;\cap\; \mathcal{C}_{\rm admissible} \;=\; \{E_{\rm SM}\},$$

i.e. that the Standard-Model spectrum is the only anomaly-free admissible spectrum. That theorem is not proven — the anomaly-free set is, as far as anyone has shown, infinite. So $E$ stays a primitive input across all grammars, and the claim "anomaly cancellation selects the Standard Model" is false. (This is the Layer-2 result, carried forward unchanged; the full accounting lives in the hypercharge / anomaly dossier.)

Second, frozen-before-compare and no-smuggling are what keep the contest honest. The most common way a competitor looks cheaper than it is: it states a single elegant top-line object — a unified representation, a generic compactification, a finite algebra — and leaves the breaking chains, the flux choices, the flavor structure, and the proton-safety machinery folded into a phrase. When those functions are unfolded into explicit Stage / Rulebook / Actor data, the apparent economy usually reappears as rulebook and hidden-sector cost. Elegance at the headline is not economy in the ledger.

The no-cross-grammar rule

Here is the rule that does the real work of Layer 3:

You may not compare a candidate in one grammar to a candidate in another without an explicit bridge theorem and a common cost metric.

This is not bureaucratic caution; it dissolves a whole class of false paradoxes. Consider three "contradictions" a careless comparison would generate:

• Grammar C beats the 13D branch — true, under dimension-first ($4 < 13$).
• The 13D branch beats Grammar C — true, under description-length (C injects $\sim 25b$; the branch $\sim 13$–$14b$).
• Grammar B ties the 13D branch on gauge recovery while failing to supply a selected vacuum — also true.

These are not contradictions. They are different games scored on different rulers. The dimension-first ruler and the description-length ruler genuinely disagree about which architecture is "simpler," and which ruler is correct is the Layer-1 question, still open. Until that bridge is built, "13D is minimal" is an honest statement only when stamped with its grammar and its metric: minimal inside Grammar A, under description-length, given $E$. Strip any of those qualifiers and the statement becomes either false or unprovable.

A-versus-A comparison is legitimate and is where the program's sharpest results live (carrier economy: which isometry construction is cheapest). A-versus-C, A-versus-B, A-versus-D are not legitimate without a bridge. Saying so is not a weakness of the program — it is the program refusing to claim a win it has not earned.

The closure target: a role-mechanism normal-form / exhaustion theorem

The grammar register turns an infinite survey into a finite one inside each grammar. The remaining ambition — the named, finite, reachable target that would upgrade the whole picture from a survey to a classification — is a role-mechanism normal-form / exhaustion theorem.

The idea: every admissible explanation of the Standard Model, in any grammar, must supply a mechanism for each of finitely many functional roles. Declare the roles as axes, and declare, for each axis, the finite list of known mechanisms that can fill it. A "normal-form class" is then one chosen mechanism per axis — a tuple. The five declared axes are:

Because each axis is a finite list, the set of normal-form classes is a finite product — and that finiteness is exactly what makes the exhaustion question checkable rather than a search over arbitrary programs. The 13D branch is itself just one tuple in this scheme (gauge = isometry/coset; chirality = index; family = index; flavor = geometric overlap plus a fitted normalization; scale = posited anchors). It gets no privileged row — it is charged by the same codebook as every competitor, and it occupies the "fitted normalization" flavor cell honestly, because the branch does tune normalization constants $N_d, N_e, N_\nu$ to hit target masses, and a fitted normalization is a charged injection, not a derivation.

The theorem to prove has two parts:

1. Reduction (exhaustion): every admissible architecture reduces — cost-non-increasingly, so no smuggling rescues it — to one of these finitely many tuples. The finite-taxonomy half of this is proved: inside the declared grammar, with dimension $D \in \{4,\dots,13\}$ crossed with the finite mechanism axes, the competitor space is finite and classifiable, and the no-smuggling rule preserves cost. This is the rigorous upgrade of the older informal "selector-minimal" claim.
2. Lower bound: for each tuple, bound its minimal cost from below, and show the 13D tuple is no worse than the cheapest. This is the open half — a finite lower-bound matrix that has not been completed. It is a checklist, not a universal negative; that is the whole point of having done Layer 3.

The honest boundary condition is essential: the taxonomy is a declared posit, and it is living. The claim is exhaustion relative to this list of mechanisms — never an absolute negative. A competitor that uses a mechanism not on any axis is the unconsidered competitor: it does not refute the theorem, it forces the taxonomy to be extended and the matrix re-run. Broadening the axes strengthens the result. That is the legitimate way to attack the program — and inviting it is the honesty.

Status — reached vs open

Reached.

• The grammar register is declared, with four explicit construction-languages and their cost currencies. "Simpler" now always carries a grammar and a metric.
• The no-cross-grammar rule is in force, which dissolves the apparent dimension-first-vs-description-length contradictions into "different games, different rulers."
• The conversion of the impossible universal-negative ("simplest anywhere") into a finite, decidable, grammar-relative problem is done — that is the central Layer-3 achievement.
• The finite-normal-form half of the exhaustion theorem is proved: inside the declared grammar the competitor space is finite and classifiable, and the no-smuggling rule keeps the cost honest.
• Inside Grammar A, the 13D branch is the strongest known survivor given $E$; inside the broad competitor audit, no reviewed class — and no Tier-1 class (noncommutative geometry, Kaluza–Klein alternatives, string / F-theory, finite-state / discrete geometry, SO(10) / exceptional GUTs) — is currently a preferred competitor that both meets the full target and is cheaper after unfolding.

Open — the named bridge-theorem.

• The lower-bound matrix (the second half of the exhaustion theorem): bound every normal-form class from below and show the 13D tuple is no worse than the cheapest. This is a finite checklist, not a universal negative, but it is not yet filled in.
• Cross-grammar minimality as a whole: it depends on the lower-bound matrix and on the Layer-1 metric bridge (which ruler is correct) and on cost-translation bridges into Grammar D. Each is a named, finite target — not a unicorn.
• The architecture-neutral claim ("no simpler competitor across all grammars, full stop") remains open and is likely unprovable in full, because it reaches back into the uncomputable universal negative. That is the honest ceiling, and it is the same ceiling every theory of everything hits.

So the Layer-3 standing is exactly symmetric and exactly honest: the 13D branch is unrefuted but not certified. No shorter full-target competitor has been exhibited in any reviewed class; and no procedure can certify global minimality. A skeptical reviewer, checking blind, should conclude serious candidate, not yet validated — which is precisely the conclusion the methodology is built to license. The honesty is the methodology: we say exactly which game the shape is winning (Grammar A, given $E$), which it merely ties (Grammar B's gauge outcome), which beats it on a different ruler (Grammar C, dimension-first), which is not yet commensurable (Grammar D), and what one finite theorem — the completed lower-bound matrix — would let us compare all of them fairly.

Cross-links

Sibling anchor pages

• The Anchors — overview — how the whole stack fits together.
• A0 — The Master Anchor — the audit rule that grades every grammar by the same codebook.
• Layer 1 — Why "simplest" means description-length — the metric a cross-grammar comparison must agree on first.
• Layer 2 — No unpaid exact labels — the anti-smuggling rule each grammar's cost ledger must obey.
• Layer 4 — Carrier-forcing and the given-$E$ wall — where Grammar A's in-grammar dominance is actually argued.
• The Shape Minimality Challenge — the synthesis: the three claim levels and the competitor ledger.

Gate dossiers

• The shape, in full — the frozen 13D construction and its honest standing.
• Gauge recovery (SG2) — the gauge-outcome tie that motivates the no-cross-grammar rule.
• Hypercharge & anomaly (SG4) — why anomaly cancellation is a filter, not a selector.
• The live 33-gate scoreboard — every requirement-gate this stack feeds: all 33 resolved at +0 · 0 open, graded in the open with residuals shown; and 0 of 33 physics-closed, stated plainly on the board itself.