Gate Traceability — method & template

This is the reusable method page for every per-gate anchor ledger. It is not a gate-specific page. It teaches how to build a gate ledger — for SG-4, SG-5, and every later gate — so that the same discipline applies everywhere and nothing load-bearing ever floats silently.

A gate is a place where the framework claims to read some piece of Standard-Model structure off the frozen 13D shape. Each gate touches a handful of exact objects — a charge relation, a quotient, an anomaly ledger, a custodial parameter, a winding number. The danger is always the same: a real local win gets quietly inflated into a whole-gate closure, a filter gets sold as a selector, or a measured input gets re-narrated as a derivation. The template on this page exists to make that inflation impossible by construction.

Status precedence. This is a method/template page for building per-gate anchor-traceability ledgers; its roll-up vocabulary grades ledger rows on the strictest traceability axis, not gate status. Gate status is graded once, on the live gate board — 33 requirement-gates: all 33 RESOLVED at +0 · 0 ANCHORED at +1 · 0 OPEN (ratified 2026-07-08), with the separate honest axis stated just as plainly: 0 of 33 physics-closed, because every closure rests on declared measured anchors — and the per-gate dossiers are the closure-of-record. Where a worked example below names a residual, the same residual is shown openly on its board row; nothing on this page re-opens a closed gate.

The page thesis. A gate page is complete only when every exact object it touches has a root trace, a master-anchor trace, a status label, an allowed claim, a forbidden claim, and an open-residual / closure task.

The three discipline lines run through every gate page, never dropped:

selection ≠ derivation · given-E ≠ derivation-of-E · frozen / reproducible ≠ proven-unique.

This page grounds in the anchoring method, the master anchor, and the seven deep roots. The two worked examples below (SG-4, SG-5) are the canonical instantiations — read them alongside this template.

1. The status taxonomy (use only these labels)

Every major claim on a gate page must carry exactly one of the allowed status labels. No free-floating adjectives ("solid", "robust", "essentially closed") are permitted in place of a status. The allowed set, with what each one means:

The gate roll-up on this traceability axis is the least-closed residual (the since-retired mid-audit roll-up rubric — the closure-of-record grades by reached terminals; see /gates/): the ledger row stays OPEN if any required piece is open, regardless of how strong its local legs are. This is the row-audit discipline only; the gate’s terminal grade lives on the live /gates/ board.

2. The seven-root hierarchy (every gate anchor must link to ≥1 root)

Every gate anchor must trace to at least one of the seven deep roots. If no root link can be found, the item is not admissible until it is instead measured, charged, declared, or marked open. The seven roots, used consistently across all gate pages:

1. Physical Equivalence / Invariance Root — only frame/gauge/coordinate-invariant content is physical.
2. Record Interface Root — a claim earns status only by connecting to finite, reproducible records.
3. Causal Order Root — admissible structure respects a causal/partial order.
4. Granularity / Cost-Floor Root — finite recordability imposes a cost floor; no unpaid exact labels.
5. Scale Root — dimensionful structure requires a measured scale (e.g. $M_{\rm Pl}$).
6. Shape Root — the frozen 13D geometry supplies carriers, cycles, quotients.
7. Nonseparability / Global State Constraint Root — local closure is constrained by global state; it is why a local leg need not close the whole gate.

These roots are not all theorem-grade. Two are meta-admissibility roots (Invariance, Record Interface), the rest are charged physical posits or proof targets. Naming them is the point — it forces every resting place into the open.

3. The master-anchor hierarchy (every gate anchor must link to ≥1 master anchor)

Every gate anchor must also trace to at least one master anchor — the operational clauses of the master anchor $A_0$:

• finite invariant records — the object connects to a finite, frame-invariant ledger.
• no unpaid exact labels — every exact label is generated, charged, or marked open.
• full-generator cost / MDL pressure — the object is paid for in the full-generator budget.
• measured scale / $M_{\rm Pl}$ — dimensionful content is pinned to a measured scale.
• frozen 13D branch — the object is tested against a frozen, read-only branch.
• given $E$ — the object is evaluated on the inherited spectrum, not a derivation of it.
• audit hashes/manifests — the object's identity is certified (audit only).
• local/global nonseparability discipline — local closure is not asserted as global.
• obstruction-map discipline — closure is stated as a specific component of the obstruction map.
• open-residual discipline — each residual is named, typed, and exported.

If an anchor links to no master anchor, it is a floating anchor and is inadmissible until typed.

4. The universal gate ledger table

Every gate ledger must use this exact table — one row per exact object the gate touches, at atomic granularity (do not collapse distinct objects into vague rows):

