SOURCE: https://physics.magflowmeters.com/layer2/
======================================================================

The Second-Layer Roots — the admissibility / interface discipline 

 The Second-Layer Roots — the admissibility / interface discipline — rendered package. Rendered from index.md ; frozen technical content unchanged by rendering.

 The Second-Layer Roots — the admissibility / interface discipline

 Thesis. The second-layer roots are the four admissibility/interface disciplines that sit above the three deep physical roots — the Shape , the Scale , and the Granularity . They are Invariance , Record Interface , Causal Order , and Nonseparability . The deep roots supply the physical substrate — the frozen object, the absolute magnitude, the finite cost. The second-layer roots supply the discipline that decides whether a claimed rule from that substrate is actually invariant, actually record-facing, actually target-blind, and not secretly factorized. They do not generate physics. They are the screen every claimed closure must pass before it is even eligible to be called closed. The single sentence the rest of this page unpacks: a rule that survives Shape, Scale, and Granularity is still inadmissible until it also survives all four second-layer roots — and passing them is necessary for closure, never sufficient for truth. 

 Honesty guard (read before anything else). None of these four roots is an answer-generator. Invariance does not tell you which invariant nature realizes; it only tells you a coordinate, gauge, basis, scheme, or off-shell artifact does not count. Record Interface does not tell you what the observable is; it only tells you a claim with no finite, correct-object endpoint is not reviewable. Causal Order does not tell you the value of a target; it only tells you a rule shaped by that value is a fit, not a derivation. Nonseparability does not tell you how sectors couple; it only tells you that assuming they do not is a debt that must be proven, paid, or tested. These are filters on candidate claims, not sources of them. Passing them removes a way to be wrong ; it does not supply a reason to be right . This page is a completeness statement of the four interface roots, not an anchor-elimination and not a status change. The site invariants stand verbatim in spirit: Anchored is not derived. Selected is not forced. Frozen-and-reproducible is not proven-unique. Dissolved is not solved. This is a Theory-of-Everything candidate under honest audit: 0 of 33 gates are physics-closed , and the running status change count is no status changes .

 The single most common way to mis-state the role of this layer is to treat passing it as a result. It is the opposite of a result: it is the elimination of a false result. A gate that has cleared all four second-layer roots has earned only the right to be evaluated on the deep roots and the Layer-1 observable — nothing more.

 1. Where the second layer sits

 The seven deep roots (see The Seven Deep Roots ) fall into two tiers relative to physics. The four roots on this page are the upstream tier — two meta-roots (Invariance, Record Interface) that are conditions for anything to count as physics or empirical audit at all, plus two physical-but-interface-facing roots (Causal Order, Nonseparability) that police the direction of information flow and the accounting of independence . They sit above the three deep physical roots that supply the substrate:

 SECOND LAYER (admissibility / interface discipline)
 Invariance — branch-preserving equivalence
 Record Interface — finite observable / audit endpoint
 Causal Order — no backward target → rule flow
 Nonseparability — no unpaid factorization / independence

DEEP ROOTS (physical substrate)
 Shape — the frozen object identity
 Scale — the absolute magnitude
 Granularity — the finite cost-floor
 
 The deep roots tell you what the object is, how big it is, and what a finite step costs . The second-layer roots tell you whether a claim about that object is admissible as physics in the first place . A wall is closed only when the deep roots are saturated, a Layer-1 observable is reached, and the second-layer screen passes. This page is the discipline of that screen.

 1.1 What each root catches — the one-line overview

 Root 
 Compressed definition 
 What it catches 

 Invariance 
 branch-preserving equivalence discipline 
 representation / coordinate / gauge / basis / scheme / off-shell-sign artifacts 

 Record Interface 
 finite observable / audit endpoint discipline 
 no-observable / wrong-record / wrong-object / hash-as-derivation artifacts 

 Causal Order 
 no backward target → rule information flow 
 target leakage — the answer secretly choosing the rule, exponent, chamber, or tolerance 

 Nonseparability 
 no unpaid factorization or free independence 
 unpaid factorization debt — independent sectors, additive ledgers, shared objects miscounted 

 Read the table as four distinct failure modes. A claim can be perfectly invariant and still fail Record Interface (it survives every redescription but never touches a finite observable). It can have a clean record and still fail Causal Order (the observable closes the loop because it was used to pick the rule). It can pass all three and still fail Nonseparability (three "independent successes" are one shared scheme object counted thrice). All four are independent guards, and a claim must clear every one.

 2. Invariance

 2.1 One-sentence definition

 Invariance is the discipline that only branch-preserving content counts as physical; coordinate, gauge, basis, scheme, observer, and parametrization artifacts do not close gates. 

 Compressed: Invariance = branch-preserving equivalence discipline. A claim is physical only to the extent that its content survives all transformations that preserve the same physical branch. Coordinate, gauge, basis, representation, observer, scheme, and field-parametrization choices are not physical content unless they leave invariant residue.

 2.2 Why this root exists

 Description is not content. The same physics can be written in infinitely many equivalent ways, and any quantity that changes when you merely change the description was never physics — it was bookkeeping. Invariance exists because the most seductive false closures are the ones that look like results only in one description: a sign that flips under a gauge choice, a value that is finite only in one scheme, a "match" that holds in one basis and one parametrization. The root forces the agent to separate the residue that survives every branch-preserving redescription from the artifact that does not.

 2.3 Relationship to Shape / Scale / Granularity

 Invariance is branch-relative , and the branch is supplied by the deep roots. It does not ask the generic question "is this covariant?" It asks: what transformations preserve this frozen Shape object — including its metric stage, quotient/fold data, rulebook, actor bundle, operator, connection, and readout map? A transformation that preserves only the metric but changes the actor/operator layer may not preserve the branch at all.

 Shape-derived. A transformation preserving only the × Stage is not automatically branch-preserving; it must preserve the ⊕ Rulebook and ⊗ Actors too. Object identity (which operator, which connection, which bundle) is a Shape fact, and Invariance enforces that it is held fixed across the redescription.

 Scale-derived. Invariance must distinguish dimensionless invariants, unit conventions, renormalization-scheme dependence, normalization-selected values, scale-window-dependent claims, absolute magnitudes, and dissolved quantities. A number is not invariant merely because it is reproducible — it must survive the relevant scale/scheme transformations or be labeled scheme-dependent, anchored, fitted, or dissolved.

 Granularity-derived. Invariance must be finitely auditable: a finite transformation grammar, declared equivalence classes, canonical representatives, a finite invariant ledger, no hidden continuous convention knobs, and no "up to convention" without a closed convention class. 

 2.4 What this root forbids

 Do not claim coordinate/gauge covariance is enough for physical invariance.
Do not claim a reproducible hash is physical invariance.
Do not claim an off-shell local sign is an invariant positivity verdict.
Do not treat two operators as equivalent unless object identity is proven.
 
 What it catches, concretely: coordinate artifacts, gauge artifacts, BRST/ghost-sign mistakes, basis artifacts, representation artifacts, field-parametrization artifacts, renormalization-scheme artifacts, normalization artifacts, off-shell sign artifacts, and wrong-object equivalences.

 2.5 What this root can force

 A rule is Invariance-forced only if the branch-preserving transformation class is closed, all non-invariant candidates are eliminated, a unique invariant rule or invariant equivalence class survives, the rule is target-blind, and perturbing the branch-preserving equivalence structure changes or removes the rule. In certificate form (the four-field grade specialized to invariance):

 The branch-preserving equivalence class is closed,
all non-invariant candidates are eliminated,
and one invariant rule / equivalence class survives.
 
 2.6 What this root cannot claim

 If Invariance merely says "this is compatible with covariance," the result is ROOT-SUPPORTED , not ROOT-FORCED. Invariance cannot promote a frozen object into a unique object — frozen-and-reproducible is not proven-unique, and a hash certifies which object was tested, not that the object is invariantly singled out. It cannot read a physical verdict off a description-dependent quantity.

 2.7 Support-to-force ladder (Invariance)

 The general ladder (Section 6) instantiated for this root:

 NARRATIVE-ONLY : names "we should be covariant" but constrains nothing.
ROOT-COMPATIBLE : the claim does not contradict branch-preserving invariance.
ROOT-SUPPORTED : invariance makes the rule natural; non-invariant rivals survive.
ROOT-CONSTRAINED : invariance eliminates some non-invariant candidates.
ROOT-SELECTIVE : invariance + toolbox leaves a small finite invariant family.
ROOT-FORCED-FAMILY : one invariant equivalence class survives, modulo allowed transforms.
ROOT-FORCED : one target-blind invariant rule survives inside the closed class.
TARGET-LOADED : the "invariant" was chosen in the basis that makes the number match.
 
 2.8 Wall example — Gap-01 positivity and the off-shell sign

 Computing the frozen 13D graviton+ghost $a_6$ Seeley–DeWitt diagnostic, one is tempted to read a positivity verdict off the sign of a local heat-kernel density. Invariance forbids this. A positivity verdict cannot be read from an off-shell, odd-$D$, gauge-dependent, local $a_6$ sign: the sign is not a valid invariant positivity predicate. It is gauge- and field-parametrization-dependent off-shell, and in odd $D=13$ a dimensionful $a_6$ is not even a canonical finite local observable — only consistency coefficients may be reported. The invariant content, if any, lives in route-agreement and exact identities, not in the local sign. Verdict: any positivity claim read from the off-shell local sign is INVARIANCE-BLOCKED. 

 2.9 Checklist for agents (Invariance)

 [ ] Name the physical object held fixed.