A row is admissible only when all eight cells are filled with concrete content: a named anchor, the exact mathematical object, ≥1 of the seven roots, ≥1 master anchor, one allowed status label, what it may claim, what it may not claim, and the residual/closure task (or "—" only when genuinely terminal).

5. The eleven-section gate page structure

Every per-gate page must have these eleven sections, in order:

1. Gate status header — the board terminal from the live /gates/ ledger, plus this axis’s strictest-row roll-up; the exact closed local/partial leg as a formula $O_{\rm GATE,local}(E_{\rm frozen})=0$; the status of that leg.
2. Frozen inputs — branch hashes (AUDIT ONLY); $E_{\rm frozen}$ and any upstream object (GIVEN-E / charged), explicitly not derived here.
3. Gate-specific anchor set — the spectrum / fields / structures the gate acts on (given-E / upstream-inherited).
4. Root and master-anchor traceability — which deep roots are load-bearing and why; which master anchors are in play.
5. Universal anchor ledger table — the table of §4, one row per exact object.
6. Calculations / obstruction map — the actual computation at full depth (formulas, witnesses, the obstruction map split into local vs full), with at least one specificity diagnostic showing the result is specific, not trivial.
7. Local result versus whole-gate status — the explicit local-vs-full distinction (see §6).
8. Open residuals / closure family — each residual a separate row, grouped by family; never collapsed.
9. Anti-claims — the explicit forbidden statements for this gate (see §8).
10. Specialist closure plan — each open residual as a concrete, finite, target-blind work-package: what closes it, the machinery, and the falsifier / negative outcome.
11. Completion tests — the required-presence and required-absence lists, plus the final completion report.

6. Local result versus whole-gate status

This is the single most important discipline on a gate page. A gate page must explicitly state:

$$\text{local leg closed} \;\neq\; \text{whole gate closed}.$$

A closed local leg is a genuine, checkable win. It is not a whole-gate closure, and a gate page that lets the two blur has failed its primary job. On this traceability axis the roll-up stays at the least-closed residual; the gate’s terminal grade lives on the live /gates/ board.

7. The obstruction-map pattern

For each gate, define the obstruction map as a tuple of named components:

$$O_{\rm gate}(X) = \big( O_1(X), O_2(X), \ldots, O_n(X) \big).$$

State the exact closed claim as a specific component evaluated at the frozen input — for example:

$$O_{\rm gate,local}(X_{\rm frozen}) = 0,$$

instead of claiming the full map vanishes when residuals remain open. Asserting $O_{\rm gate}(X_{\rm frozen})=0$ while any $O_i$ is open is forbidden. The closed claim is always the named sub-tuple, never the whole map until every component is terminal.

8. The anti-claim method

Each gate must include at least one anti-claim per major overclaim risk. The six risk channels every gate page must check:

9. Worked example — SG-4 (hypercharge & anomaly)

The SG-4 ledger is the canonical instantiation of this template.

• Local claim: $O_{\rm SG4,local}(E_{\rm frozen})=0$ — the six local anomaly ledgers vanish by exact rational arithmetic for the frozen spectrum.
• Status: DERIVED-GIVEN-E (the local arithmetic leg, given $E$).
• Specificity diagnostic: $\sum (\text{mult})\,Y^2 = \tfrac{10}{3}\neq 0$ — a non-trivial quadratic invariant is non-zero while all six anomaly invariants vanish, so the cancellation is a real arithmetic fact about $E_{\rm frozen}$, not an artifact.
• Forbidden: "anomaly cancellation selects the Standard Model, SG-4 fully closed." Anomaly-freedom is a filter admitting infinitely many spectra (vector-like additions $R\oplus\bar R$ cancel every anomaly); it does not select the SM. On this traceability axis the roll-up stays at the least-closed row; on the live board SG-4 stands RESOLVED at +0 — given the observed spectrum, all six anomaly sums vanish exactly, with the given-$E$ limit stated on the row (dossier).

10. Worked example — SG-5 (electroweak embedding / EWSB)

The SG-5 ledger instantiates the template for a gate with a strong embedding leg and a live computed finding.