[ ] Name the transformations that preserve that object (the branch).
[ ] Name the transformations that change the branch.
[ ] List the quantities that survive the preserving transformations.
[ ] List the quantities that are artifacts of description.
[ ] State the on-shell / off-shell status of any gauge-dependent claim.
[ ] Confirm the equivalence-class ledger is finite and the convention class is closed.
[ ] Confirm the surviving rule is target-blind (written without the target value).
 
 2.10 Honest ceiling

 This root is an admissibility/interface root. It does not generate physics by itself. It tells us whether a claimed rule from Shape, Scale, and Granularity is invariant — whether its content survives every branch-preserving redescription — and nothing more. Passing Invariance removes representation, gauge, scheme, and off-shell-sign artifacts from a claim; it is necessary for closure, not sufficient for truth. A perfectly invariant claim can still have no observable endpoint, can still be target-loaded, and can still hide factorization debt. Invariance is one of four guards, and clearing it is not a status change.

 3. Record Interface

 3.1 One-sentence definition

 Record Interface is the discipline that every claim must terminate in a finite physical observable or finite audit record tied to the correct object. 

 Compressed: Record Interface = finite observable/audit endpoint discipline. A claim is reviewable only if it terminates in a finite physical observable or a finite audit record — and that record must be read off the correct object.

 3.2 Why this root exists

 A claim with no endpoint cannot be tested, and a claim with the wrong endpoint cannot be trusted. Record Interface exists because two distinct failures hide here: the claim that never reaches a finite observable at all (an internal coordinate sold as a result), and the claim that reaches a finite record attached to a different object than the one in question (a numeric match on the wrong operator, bundle, or connection). The root also separates two strengths of "record" that are constantly conflated: a physical observable that the world supplies, and an audit record that the computation supplies. The second is real and useful, but it does not prove physical truth.

 3.3 Relationship to Shape / Scale / Granularity

 Shape-derived. The readout map must run from the correct object: Shape object → operator/path/bundle/invariant → record . A record attached to a different operator, bundle, connection, or quotient object does not close the wall, no matter how clean the number.

 Scale-derived. Every record must declare its unit, renormalization scheme, energy scale, scale window, normalization, uncertainty, tolerance, fit/input/output status, and dimensionless-vs-dimensionful status. Without these, a record may exist but not be comparable — and an incomparable record closes nothing.

 Granularity-derived. Records must be finite: a finite file, finite table, finite value, finite uncertainty, finite tolerance, finite hash, finite reproducer, finite pass/fail predicate, and a finite, wired falsifier. A claim requiring infinite precision, an unbounded lookup table, or an undefined tolerance does not have a valid Record Interface.

 3.4 What this root forbids

 Do not call an internal variable an observable without a readout map.
Do not call a captured terminal log an independent reproduction.
Do not call a consistency coefficient a measured invariant.
Do not use a record from the wrong object to close a wall.
 
 What it catches: an internal coordinate sold as an observable; a wrong-object comparison; a computed value with no physical endpoint; a log treated as independent reproduction; a hash treated as derivation; unclear units or scale window; a post-hoc tolerance; an open-ended lookup table; a falsifier that was never wired.

 3.5 What this root can force

 A rule is Record-Interface-forced only if the correct Shape object supplies the readout map, the record is finite and auditable, the Scale context is fixed, the record tests the rule rather than selecting it, and changing the record target would not change the rule grammar. In standard form:

 The correct Shape object has only one admissible finite readout to the relevant
observable/audit record, or all other readouts are eliminated as wrong-object /
wrong-scale / non-finite / target-loaded.
 
 3.6 What this root cannot claim

 Record Interface cannot turn an audit win into a physics win. The most important distinction on this root: a strong, exact audit record is not gate closure. An audit record certifies that a computation was done correctly on a specified object; it does not certify that the object's physics is true, nor that the routes which must agree do agree, nor that the total physical quantity has even been emitted.

 3.7 Support-to-force ladder (Record Interface)

 NARRATIVE-ONLY : "there will be an observable" — none named.
ROOT-COMPATIBLE : a record could in principle exist for this claim.
ROOT-SUPPORTED : a finite record exists but does not yet uniquely test the rule.
ROOT-CONSTRAINED : wrong-object / wrong-scale / non-finite readouts are eliminated.
ROOT-SELECTIVE : a small finite family of admissible correct-object readouts remains.
ROOT-FORCED-FAMILY : one readout class survives, modulo allowed transforms.
ROOT-FORCED : one finite correct-object readout tests the rule, target-blind.
TARGET-LOADED : the readout map was chosen because it outputs the target.
 
 3.8 Wall example — Gap-01 exact rational sphere checks vs. the total $a_6$

 In the Gap-01 / $a_6$ work, the program has exact rational heat-kernel cross-checks — for example sphere-rational and Bianchi identities computed in closed form. These are strong audit records: they are finite, exact, reproducible, and they catch errors. Record Interface insists on the limit of what they prove. They do not emit the total physical $a_6$ value , and the two structurally independent physical routes (the canonical Casimir route and the physical Levi-Civita/Lichnerowicz route) have not been reconciled. An exact correctness gate on a sub-object is an audit win; it is not the physical observable the gate requires. Verdict: the exact sphere checks are ROOT-SUPPORTED audit records; the gate remains RECORD-BLOCKED until the total $a_6$ is emitted from the correct object and the routes agree. 

 3.9 Checklist for agents (Record Interface)

 [ ] Name the thing being read and the correct object identity.
[ ] Name the readout map from that object.
[ ] State the observable or audit record produced.
[ ] Declare units, scale, scheme, uncertainty, tolerance.
[ ] Classify the record: physical observable / computational / audit-only / falsifier.
[ ] State whether the record TESTS the rule or SELECTED the rule.
[ ] Confirm the record is finite (file, value, tolerance, predicate, falsifier).
[ ] Confirm reproduction is independent — a captured log is not a reproduction.
 
 3.10 Honest ceiling

 This root is an admissibility/interface root. It does not generate physics by itself. It tells us whether a claimed rule from Shape, Scale, and Granularity terminates in a finite, correct-object observable or audit record — and whether that record tests the rule rather than having selected it. Passing Record Interface removes no-observable, wrong-object, and audit-as-physics artifacts; it is necessary for closure, not sufficient for truth. An exact audit record is the cleanest thing on the board and still closes nothing by itself. Record Interface is one of four guards, and clearing it is not a status change.

 4. Causal Order

 4.1 One-sentence definition

 Causal Order is the discipline that rules, grammars, maps, scales, and tolerances must not be shaped by target observables unless explicitly paid as fits. 

 Compressed: Causal Order = no backward target-to-rule information flow. A rule is causally clean only if it can be specified without knowing the target observable — unless the dependence is explicitly declared and paid as a fit.

 4.2 Why this root exists

 The single most efficient way to manufacture a fake derivation is to let the answer choose the rule. Pick the chamber that lands the mass ratio, the exponent that matches, the tolerance that turns the miss into a hit, the scale window where the number agrees — and then present the result as if the rule came first. Causal Order exists to enforce the direction of information flow:

 root/object → rule/grammar/map → prediction/readout → target comparison
 
 and to forbid the reverse:

 target → rule selection → claimed derivation
 
 A fit is a legitimate, honest thing — when declared and paid as a fit. What Causal Order forbids is a fit sold as a derivation.

 4.3 Relationship to Shape / Scale / Granularity

 Shape-derived. The branch/map must be fixed before comparison: frozen Shape object → declared rulebook/map → computed output → observable comparison. If the observed target chooses the branch, chamber, projector, exponent, connection, field basis, tolerance, or scale window after the fact, the map is target-loaded. 

 Scale-derived. Causal Order forces the agent to freeze or pay every scale-side choice: renormalization scheme, energy scale, scale window, threshold policy, sector normalization, RG bridge, tolerance, rounding rule, absolute anchor policy. Changing any of these after seeing the result is target-loading unless declared as a paid fit. (This is exactly why the program's flavor sector normalizations $N_d, N_e, N_\nu$ are carried openly as paid calibration inputs, not as predictions.)

 Granularity-derived. Causal Order lives in finite artifacts: a frozen manifest, an allowed-input manifest, a forbidden-target manifest, a holdout table, a pre-registered grammar, pre-registered tolerances, a run log, versioned output, and a finite audit trail. Target-blindness must be a checkable finite fact, not a promise.

 4.4 What this root forbids

 Do not call a fit a derivation.
Do not call a post-target grammar pre-registered.
Do not use target values to choose projectors, exponents, chambers, or tolerances.
Do not promote target-loaded rules to root-forced.
 
 What it catches: post-hoc rule selection, answer-shaped grammar, post-target chamber selection, post-target exponent assignment, tolerance tuning, scale-window tuning, a fit sold as a prediction, cherry-picked observables, and using holdouts during reconstruction.

 4.5 What this root can force

 A rule is Causal-Order-clean only if the rule and grammar can be written without the target value, allowed inputs and forbidden targets are declared, scale/tolerance choices are pre-fixed or paid, changing the target would not change the rule, and the target is used only as a test unless explicitly paid as an input. In standard form:

 The rule grammar is derivable without target values;
all target-dependent grammars are eliminated or paid as fits.
 
 4.6 What this root cannot claim

 Causal Order cannot, by itself, make a rule correct — it can only certify that the rule was not contaminated by the answer. A causally clean rule can still be wrong (it can disagree with the target), still lack an observable endpoint, and still hide factorization debt. Causal Order is about provenance , not validity .

 4.7 Support-to-force ladder (Causal Order)

 NARRATIVE-ONLY : "we did not peek" — no manifest, no holdout.
ROOT-COMPATIBLE : the rule could in principle be written without the target.
ROOT-SUPPORTED : the rule looks target-blind but inputs/targets are not declared.
ROOT-CONSTRAINED : some target-dependent grammars are eliminated.
ROOT-SELECTIVE : a small finite family of target-blind grammars remains.
ROOT-FORCED-FAMILY : one grammar class survives without target backflow.
ROOT-FORCED : one target-blind rule grammar survives; target used only as a test.
TARGET-LOADED : the rule depends on the desired answer.
 
 4.8 Wall example — the SG8 flavor exponent

 An SG8 flavor exponent chosen because it matches a mass ratio is target-loaded : the target observable flowed backward and selected the exponent, so the apparent agreement is circular. By contrast, an exponent derived from a Shape path/winding/action class before comparison — read off the geometry as a discrete residue, with the falsifier and tolerance frozen before any output is read — may be causal-order clean. The discriminating question is not "does it match?" but "could the exponent have been written down without ever seeing the mass ratio?" If the answer is no, the rule is TARGET-LOADED regardless of how good the match looks. Verdict: a fitted exponent is CAUSAL-ORDER-BLOCKED; a pre-registered winding-class exponent is the only route to ROOT-FORCED here — and that map is currently open, so the flavor result is at most Shape-supported. 

 4.9 Checklist for agents (Causal Order)

 [ ] Declare allowed inputs.
[ ] Declare forbidden targets (and the holdout table).
[ ] State the rule grammar and the map-construction time/order.
[ ] State the scale/tolerance policy and confirm it was fixed before outputs.
[ ] Run the target-perturbation test: if the target changed, would the rule change?
[ ] Classify the result: prediction vs paid fit.
[ ] Confirm holdouts were not used during reconstruction.
[ ] Confirm no projector / exponent / chamber / tolerance was chosen by the target.
 
 4.10 Honest ceiling

 This root is an admissibility/interface root. It does not generate physics by itself. It tells us whether a claimed rule from Shape, Scale, and Granularity was specified without the target observable flowing backward to shape it — or was honestly declared and paid as a fit. Passing Causal Order removes target-dependence artifacts: post-hoc selection, answer-shaped grammars, tuned tolerances, fits sold as predictions. It is necessary for closure, not sufficient for truth. A target-blind rule can still be wrong, can still lack an endpoint, and can still hide factorization debt. Causal Order is one of four guards, and clearing it is not a status change.

 5. Nonseparability

 5.1 One-sentence definition

 Nonseparability is the discipline that exact independence, factorization, additive cost, and sector splitting are never free. 

 Compressed: Nonseparability = no unpaid factorization or free independence. Every sector split, factorization assumption, additive cost ledger, independent fit, or cross-wall decoupling must be proven, paid, or tested — exact independence is never assumed because the math is easier that way.

 5.2 Why this root exists

 Independence is the most expensive assumption that costs nothing to write down. Treating two sectors as independent lets you compute them separately, add their costs, and count their successes twice. But if the global object does not actually factorize over those sectors, every one of those moves is a miscount: the additive cost ledger is wrong, the "independent" fits share hidden parameters, and three "independent successes" may be one shared scheme object counted three times. Nonseparability exists to convert every silent independence assumption into an explicit entry on a factorization-debt ledger that must be discharged by proof, payment, or test.

 5.3 Relationship to Shape / Scale / Granularity

 Shape-derived. Start from the whole branch : metric stage + quotient/fold + rulebook + actor/operator + connection + readout map. If sectors are computed independently, the agent must show the Shape genuinely factorizes for those sectors, or charge the independence assumption.

 Scale-derived. Track cross-scale dependencies: thresholds, RG flow, compactification scales, sector normalizations, shared heat-kernel scheme objects , correlated uncertainties, shared anchors, scale bridges. A scale object shared by multiple walls is one shared object, not separate knobs. 

 Granularity-derived. Force factorization into a finite ledger: the factorization assumption, its claimed exact/approximate status, its justification, its charged cost, the residual coupling, the observable test, and its status. No hidden independence can be treated as zero-cost. 

 5.4 What this root forbids

 Do not assume sectors are independent because calculations are easier that way.
Do not count a shared scheme object three times as three independent successes.
Do not use additive cost unless factorization is proven or paid.
Do not claim nonseparability implies faster-than-light signalling;
 it is an accounting/root discipline, not a signalling claim.
 
 What it catches: independent sector patches, separate fits sold as one generator, additive MDL without an independence proof, uncounted shared scheme objects, wrongly duplicated anchors, ignored cross-wall dependencies, and joint observable vectors split into cherry-picked passes.

 5.5 What this root can force

 A rule is Nonseparability-clean only if the global object is stated, exact separations are proven or approximate separations are charged/tested, shared anchors are counted once as shared, joint observables are generated jointly or the independence debt is paid, and residual factorization ambiguity is named. In standard form:

 The global Shape/Scale object either proves a factorization or forces a joint generator;
no independent sector patch remains admissible without a paid debt.
 
 5.6 What this root cannot claim

 Nonseparability is an accounting and root discipline, not a signalling claim. It does not assert faster-than-light influence; the no-signalling guardrail (see the Nonseparability deep root, R7) keeps it from overclaiming. It also cannot, by itself, tell you how sectors couple — it only forbids assuming they do not without paying for it. A factorization that is honestly proven is allowed; what is forbidden is factorization assumed for convenience.

 5.7 Support-to-force ladder (Nonseparability)

 NARRATIVE-ONLY : "the sectors are basically independent" — no ledger.
ROOT-COMPATIBLE : independence is not obviously contradicted.
ROOT-SUPPORTED : factorization is plausible but neither proven nor charged.
ROOT-CONSTRAINED : some unpaid independence assumptions are eliminated.
ROOT-SELECTIVE : a small finite family of admissible factorizations remains.
ROOT-FORCED-FAMILY : one factorization class survives, modulo the global object.
ROOT-FORCED : the global object proves a factorization or forces a joint generator.
TARGET-LOADED : the sector split was chosen to make the cost ledger smaller.
 
 5.8 Wall example — the shared heat-kernel / LC-hopping object across Gap-01, SG-6, SG-7

 Gap-01, SG-6, and SG-7 share a heat-kernel scheme / LC-hopping object. Nonseparability forbids treating them as independent. If they are scored as three independent knobs, the theory has more free parameters than it really does; if they are counted as three independent successes , the theory is over-credited — the same one object is being counted three times. The honest accounting is that there is one shared scheme object underneath all three, and the correct ledger counts it once, with the cross-wall coupling named and either proven to factorize or charged. Verdict: treating Gap-01 / SG-6 / SG-7 as independent is FACTORING-BLOCKED; the shared object must be counted once and the residual coupling carried on the factorization-debt ledger. 

 5.9 Checklist for agents (Nonseparability)

 [ ] State the global object (full branch: stage + rulebook + actors + connection + readout).
[ ] List exact product structures and approximate product structures.
[ ] List shared anchors, shared scheme objects, shared scale bridges.
[ ] Identify residual correlations and name the factorization debt.
[ ] State whether outputs are generated jointly or patched separately.
[ ] Count each shared object once — never as N independent successes.
[ ] Justify any additive cost ledger with a factorization proof or a charged cost.
[ ] Name residual factorization ambiguity explicitly.
 
 5.10 Honest ceiling

 This root is an admissibility/interface root. It does not generate physics by itself. It tells us whether a claimed rule from Shape, Scale, and Granularity has paid for every independence and factorization assumption it uses — whether sectors are genuinely separable, whether shared objects are counted once, whether joint observables are generated jointly. Passing Nonseparability removes unpaid-factorization artifacts: independent-sector patches, additive ledgers without proofs, shared objects miscounted as separate successes. It is necessary for closure, not sufficient for truth. A claim with a clean factorization ledger can still be non-invariant, lack an endpoint, or be target-loaded. Nonseparability is one of four guards, and clearing it is not a status change.

 6. The support-to-force ladder (shared reference)

 A second-layer root becomes ROOT-FORCED only when it becomes a necessity condition , not merely a warning. The grading ladder below is the single shared standard for all four roots; each root's section above instantiated it. The general conversion rule:

 ROOT-SUPPORTED:
 the second-layer root makes the rule natural or useful.

ROOT-CONSTRAINED:
 the second-layer root eliminates some alternatives.

ROOT-FORCED:
 given the deep roots, wall object, laws, and the closed admissible class,
 the second-layer root eliminates all non-equivalent alternatives
 and leaves one rule / equivalence class.
 
 The full ladder, lowest to highest, with the target-loaded floor:

 NARRATIVE-ONLY:
 names a concern but does not constrain anything.

ROOT-COMPATIBLE:
 does not contradict the second-layer root.

ROOT-SUPPORTED:
 the root makes the rule natural, but alternatives survive.

ROOT-CONSTRAINED:
 the root eliminates some alternatives.

ROOT-SELECTIVE:
 the root plus toolbox leaves a small finite family.

ROOT-FORCED-FAMILY:
 one equivalence class survives, modulo allowed transformations.

ROOT-FORCED:
 one target-blind rule survives inside a closed class.

TARGET-LOADED:
 the rule depends on the desired answer.
 
 TARGET-LOADED is not a rung above ROOT-FORCED — it is the disqualifier . Any rule that depends on the desired answer fails the bottom of the ladder regardless of how forced it looks on the other fields, exactly as the deep-root pages downgrade a target-selected rule to TARGET-SELECTION-RISK.

 6.1 The four-field certificate

 Every second-layer ROOT-FORCED claim must fill all four fields. A blank field means the claim is at most ROOT-SUPPORTED.

 1. Anchor-transfer chain
2. Necessity counterfactual
3. Closed candidate class
4. Target-blindness

 Field 
 What it requires 
 Per-root anchor-transfer 

 1. Anchor-transfer chain 
 Name where the rule's content comes from — not the target. 
 Invariance: branch-preserving gauge/BRST class → invariant physical operator. Record Interface: correct Shape operator → measured/audit record. Causal Order: frozen allowed-input grammar → rule independent of target. Nonseparability: global Shape object → joint generator / factorization ledger. 

 2. Necessity counterfactual 
 Perturb the root/interface and show the rule changes or disappears. 
 If the gauge equivalence class changes, the invariant operator changes. If the readout object changes, the valid record changes. If the causal order is reversed, the rule becomes target-loaded. If the global object does not factorize, the additive ledger fails. 

 3. Closed candidate class 
 Define the complete admissible class — never a hand-drawn list. 
 all branch-preserving transformations; all correct-object readout maps; all allowed-input grammars; all factorization assumptions compatible with the global Shape. 

 4. Target-blindness 
 The rule must be writable without the target value or desired status. 
 Failure: choosing a basis because it makes the number match; choosing a tolerance after seeing the miss; choosing a sector split because it makes the cost ledger smaller; choosing a readout map because it outputs the target. 

 The per-root forcing standards, stated once:

 Invariance-forced:
 the branch-preserving equivalence class is closed, all non-invariant
 candidates are eliminated, and one invariant rule/equivalence class survives.

Record-interface-forced:
 the correct Shape object has only one admissible finite readout to the relevant
 observable/audit record, or all others are eliminated as wrong-object /
 wrong-scale / non-finite / target-loaded.

Causal-order-forced:
 the rule grammar is derivable without target values; all target-dependent
 grammars are eliminated or paid as fits.

Nonseparability-forced:
 the global Shape/Scale object either proves a factorization or forces a joint
 generator; no independent sector patch remains admissible without a paid debt.

 7. Completeness test for the second layer

 A wall passes the second-layer screen only if all four roots pass at once. Failing any one is enough to keep the wall from being labeled closed.

 Invariance:
 The claim survives the branch-preserving equivalence class.

Record Interface:
 The claim terminates in a finite correct-object observable/audit record.

Causal Order:
 The rule was specified without target backflow, or declared as a paid fit.

Nonseparability:
 No independence/factorization debt is hidden.
 
 The verdict labels, applied to any wall after running the screen:

 Verdict 
 Meaning 

 SECOND-LAYER-PASS 
 all four roots pass; the wall is eligible for deep-root + Layer-1 evaluation (this is not closure) 

 INVARIANCE-BLOCKED 
 the claim is a representation/gauge/scheme/off-shell artifact 

 RECORD-BLOCKED 
 no finite correct-object observable/audit endpoint, or audit-only sold as physics 

 CAUSAL-ORDER-BLOCKED 
 the rule was shaped by the target (target leakage), not declared as a paid fit 

 FACTORING-BLOCKED 
 unpaid factorization/independence debt; shared objects miscounted 

 SECOND-LAYER-PARTIAL 
 some roots pass and others are not yet evaluated or not yet discharged 

 Crucial honesty point. SECOND-LAYER-PASS is not gate closure. It certifies only that a claim has survived the four admissibility filters and is therefore worth evaluating on the physics . The deep roots (Shape, Scale, Granularity) and a Layer-1 observable test still have to be saturated for a gate to be physics-closed — and on this candidate, 0 of 33 gates are physics-closed. The four wall examples on this page (the Gap-01 off-shell sign, the Gap-01 exact sphere checks, the SG8 exponent, and the Gap-01/SG-6/SG-7 shared object) are all currently blocked by at least one second-layer root, which is exactly why their gates remain open.

 8. Red-team traps

 The four interface roots exist to block sentences that sound like results. Each of these is a false closure the second layer must never let stand:

 "It's gauge-covariant, so it's physical." Rejected — covariance is compatibility, not invariance. Only branch-preserving residue counts, and an off-shell local sign is not an invariant predicate (Invariance §2).

 "The hash reproduces, so the physics is validated." Rejected — a hash is an audit anchor certifying which object was tested, not that the object's physics is true (Invariance §2.6 / Record Interface §3.6).

 "The exact check passed, so the gate is closed." Rejected — an exact audit record on a sub-object is an audit win, not the emission of the total physical observable, and not route agreement (Record Interface §3.8).

 "The exponent matches the mass ratio, so it's derived." Rejected — if the ratio chose the exponent, the rule is target-loaded; a match is not a derivation (Causal Order §4.8).

 "Three independent sectors all worked." Rejected — if they share one scheme object, that is one success counted three times, not three independent successes (Nonseparability §5.8).

 "Independence is the natural default." Rejected — exact independence is never free; it must be proven, paid, or tested against the global object (Nonseparability §5).

 9. Status ledger

 The honest standing of the four interface roots, by claim type. These are admissibility roots: their job is to block , and their status is about whether the discipline is enforced, never about whether physics is generated.

 Item 
 Endpoint type 
 Status 
 Notes 

 Invariance (branch-preserving equivalence) 
 meta-root / discipline 
 DECLARED ROOT / ENFORCED 
 admissibility condition; upstream of every physical root 

 Record Interface (finite endpoint) 
 meta-root / discipline 
 DECLARED ROOT / ENFORCED 
 empirical-interface condition; audit ≠ physics 

 Causal Order (no target backflow) 
 physical interface root / discipline 
 DECLARED ROOT / ENFORCED 
 provenance guard; fit must be declared and paid 

 Nonseparability (no unpaid factorization) 
 physical interface root / discipline 
 DECLARED ROOT / ENFORCED 
 accounting discipline; no-signalling guarded 

 Second-layer screen (all four) 
 admissibility verdict 
 NECESSARY-NOT-SUFFICIENT 
 SECOND-LAYER-PASS ≠ gate closure 

 Gap-01 off-shell positivity sign 
 claim 
 INVARIANCE-BLOCKED 
 sign is not an invariant positivity predicate 

 Gap-01 exact sphere/Bianchi checks 
 audit record 
 ROOT-SUPPORTED / RECORD-BLOCKED for closure 
 strong audit win; total $a_6$ not emitted; routes not reconciled 

 SG8 fitted flavor exponent 
 claim 
 CAUSAL-ORDER-BLOCKED / TARGET-LOADED 
 pre-registered winding-class exponent is the only clean route; open 

 Gap-01 / SG-6 / SG-7 shared scheme object 
 accounting 
 FACTORING-BLOCKED if treated as independent 
 one shared object; count once; coupling carried as debt 

 Discipline, restated. The four second-layer roots are admissibility/interface roots. They do not generate physics; they decide whether a claimed rule from Shape, Scale, and Granularity is invariant, record-facing, target-blind, and not secretly factorized. Passing them is necessary for closure, not sufficient for truth. Anchored is not derived · selected is not forced · frozen-and-reproducible is not proven-unique · dissolved is not solved. This is a Theory-of-Everything candidate under honest audit — 0 of 33 gates are physics-closed. no status changes. 

 10. Read it / cross-links

 The three deep physical roots the second layer sits above: The Shape (the frozen three-layer object) · The Scale (the absolute magnitude) · The Granularity (the finite cost-floor).

 The Seven Deep Roots — where these four (Invariance and Record Interface as Tier-0 meta-roots; Causal Order and Nonseparability as physical roots) sit in the full root hierarchy, with operational statements, allowed/forbidden claims, and specialist hardening questions.

 The gate scoreboard — honest per-gate status across all 33 gates · the walls register · the closure routing .

 The anchors overview — the anchoring rule-set and the full bridge stack at a glance.

 Appendix — the per-root agent checklists

 The four checklists, collected for reference. Each is the finite set of questions an agent must answer before a wall may be labeled SECOND-LAYER-PASS . A blank box is a blocked screen.

 A.1 Invariance checklist

 [ ] Name the physical object held fixed.
[ ] Name the transformations that preserve that object (the branch).
[ ] Name the transformations that change the branch.
[ ] List the quantities that survive the preserving transformations.
[ ] List the quantities that are artifacts of description.
[ ] State the on-shell / off-shell status of any gauge-dependent claim.
[ ] Confirm the equivalence-class ledger is finite and the convention class is closed.
[ ] Confirm the surviving rule is target-blind.
 
 A.2 Record Interface checklist

 [ ] Name the thing being read and the correct object identity.
[ ] Name the readout map from that object.
[ ] State the observable or audit record produced.
[ ] Declare units, scale, scheme, uncertainty, tolerance.
[ ] Classify the record: physical observable / computational / audit-only / falsifier.
[ ] State whether the record TESTS the rule or SELECTED the rule.
[ ] Confirm the record is finite (file, value, tolerance, predicate, falsifier).
[ ] Confirm reproduction is independent — a captured log is not a reproduction.
 
 A.3 Causal Order checklist

 [ ] Declare allowed inputs.
[ ] Declare forbidden targets (and the holdout table).
[ ] State the rule grammar and the map-construction time/order.
[ ] State the scale/tolerance policy and confirm it was fixed before outputs.
[ ] Run the target-perturbation test: if the target changed, would the rule change?
[ ] Classify the result: prediction vs paid fit.
[ ] Confirm holdouts were not used during reconstruction.
[ ] Confirm no projector / exponent / chamber / tolerance was chosen by the target.
 
 A.4 Nonseparability checklist

 [ ] State the global object (stage + rulebook + actors + connection + readout).
[ ] List exact product structures and approximate product structures.
[ ] List shared anchors, shared scheme objects, shared scale bridges.
[ ] Identify residual correlations and name the factorization debt.
[ ] State whether outputs are generated jointly or patched separately.
[ ] Count each shared object once — never as N independent successes.
[ ] Justify any additive cost ledger with a factorization proof or a charged cost.
[ ] Name residual factorization ambiguity explicitly.
 
 Final standard. This page succeeds if, for any wall, you can now answer: Does the claim survive every branch-preserving redescription? Does it terminate in a finite, correct-object observable or audit record? Was the rule written without the target flowing backward into it? Is every independence assumption proven, paid, or tested? If all four are yes, the wall earns SECOND-LAYER-PASS — eligibility, not closure. If any is no, the wall is blocked, and that block is exactly why its gate is honestly open. The second layer removes ways to be wrong; it never supplies a way to be right. 0 of 33 gates are physics-closed. no status changes.