• Embedding claim: $SU(2)_L \times U(1)_Y \to U(1)_{\rm em}$, with $Q=T_3+Y$ exact componentwise and the photon forced massless — $O_{\rm SG5,embed}(E_{\rm frozen})=0$, DERIVED-GIVEN-E for the embedding leg only.
• Open residuals: $\rho_{\rm tree}$ realization map, the electroweak hierarchy, no-second-VEV, and the KK-Schur correction — each a separate OPEN / BLOCKED row on this axis, governing this axis’s roll-up (on the live board SG-5 stands RESOLVED at +0, with $v_{\rm EW}$ anchored as the second measured ruler and the residual shown openly — dossier).
• Forbidden: "the geometry derives $\rho=1$ without an actual frozen-geometry W/Z computation." The claim became legitimate only when the computation was actually carried out: the frozen-geometry hinge confirmed the Higgs VEV mode is an SU(2)$_L$ DOUBLET, giving $\rho_{\rm tree} = 1$ exactly (the mid-audit $\rho_{\rm tree}\neq 1$ commutator model stands banked as a negative control) — and $v_{\rm EW}$ is a MEASURED second anchor, not a derived quantity. The live board row confronts (not fits) the measured custodial ratio $\rho_0 = 1.00038 \pm 0.00020$ against that computed $\rho = 1$ — a genuine result, since the shape carries no hidden custodial symmetry that would have forced the tidy textbook value automatically (SG-5 dossier).

11. Required completion-test table for gate pages

Every gate page must include this self-report table:

Allowed status labels (the only tokens a gate page may use): DECLARED ROOT · GENERATED · DERIVED-GIVEN-E · MEASURED · CHARGED · AUDIT ONLY · OPEN · BLOCKED · ANTI-CLAIM.

12. Global forbidden overclaims (every gate page must avoid all of these)

• Do not claim all deep roots are theorem-grade.
• Do not claim the 13D shape is absolutely unique.
• Do not claim $E$ is derived unless a separate bundle-uniqueness proof is supplied.
• Do not claim local gate closure equals whole-gate closure.
• Do not claim hashes validate physics; hashes validate frozen-object identity / audit integrity.
• Do not claim anomaly cancellation selects the Standard Model.
• Do not claim MDL / full-generator cost is absolutely proven against every competing metric.
• Do not claim measurement / nonseparability sends a usable superluminal signal.

13. Completion tests for this method page

Required presence (all met): the page thesis · the status taxonomy with meanings · the seven-root hierarchy + root-link rule · the master-anchor hierarchy + master-link rule · the universal gate ledger table · the eleven-section structure · the local-vs-full-gate distinction $\text{local leg closed}\neq\text{whole gate closed}$ · the obstruction-map pattern $O_{\rm gate}(X)=(O_1,\ldots,O_n)$ with the local-component closed claim · the six-channel anti-claim method · the SG-4 example ($O_{\rm SG4,local}=0$, DERIVED-GIVEN-E, anomaly-selector forbidden) · the SG-5 example (embedding $\to U(1)_{\rm em}$, $\rho/$hierarchy residuals, $\rho=1$ overclaim forbidden) · the GATE-01..GATE-10 completion-test table · the allowed status labels · the global forbidden overclaims · this completion report.

Required absence (all held): no claim that any gate is fully closed by a local leg · no claim that $E$ is derived · no claim that a filter is a selector / anomaly cancellation selects the SM · no claim that the 13D shape is absolutely unique · no claim that hashes validate physics · no claim that $\rho=1$ / the hierarchy is derived · no claim that any root is theorem-grade across the board · no FTL / superluminal-signal claim · no use of any status label outside the allowed set · no reader-visible build-process vocabulary.

Completion report

• Tests passed: P1 (universal gate ledger table — §4) · P2 (eleven-section structure — §5) · P3 (allowed status vocabulary — §1, §11) · P4 (root-link and master-link rules — §2, §3) · P5 (local-vs-full-gate distinction — §6) · P6 (obstruction-map pattern — §7) · P7 (SG-4 and SG-5 examples — §9, §10) · P8 (gate-page completion-test table — §11) · P9 (completion report — this block). Universal: U1 status honesty · U2 no floating anchors (every named anchor is typed) · U3 no root inflation (roots stated not all theorem-grade) · U4 no E-smuggling (E is given/charged) · U5 no hash-overclaim (audit only) · U6 local/global distinction · U7 forbidden claims absent · U8 completion report present.
• Tests failed: none.
• Open items: this is a method/template page; the gate-specific residuals live on the individual gate ledgers (e.g. SG-4 §8, SG-5 §9). Closing them is the job of each gate's specialist closure plan, not of this template.
• Assumptions made: the seven-root and master-anchor naming follows the deep-roots page and the master-anchors page; the SG-4 / SG-5 example details are quoted from the canonical SG-4 and SG-5 ledgers and are not re-derived here.

See also: The Anchor Hierarchy — overview · The Seven Deep Roots · Master / Fundamental Anchors · The Logical Endpoint Proof · Gate Traceability — method & template · Blind Spots & Implicit Assumptions · The AI-Agent Completion Protocol · the anchoring method index · the worked examples: SG-4 ledger · SG-5 ledger.