The Granularity — finite-cost discipline

Thesis. Granularity is the finite-cost discipline of this theory: no unpaid labels, no hidden infinite precision, no silent object swaps, and no closure without a finite admissible rule class or an exact check. It is one of the three deep roots — alongside the Shape (the frozen object that is being tested) and the Scale (the absolute magnitude that gives dimensionful numbers meaning). Granularity is the root that decides whether any claim — a survivor, a coefficient, a probability, a lifetime bound — was paid for and checked or merely narrated. The single sentence that the rest of this page unpacks: a result counts only when its finite object class, its uniform cost accounting, its exact object identity, and its target-blindness are all on the table at once.

What does “paying” for a distinction or a separation mean, exactly? It has a precise definition — see What it means to pay for something.

Honesty guard. Granularity is not "discreteness as a vibe," and it is not the soft claim that a theory uses finitely many symbols. It is the requirement that every primitive label, assignment, candidate class, tolerance, route, and observable map be finitely specified, paid, and testable under exact identity constraints — and that the floor on distinguishable cost be uniform and positive, not merely finite. Finiteness without uniformity is provably insufficient (the basin-shallowing countermodel below shows finite resources can still admit arbitrarily fine grain). This page is a completeness upgrade of the root — it is not anchor-elimination. The Granularity root still bottoms out on its anchor: a single named, value-free posit, the Uniform Operational Cell Law ($\Delta_0 > 0$), with $\hbar$ as its measured residue. anchored ≠ derived · selected ≠ forced · dissolved ≠ solved · floor ≥ 1, forever. This is a frozen Theory-of-Everything candidate under honest audit: on the live ledger the board stands at 33 RESOLVED at +0 · 0 ANCHORED at +1 · 0 OPEN, and 0 of 33 gates are physics-closed — a separate, permanent, honest axis, stated plainly (the measured-anchor floor is always ≥ 1).

Granularity floor — convention box (read this first)

Before anything else, fix what object the Granularity root is about, because the single most common misreading collapses it into "spacetime pixels."

• The object. Granularity's floor is $\Delta_0$ = the minimum distinguishable operational / action cost. That is the whole object — a floor on cost.
• What it is NOT. It is not a smallest length, not a spatial lattice spacing, not a preferred-frame cell, and not a proof that spacetime is discrete. A floor on a Lorentz-scalar cost picks no frame; a floor on a length would (length contracts), so the length reading is explicitly disclaimed.
• Where it lives. On the full three-layer Shape (× Stage · ⊕ Rulebook · ⊗ Actors), across all 13 dimensions including time, and over all admissible records, rules, actors, operators, and maps — never a spatial-only or single-layer subset.
• Status — two separable claims. Existence of a uniform floor is a declared root / axiom-open posit (the Uniform Operational Cell Law). The value / size residue ($\hbar$) is measured / anchored, NOT derived. The page never lets the second masquerade as the first. On the live ledger the gate carrying this root closes CERTIFIED-IRREDUCIBLE · RESOLVED +0 — closed by naming the posit and proving no internal lever can derive it from a weaker premise (the two countermodels on this page), never by pretending to derive it.

Read the full precision (PDF) account of this object in the Appendix.

What the floor buys — the evidence

Dropping the continuum is not a philosophical taste; it is the move that makes specific, famous problems never arise — and every item below is checkable at its source. Two honesty rules govern the whole list, stated up front and kept: dissolved is not solved (a dissolution removes a false debt; it derives nothing and closes no owed number), and ħ’s value is never derived — it is the floor’s measured size, full stop.

Quantum gravity’s infinities never arise

For ninety years, pushing gravity-plus-quantum-theory to infinitely short distances produced divergences — but “infinitely short” was an inherited assumption, not a fact. Give reality a finest grain — a smallest operationally-recordable cell, anchored near the compactification scale ~6×10¹⁶ GeV — and the entire infinite tower of short-distance divergences never arises: the infinities were never real. Because the floor sits on a Lorentz-scalar action, not a coordinate length, it does what a hand-inserted cutoff cannot — it dissolves the divergence class without picking a frame. And the specific one-loop UV obstruction is shown not even to apply: in 13 (odd) dimensions the compared quantity is not well-posed. Proven: gates UQF-5C and UQF-9. The limit, named: dissolving the divergence class does not exhibit a full strong-coupling UV completion — that wall is shared by strings, loops, and asymptotic safety alike, and is closed here as a certified-irreducible external dependency, never claimed as solved.

The black-hole center comes out finite

General relativity predicts its own breakdown: infinite curvature at a black hole’s center. Trace that infinity to its hidden assumption — space subdividable to a mathematical point — replace the assumption with the floor, and the curvature levels off at a large but finite value; the point singularity becomes a small finite core. The control is decisive: put the idealized continuum back and the infinity reappears exactly, proving the floor is what does the work. Proven: the Black-Hole Singularity + Horizon gate. The limit, named: nothing about escaping a black hole or altering its exterior is claimed, and the interior microstate/Page-curve bookkeeping belongs to Gap-13, closed there as a named external dependency.

The Big Bang becomes the first payable record — and the direction is right

A record costs granularity, and that cost is time-dependent — the engine of this framework’s second, fully independent way to read the early universe. The direction is the point: record cost grows toward the Big Bang — run history backward and the price of a single distinction climbs until nothing can be paid for at all, so “before the Big Bang” is not an earlier clock reading but an unpayable epoch — and distinctions are cheapest, and the knowable universe widest, at the present, where the window of observability opens symmetrically around us. The Big Bang is the beginning of the knowable, not the beginning of time; no singularity is required, and both record-cost bookkeeping and dimensional analysis stop at the identical Planck time. Run the entire cosmic timeline both ways — the granularity budget against standard cosmology, sharing no machinery — and the scoreboard reads 44 tests / 30 agree / 14 indeterminate / 0 disagree. Proven: the Early & Distant Universe section — the method, the direction, and every milestone. The limit, named: the whole denominator is always shown — the 14 indeterminate rows are the questions the entire field still shares, held open in public, and the Planck-wall rows are labeled indeterminate because no validated theory computes past them.

The floor forces the squaring rule

Plain quantum mechanics staples “probability = amplitude squared” to the front as an unexplained postulate. On a discrete outcome set — exactly what the floor supplies — demanding real, non-negative weights that compose across independent systems leaves exactly one survivor: exponent 2. Experiment independently agrees: the Sorkin three-way-interference parameter, which vanishes if and only if p = 2, is measured ≈ 0 (Sinha et al. 2010, and tighter repetitions since). A century-old free postulate becomes a forced consequence of a grainy bottom. Proven: the Born Rule gate. The limit, named: this reduces the axiom’s size; it is not a rule-free derivation — non-contextuality remains an openly-disclosed imported assumption, split into two named legs, with a countermodel proving nothing is smuggled.

The two countermodels — the axiom proved honest

The strongest evidence for the floor’s integrity is that this framework attacked its own axiom and published the result. Two explicit countermodels prove that finite resources alone would not give you a uniform floor: the delta-test countermodel (finite resources, yet no finite test cover exists) and the basin-shallowing countermodel (finite total resource, yet arbitrarily fine grain) — both constructed in full in the Appendix. That is exactly why the Uniform Operational Cell Law ($\Delta_0 > 0$) must be its own named axiom, and why naming it is strength, not weakness: a posit proved non-trivial cannot be smuggled, and the tempting shortcut “it’s finite, therefore it’s granular” is exposed as the trap it is. ħ is then nothing more than the named floor’s measured size. Proven: the DeepRoot-Granularity dossier, which banks both countermodels. The limit, named: ħ’s value is never derived, and a pre-quantum derivation of the floor itself is a named open upgrade path (Appendix A.10) — shown, never hidden.

1. The three layers Granularity controls

Granularity is not a single test; it is a discipline that applies at every layer of the analysis stack. The three roots split the work cleanly, and Granularity is the root that polices the cost and the bookkeeping of all of it.

The discipline is comprehensive in a second sense too. Per the deep-roots ledger, Granularity is a property of the entire Shape — the cost-floor governs distinguishable steps across all 13 dimensions, including time, and all three Shape layers (× Stage · ⊕ Rulebook · ⊗ Actors), at full precision (PDF), never a spatial-only or ×-layer-only subset. It remains a floor on a Lorentz-scalar action (cost, not length), but applied over the whole object. A gate closure that charges the floor on only part of the Shape is using an incomplete root and may fail for that reason alone, with nothing wrong in the physics.

2. Finite-record discipline vs ontological granularity

The most important distinction on this page is between two strengths of the same idea, because conflating them is the single most tempting overclaim.

Finite-record discipline. What any honest observer or computation can operationally verify: every contact between theory and world factors through a finite, reproducible, physically instantiated record — a measurement to finite precision, a detector logging a finite count, a computation halting with finite output. This is the Record Interface root, and the program can use it immediately. It is the currency in which any theory — this one or a rival — earns physical status.

Ontological granularity. The stronger claim that reality itself bottoms out in a uniform positive operational/action step. This is the Granularity / cost-floor root, and it is not a free consequence of the finiteness of records. Inferring a discrete world from finite records is a separate, undischarged step.

The constraint that pins this is GRN-H (finite records vs ontology): finite observable records support granularity discipline; ontological discreteness remains a stronger root posit unless independently proven. The corresponding forbidden claim is blunt: "finite experimental records alone prove ontological discreteness" is an overclaim. The allowed claim is the modest one: no unpaid labels.

So the program runs the finite-record discipline at full strength today and carries ontological granularity as a named, status-labelled posit. The full-precision account of exactly how that posit is reduced — to one value-free axiom with $\hbar$ as its residue — is in the Appendix — Full precision below.

3. The full definition

Granularity, stated completely, is the conjunction:

Granularity = uniform positive cost floor   + finite admissible alphabets / candidate classes   + no unpaid labels or hidden lookup tables   + exact object identity   + exact law / theorem checks   + independent-route reproducibility   + frozen falsifiers and tolerances   + scoped infinite towers.

Each clause is a constraint with an ID, and the next section is the constraint table that is the technical backbone of the whole page. Two clauses are the completeness additions that make this the upgraded root: the uniform positive cost floor (GRN-I) and no hidden infinite precision (GRN-J). They are what separate "finite bookkeeping" from real Granularity.

4. The complete constraint table

Every ID. This is the authoritative constraint set, including the GRN-I and GRN-J addendum additions.

The operational test that compresses the table into four questions you can ask of any candidate rule:

What is the finite alphabet / finite object class / finite rule basis?
What is the cost of each label or primitive?
What exact identity or independent route verifies it?
Could the same result be obtained only by smuggling hidden continuous precision?

If hidden precision or unpaid enumeration remains after those four questions, the rule is not Granularity-forced.

The finite-object manifest — the standard template for every claim

Every Granularity claim is required to publish a finite-object manifest before it can be graded. The manifest is the machine-readable form of "what finite object are you actually charging, and under what rules?" Any claim that cannot fill every field is GRANULARITY-BLOCKED by construction.

object_id:              a stable identifier for this finite object
object_type:            candidate class | operator basis | path class |
                        observable map | rule grammar | falsifier set
allowed_symbols:        the finite alphabet the object is built from
allowed_labels:         the labels that may be assigned (and from what set)
allowed_operations:     the admissible operations / transforms on the object
equivalence_relations:  what counts as "the same" (relabeling / gauge / basis / convention)
excluded_labels:        labels explicitly forbidden (and why)
paid_primitives:        every constant / table / map admitted as a charged input
target_dependent_fields:any field that was or could have been set after seeing the target
closure_proof:          the proof (or pointer) that the class is closed / exhausted

The manifest makes three sins detectable at a glance: an unpaid label appears as a symbol used but absent from paid_primitives; a silent object swap appears as a mismatch between two claims' object_id/object_type; and target-selection appears as any non-empty target_dependent_fields that is not itself paid as an input.

The precision-cost rule — where Granularity meets Scale

GRN-A says charge every label; the precision-cost rule says how much a label costs, because a real number is not free and is not a single bit. This is the seam where Granularity and Scale meet (the floor lives on Scale's absolute-magnitude anchor; real-valued anchors cost precision, SCL-09).

Frozen before outputs. All tolerances must be fixed before any output is seen (GRN-F).

Forbidden moves. (i) Using more precision than the anchor supplies. (ii) Hiding arbitrary real precision inside a compact formula (a finite-looking expression with a continuous knob has infinite hidden precision — GRN-J). (iii) Tuning a continuous value until an observable matches — that is target-selection, not derivation.

5. What Granularity FORCES vs what it only SUPPORTS

This is the heart of an honest root page. Granularity constrains almost everything; it forces very little. Every Granularity claim must be tagged with one of six categories, and the difference between the top two is the difference between a result and a hope.

GRANULARITY-FORCED:
  finite class closed, alternatives exhausted, unique survivor,
  target-blind, exact identity / test passes.

GRANULARITY-SUPPORTED:
  finite / cost discipline makes the rule natural, but alternatives remain.

GRANULARITY-CONSTRAINED:
  Granularity eliminates some alternatives but not all.

GRANULARITY-PAID:
  a finite primitive / table / assignment is admitted as an input and charged.

GRANULARITY-BLOCKED:
  candidate class, cost floor, object identity, or route agreement is missing.

GRANULARITY-FAILED:
  hidden precision, object swap, target-selected enumeration,
  or exact-identity violation detected.

The support-to-force ladder (make every status change explicit)

The six tags above are verdicts; the ladder below is the status change path a claim climbs to earn them, mirroring the Scale and Layer-2 ladders. Each rung is a strictly stronger statement, and a claim may be stamped only at the rung it has actually reached. No rung may be skipped.

L0  Narrative                — a finite-sounding story; no object, no ledger.
L1  Finite-compatible        — the claim is consistent with a finite object class.
L2  Finite-supported         — a finite/cost discipline makes the claim natural; alternatives remain.
L3  Finite-constrained       — Granularity eliminates some alternatives but not all.
L4  Finite-selective         — the survivor is selected inside the class, but closure or blindness is unproven.
L5  Finite-forced-family     — a closed class forces a *family*; the unique member is not yet pinned.
L6  Granularity-forced       — closed class + uniform cost + exact identity + target-blindness
                               + observable test, ALL passing. (= GRANULARITY-FORCED)

L6 requires the same five conditions as the forcing certificate below, all at once. Nothing on the board currently stands above L2–L3 for any whole gate — consistent with 0 of 33 gates physics-closed.

The forcing certificate (the four-field grade)

A Granularity claim earns the top tag, GRANULARITY-FORCED, only if all four fields are satisfied — the same four-field discipline used across the program for any FORCED verdict (anchor-transfer · root-counterfactual · closed candidate class · target-blindness), specialized to cost:

1. Finite object class — define the finite alphabet, finite candidate class, finite rule basis, or finite state space. (Closed candidate class.)
2. Uniform cost accounting — every primitive / label / assignment is charged under a uniform positive cost floor. (Anchor-transfer: the cost traces to the named floor, not to a hidden knob.)
3. Exact identity / reproducibility — object identity is exact, and either exact-theorem checks or structurally independent routes verify the result. (Root-counterfactual: change the object and the result must change.)
4. Target-blindness — the finite rule class and the survivor cannot have been drawn around the target.

Downgrade rules. If the candidate class is not closed, downgrade out of FORCED. If the class was chosen after seeing the target, mark target-selection risk and downgrade. The honest reality across this candidate's gates: most Granularity contributions land at SUPPORTED, CONSTRAINED, or PAID. There are no GRANULARITY-FORCED whole-gate closures on the board — consistent with 0 of 33 gates physics-closed, which is exactly what the vocabulary is for: forced-from-nothing is never claimed, and every closure names what it rests on.

The closed candidate-class certificate (the stricter GRN-B proof recipe)

"Only one option survived my list" is the single most common false closure, and the four-field certificate above leans on GRN-B to block it. This is the proof recipe that field demands. A candidate class is closed only when all six steps are on the table — the fix for "I listed three options and one survived."

1. Generation rule — state how all candidates are generated (the construction or grammar), not a hand-drawn list.
2. Closure — show the generated set is closed under the relevant transforms: symmetry, gauge, basis change, quotient, admissibility, and branch-preserving maps.
3. Equivalence quotient — state which candidates are the same up to relabeling / gauge / basis / convention, and quotient by that relation.
4. Exhaustion — all generated candidates are listed, or symbolically classified (a finite parametrization of an infinite family counts).
5. Survivor ledger — record which survive and which are eliminated, by which constraint — one row per candidate, one named eliminator per casualty.
6. Red-team hole — state what class could have been missed by the generation rule itself (the meta-risk that the grammar is too narrow).

A survivor count is meaningful only after the quotient (step 3) and only inside an exhausted, closed class (steps 1–2, 4). Steps 5–6 are what convert "one survived" from a coincidence into a constraint — and step 6 is why even a complete-looking ledger is never stronger than Finite-selective (L4) until the generation rule itself is shown wide enough.

6. How Granularity interacts with Shape and Scale

The three roots are distinct and must not be cross-charged. The clean division of labor:

• Shape supplies the object class. Granularity counts and charges, but it counts over the object that Shape specifies — the metric carrier, the quotient/global data, the rulebook, the actor/operator layer, the connection, the readout map, and the frozen branch identity (Shape's own addendum constraint, SHP-I). When GRN-C (exact object identity) forbids a silent operator swap, it is policing whether the computation used the Shape-specified operator. Object identity is a Shape question; enforcing that it stays exact is a Granularity question.
• Scale supplies the magnitude the floor lives on. Granularity's cost floor is a floor on a Lorentz-scalar action, not on a length — and that is precisely a Scale fact (the floor lives on the absolute-scale anchor, Scale's addendum constraint SCL-I). $\hbar$, the measured size of the floor, is a measured-anchor under Scale, not something Granularity derives. When GRN-A charges a real-valued anchor "for its precision," that precision cost is the place Granularity and Scale meet (see SCL-09: real-valued anchors cost precision).

The compressed triad, the three questions you ask of every wall in order:

Shape:        What is the exact frozen object, and what map does it permit or force?
Scale:        What magnitude or ratio is meaningful, and what bridge makes it meaningful?
Granularity:  What finite rule / candidate / record structure prevents hidden labels,
              infinite precision, and arbitrary fitting?

A wall may not say "Shape forces X" without naming the part of Shape that does the forcing; it may not say "the number is Scale-derived" without naming the scale/scheme object; and it may not say "Granularity forces X" without passing the four-field certificate. The three guards are independent, and a claim must clear all three.

7. How gaps and gates constrain Granularity — worked examples

The 19 walls / gaps are where Granularity stops being abstract. For each one, the discipline extracts: the finite object/class, the unpaid labels at risk, the exact-identity check, the independent route or theorem check, the falsifier/tolerance status, the infinite-tower or continuum risk, and the Granularity constraint that results. Below are the most instructive worked examples mined from the per-gap dossiers. (The full constraint matrix spans W01–W19; these are the cases that teach a distinct Granularity lesson.)

Worked example A — Gap-01 / W03 (the a6 one-loop diagnostic): exact object identity, GRN-C

The wall. Can the frozen 13D graviton+ghost $a_6$ Seeley–DeWitt object be computed with the correct operator, object class, and scale predicate?

The Granularity lesson — the canonical GRN-C case. Object identity is discrete and exact: the Bochner ghost value cannot be silently substituted for the physical Lichnerowicz ghost. These are different operators with different connections on a non-symmetric $K_6$; the canonical Peter–Weyl / Levi-Civita proxies are not interchangeable with the physical Lichnerowicz operator by default. A route-agreement test (GRN-D) only counts if both routes compute the same operator, connection, bundle, grading, and predicate — a numeric match on the Bochner object does not close a wall about the Lichnerowicz object. This is the single sharpest illustration on the site of why GRN-C exists: a wrong-object match is the most seductive false closure, because the number can look right.

The Granularity constraints extracted: GRN-06 (Bianchi and sphere-rational checks are exact correctness gates, GRN-E); GRN-07 (two structurally independent routes are mandatory for a decision-grade value, GRN-D); GRN-08 (object identity is discrete — no Bochner-for-Lichnerowicz swap, GRN-C). Binding residual: the GT/LC off-diagonal physical graviton+ghost route reconciliation. Status: the wall is not closed merely because the constraints are stated — they are necessary conditions, not a forcing certificate.

The route-independence taxonomy (grading GRN-D)

GRN-D ("two-route reproducibility") is not a binary; two computations can "agree" at five different strengths, and only the top two are decision-grade. The Gap-01 case above is the live reason this taxonomy is enforceable.

The Gap-01 worked instance — why agreement requires the same operator. A Bochner ghost route ($E = 0$) is NOT confirmation of the physical Lichnerowicz ghost route ($E = -\mathrm{Ric}$). These two routes evaluate different Laplace-type operators on the non-symmetric coset $K_6 = SU(3)/T^2$. By Gilkey's heat-kernel theorem, the Seeley–DeWitt coefficient $a_6$ depends on the endomorphism $E$, so the two operators must produce different $a_6$ — they cannot agree, and an apparent agreement would be an object swap, not a confirmation. Route agreement is meaningful only when both routes evaluate the same operator. This is what makes object-identity (next) enforceable rather than decorative.

The object-identity fingerprint (a route agreement counts only when fingerprints match)

Every computation on this candidate carries an object-identity fingerprint. Two routes "agree" only when their fingerprints are identical; a numeric match across non-matching fingerprints is an object swap (GRN-C), not a confirmation (GRN-D).

branch                          : which frozen 13D branch object
geometry                        : the exact metric carrier (e.g. SU(3)/T² coset)
dimension                       : the dimension of the object being charged
operator                        : the exact Laplace-type / differential operator
connection                      : Levi-Civita / canonical / other
bundle                          : the bundle / representation the operator acts on
ghost-sign convention           : Bochner (E=0) vs physical Lichnerowicz (E=−Ric)
boundary / orbifold / fixed-point object : the exact boundary or fixed-point datum
scheme-window                   : the renormalization scheme and its validity window
predicate                       : the exact yes/no question being asked
observable endpoint             : the integrated / measured quantity actually compared

What the fingerprint catches (each is a real false-closure pattern this page refuses):

• Bochner ghost $\ne$ physical Lichnerowicz ghost — different operator + ghost-sign convention; the $a_6$ values must differ (above).
• Boundary coefficient $\ne$ Donnelly fixed-point trace — different boundary / orbifold / fixed-point object.
• Bulk sign $\ne$ positivity functional — different predicate.
• Local density $\ne$ integrated observable — different observable endpoint.

Worked example B — W04 (Granularity ⇒ MDL / full-generator cost): the no-unpaid-labels root, GRN-A

The wall. Does Granularity force full-generator cost accounting, or only support it?

The Granularity lesson. A theory's cost metric must charge the full generator, not just a dimension count. Every primitive constant, lookup table, observable map, factorization assumption, and free assignment must be finite and charged (GRN-A). The competing cost dimensions — dimension burden vs anchor burden — must be costed separately or explicitly bundled (this is also why Shape's cost includes the observable-generator map, SHP-09, and why real-valued anchors cost precision, SCL-09).

The honest status — a SUPPORTED, not FORCED, case. The smallest residual is explicit: the program needs a support-to-force proof that Granularity necessitates full-generator MDL over dimension-first counting, or the MDL/full-generator metric remains an open bridge (GRN-10). This is the textbook example of a rule that Granularity makes natural but does not yet force — the cost-floor presupposes a description-length metric that is itself an OPEN Layer-1 bridge. The page must not promote "natural" to "forced."

The no-free-factorization rule (inherited from Nonseparability)

The W04 residual above has a deeper cause, and it is the same one that makes flavor (W06) hard: a cost ledger is not additive by default. Granularity inherits this from the Nonseparability deep root — see The Second-Layer Roots. Splitting a ledger into independent sectors, labels, costs, observables, or candidate-classes is itself a paid claim that requires proof, payment, or an error bound. Absent that:

• Factorization = an unpaid label. Writing $C = C_1 + C_2 + \dots$ silently asserts the sectors do not interact — that assertion is a label and must be charged (GRN-A).
• Additive MDL is root-supported, NOT root-forced. Full-generator MDL assumes a decomposition of description length; until the decomposition is justified, the metric stays at SUPPORTED (this is exactly the W04 open bridge).
• Sector-by-sector fitting is a target-selection risk. Tuning each sector to its own observable is the additive disguise of fitting the whole; it must be flagged, not credited.

This rule strengthens W04 (additive-MDL bridge) and W06 (flavor sector factorization) — in both, the additive split is the unproven move.

Worked example C — W06 (flavor / SG8 map): closed classes and frozen falsifiers, GRN-B + GRN-F

The wall. Does Shape force the flavor chamber, path residues, ladders, projectors, and the CKM/PMNS/CP readout — or are those selected because they fit?

The Granularity lesson. Flavor labels, ladder exponents, sector projectors, and chamber choices cannot be free labels. Fermion ladders/exponents must be discrete residues or winding/action classes, not fitted patterns (GRN-13). And the falsifiers — $m_u$ and the other sector outputs — require frozen tolerances before seeing outputs (GRN-14, an instance of GRN-F). The SG8 map must derive its finite assignments from Shape/path/cycle/residue structure, or pay them as inputs (GRN-A again).

How the discipline paid off — the up-quark rescue. This is the discipline's biggest on-the-record win. When the 4-D shadow calculation put the up-quark at ~4.4σ, the rules above forbade every easy exit: no per-family fudge factor (GRN-A), no widened tolerance (GRN-F), no factor reverse-engineered to hit the answer. The miss was published on the theory's own front pages instead. The resolution then arrived exactly the way this table demands it must: a target-blind, symmetry-derived factor $1/\sqrt{6} = 1/\sqrt{|S_3|}$ — fixed purely by the order of the six-element Weyl group $S_3$ of the flavor shape, machine-checked to have used only the group order, existing only in the full 13-D three-layer transport — giving $m_u = 1.2948$ MeV vs the measured $1.27 \pm 0.43$ MeV: a pull of +0.058σ. The flavor labels ARE discrete residues (integer ladder labels, no continuous per-family exponent), the falsifier stayed frozen, and negative controls reject the "you fit a ~0.40" alternative. SG-8 stands RESOLVED at +0 on the ledger — and it left the falsifier column the only legitimate way: by a derived, target-blind correction to the prediction itself, never by dissolution, band-widening, or retuning. A tighter up-quark measurement now either agrees or kills the frozen shape here — a sharp falsifiable prediction, kept.

Worked example D — W18 (Yang–Mills uniform gap): infinite-tower scoping and the uniform floor, GRN-G + GRN-I

The wall. Can the finite/Shape route produce a uniform $SU(3)$ Yang–Mills gap without changing the Clay target (pure 4D $SU(3)$ YM)?

The Granularity lesson — where GRN-I and GRN-G bite hardest. Finite lattice / transfer-matrix positivity can support but cannot replace the Osterwalder–Schrader continuum measure (GRN-37). And the decisive constraint: the uniform lower bound must survive the continuum and volume limits, or be honestly scoped as axiom-conditional (GRN-38). "Discrete ⇒ positive gap" is the easy direction; the hard leg — the literal Clay problem — is a uniform-in-$a$ lower bound that survives the continuum limit. This is exactly the GRN-I distinction in action — a finite gap at each lattice spacing is not a uniform gap, just as finite resources do not imply a uniform $\Delta_0$. A finite coefficient or a single-spacing positivity does not close the infinite tower of continuum-limit refinements (GRN-G) unless a floor theorem scopes it.

Status — closed by naming the owner, never by faking the proof. The uniform-in-$a$ leg is the literal Clay Millennium problem — unsolved by anyone. On the live ledger, Gap-02 closes CERTIFIED-IRREDUCIBLE · RESOLVED +0 by partitioning the demand exactly: the continuum-existence half dissolves given the discrete geometry, the finite-value/lower-bound half reduces precisely to Clay (borrowed-open, named, never claimed), and the gap value enters as a measured anchor like the Planck mass — and dissolved is not solved: the framework explicitly declines to claim the missing proof. That refusal, on the one famous problem a dishonest theory would fake, is the credibility anchor for every other closure on the board.

The continuum / tower scoping certificate (finite coefficients do NOT close infinite towers)

A finite computation can contribute to an infinite tower or a continuum limit; it cannot close one without a scoping certificate. Every claim that touches a limit must fill all eight fields, or it is BLOCKED on the tower:

finite object          : the finite coefficient / mode subset / single-spacing result in hand
infinite tower or limit: the series / continuum / volume / cutoff structure it sits inside
truncation rule        : exactly which modes / orders are kept vs dropped
omitted-mode bound     : a bound on everything dropped (not "assumed small")
uniformity requirement : the quantity that must hold uniformly (e.g. the gap, uniform in a)
limit order            : the order of limits — volume→∞, spacing-or-floor→continuum, cutoff→∞
surviving lower bound  : the bound / error estimate that survives the limit
status                 : scoped | open | axiom-conditional | failed

The decisive field is uniformity: a finite value at each step is not a uniform value across the limit (the GRN-I distinction). This certificate is crucial for W01 (counterterm towers), W18 (the uniform-in-$a$ YM gap), heat-kernel towers, continuum-existence claims, and any omitted-mode sum. For W18 specifically, the uniformity requirement is the uniform-in-$a$ lower bound, the limit order puts continuum after volume, and the status is scoped — by certification, not by theorem: the uniform-gap leg reduces exactly to the standing Clay problem, borrowed-open and never claimed, with the gap value a measured anchor (the Gap-02 terminal, certified-irreducible).

Worked example E — W17 (proton-decay operators): one overlooked label refutes the claim, GRN-A + GRN-B

The wall. Does the geometry forbid or suppress the dangerous baryon-violating operators at the observed lifetime scale?

The Granularity lesson. A finite operator basis by dimension and charge is required (GRN-35), and the closed-class discipline is unforgiving here: one overlooked operator refutes the safety claim (GRN-36). This is GRN-B at its sharpest — a "safety" survivor is only meaningful if the candidate class of dangerous operators is provably exhausted. A hand-drawn list that misses one operator is not a closed class; it is a false negative waiting to happen.

Worked example F — W15 (Born weights) and W16 (black-hole microstates): counting is not deriving

W15 — Born weights. Finite records/branches can be counted, but count measure alone cannot smuggle Born weights (GRN-31). You must derive or pay the squared-amplitude measure — do not narrate it (GRN-32). The residual is a root-forced probability measure, not mere record-compatibility. This is the Granularity refusal of a narrative: "there are finitely many branches, so the probabilities are obvious" is exactly the move GRN-J and GRN-A forbid.

W16 — black-hole microstates / Page curve. The microstate count must be finite and match the area law (GRN-33), and the Page curve requires a discrete information ledger, not narrative conservation (GRN-34). Again the discipline converts a story ("information is conserved") into a finite, checkable ledger — or it stays BLOCKED.

The cross-gate pattern

Across all 19 walls, the same Granularity moves recur: (i) demand a finite object class before any "only one survives" claim (GRN-B, seen in W05 bundle-uniqueness, W14 inflation potentials, W17 proton operators); (ii) forbid the silent object swap (GRN-C, seen in W03 ghosts, W08 custodial-$\rho$ generators); (iii) require two routes or a named reason for one (GRN-D, W03); (iv) freeze falsifiers first (GRN-F, W06 $m_u$, W12 washout parameters, W14 spectrum tolerances); (v) scope infinite towers (GRN-G, W01 counterterm towers, W18 continuum limit); and (vi) charge every label (GRN-A, universal). None of these, by itself, closes a wall — they are the necessary conditions that an honest closure must satisfy.

8. Red-team traps

These are the false-closure patterns the page exists to block. Each is a sentence that sounds like a result and is not.

"Only one option survived my list." Rejected — unless the list is proven closed under the relevant symmetries and admissibility rules. A hand-drawn list of survivors forces nothing (GRN-B). Countered by: the closed-candidate-class field of the forcing certificate. (Seen in W05, W17.)

"The formula is finite, so the information cost is finite." Rejected — if the formula hides arbitrary real precision, infinitely adjustable tolerances, or a lookup table (GRN-J). A finite-looking expression with a real-valued knob inside has infinite hidden precision. Countered by: the fourth operational-test question ("could this be obtained only by smuggling hidden continuous precision?").

"The routes agree." Rejected — unless both routes compute the same object: the same operator, connection, bundle, grading, scheme, and predicate (GRN-C + GRN-D). Countered by: the Gap-01 Bochner/Lichnerowicz case — a numeric match on the wrong ghost is not agreement.

"This finite coefficient closes the infinite tower." Rejected — unless a granularity / floor theorem scopes the tower (GRN-G). One coefficient does not retire an infinite series; one lattice spacing does not prove a continuum-limit gap. Countered by: W01 (counterterm towers) and W18 (uniform-in-$a$ gap).

"It's finite, therefore it's granular." Rejected — this is the deepest trap, and the reason GRN-I exists. Finite resources do not imply a uniform floor. The basin-shallowing countermodel (Appendix) exhibits finitely-resourced records with arbitrarily fine grain. Finiteness without uniformity is insufficient. Countered by: the uniform-positive-cost-floor certificate field.

"Finite records prove a discrete world." Rejected — finite records are the empirical interface (Record Interface root); ontological discreteness is the stronger Granularity posit and must be labelled, not inferred for free (GRN-H).

9. Status ledger

The honest standing of the Granularity root, by claim type. Status words are drawn only from the allowed set.

Discipline, restated. anchored ≠ closed · selected ≠ forced · frozen-and-reproducible ≠ proven-unique · finite ≠ uniform · a numeric match on the wrong object closes nothing. The Granularity gate closes CERTIFIED-IRREDUCIBLE · RESOLVED +0 on the live ledger — a real and largely-proved reduction around a named posit, never a derivation of the posit, with both axioms and the measured anchor shown in the open. That is what an honest terminal looks like: the posit is named, priced, and proven non-trivial — not smuggled. 0 of 33 gates are physics-closed, and ħ's value is never derived.

10. Read it

• The other two roots: The Shape — the frozen 13D three-layer object Granularity counts over · The Scale — the absolute magnitude its cost-floor lives on.
• The Seven Deep Roots — where Granularity (R4) sits relative to Invariance, the Record Interface, Causal Order, Scale, Shape, and Nonseparability.
• The gate scoreboard → /gates/ — the closure-of-record: 33 RESOLVED at +0 · 0 ANCHORED at +1 · 0 OPEN, every terminal named.
• The closure-of-record for this root → the DeepRoot-Granularity dossier (anchor ledger) — the gate this page instantiates, with both countermodels banked.
• The floor with time turned on → The Early & Distant Universe — record cost as a function of time, the Big Bang as the first payable record, and the 44-test two-method scoreboard (30 agree · 14 indeterminate · 0 disagree).
• The floor forcing a law → the Born Rule dossier — exponent 2 as the only survivor on a discrete outcome set.
• Full-precision cost-floor ledger → the Appendix below.

Related: the anchors overview, the walls register, and the closure routing.

Appendix — Full precision

This appendix carries the full-precision content: the cost-floor $\Delta_0 > 0$, $\hbar$ as its measured residue, the finite-class / no-unpaid-labels accounting, the proved reduction chain, the two banked countermodels, and the open reconstruction family. It is the gate-level instantiation of the granularity anchor ledger. The honest terminal for this root on the live ledger is CERTIFIED-IRREDUCIBLE · RESOLVED +0 — a reduction around a named posit, never a derivation of it.

A.1 The one-line, in full

Reality having a smallest operational step is no longer a vague confession. The granularity root has been compressed to one named, value-free posit — a positive operational cell, $\Delta_0 > 0$ — with $\hbar$ pinned as the size of that step (a residue, never an added knob). That reduction is real and largely proved around the posit; it is not a derivation of the floor — and on the live ledger that is exactly how the gate closes: CERTIFIED-IRREDUCIBLE · RESOLVED +0, the posit named, priced, and proven non-trivial. The sibling roots close on the same ledger: Shape at DERIVED-GIVEN-anchor · +0 (the most economical complete carrier under the declared rules; absolute minimality over all conceivable shapes — an uncomputable shortest-description question — is explicitly not claimed), and Scale at MEASURED-ANCHOR · +0. The granularity sub-root has no anomaly ledger and no spectrum to admit; its exact objects are a reduction chain — a metric, theorems, countermodels, and a single named posit.

A.2 Frozen inputs (what the gate stands on, not what it produces)

• Frozen branch hashes dcc66f1b2685 / a5b1e6f9d951. The 13D branch is read-only and unmutated. These hashes are audit anchors — they certify which object was tested and that it cannot be quietly retuned. They do not validate the physics.
• The measured action anchor $\hbar$ is given / charged: it enters as the value of the floor, not as something this gate derives. The gate does not derive $\hbar$, $k_B$, the Bekenstein constant, or $\Delta_0$ — these are residues by construction. Every "the floor exists" statement below is about structure, never about magnitude.

A.3 The pre-Hilbert object — operational distinguishability

The gate is built entirely on operational primitives — records, admissible tests, outcome frequencies — with no Hilbert space, Born rule, or trace distance in any root statement. The root metric is the operational total-variation distance

$$ d_{\rm op}(r,s) \;=\; \sup_{T,e}\,\big| P(e \mid r, T) - P(e \mid s, T) \big| . $$

This is well-posed pre-quantumly (a classical witness on a measurable space reduces it to total variation; indicator tests give $d_{\rm op}=1$ for distinct points). Status: GIVEN / pre-Hilbert primitive. It matches Hardy / Chiribella–D'Ariano–Perinotti operational distinguishability and is not derived here; Hilbert orthogonality is a downstream representation of $d_{\rm op}$, not its definition. This breaks the surface distinguishability circle ($d_{\rm op}$ needs no QM); it does not break the deeper certification circle.

A.4 The reduction chain, link by link

Each link is marked DERIVED, conditional, or posited.

(1) Cost, not length — DERIVED. What is quantized is action / cost (a Lorentz scalar), not space (a length). Gliding through a continuum of non-orthogonal (overlapping) states is free; only transitions to orthogonal (distinguishable) states cost, and an infinite chain of such steps, each costing $\ge$ a fixed floor, cannot complete under finite resource — so any completable process has finitely many costly steps. A length floor would pick a preferred frame (length contracts) and break Lorentz invariance; a floor on a scalar picks no frame. This is the firewall against "spacetime is discrete."

(2) The floor from compactness — T5, DERIVED. Let $D$ be the space of distinguishable records and $c : D \to \mathbb{R}_{\ge 0}$ a cost.

$$ \textbf{T5.}\quad D \text{ compact},\; c \text{ continuous},\; \big(c(x)=0 \Rightarrow x \notin D\big) \;\Longrightarrow\; \varepsilon = \min_D c > 0. $$

Proof. A continuous function on a compact set attains its minimum; the minimizer $x^\ast \in D$, so $c(x^\ast) > 0$ by pointwise positivity; hence $\varepsilon = c(x^\ast) > 0$. $\blacksquare$ T5 is unconditional given its hypotheses — which transfers the whole question onto: is $D$ compact?

(3) Compactness reduced to FTC — Theorem B, DERIVED-GIVEN (conditional). With the Finite-Test-Cover (FTC) hypothesis and the hypothesis that $R_{\rm phys}$ is closed under $d_{\rm op}$-Cauchy limits (completeness), $R_{\rm phys}$ is compact. Sketch. Fix $\eta>0$; FTC gives a finite test family, and the operational coordinate map $\Phi_\eta(r) = (P(e_j \mid r, T_j))_{j=1}^{M} \in [0,1]^M$ lands in a totally bounded cube; covering it by sup-norm cells of radius $\eta$ yields a finite $3\eta$-net, so $R_{\rm phys}$ is totally bounded; with completeness, compact. $\blacksquare$ The completeness hypothesis is a genuine extra assumption carried on the residue ledger — total boundedness alone does NOT give compactness without it.

(4) The named target — FTC. For every bounded causal $R$ (budget $B$, duration $\tau$) and tolerance $\eta>0$ there is a finite family $\mathcal{T}_\eta = \{(T_j,e_j)\}_{j=1}^{M(B,\eta,\tau)}$ with

$$ d_{\rm op}(r,s) \;\le\; \max_{1\le j\le M}\big|P(e_j \mid r, T_j) - P(e_j \mid s, T_j)\big| \;+\; \eta . $$

In words: every operational distinction makeable with bounded causal resources is $\eta$-approximable by finitely many bounded-resource tests — the pre-quantum analogue of nuclearity, stated with no Hilbert space.

(5) The sufficiency lemma — basin-packing, DERIVED-GIVEN (conditional on $\Delta$). Assume finite total variation $\mathrm{Var}_{\rm op}(R)\le B$ and that each stable record requires a robustness basin of depth $\ge \Delta$. Pairwise-resolvable records have disjoint depth-$\ge\Delta$ basins, so

$$ N\cdot\Delta \le B \;\Rightarrow\; N \le \lfloor B/\Delta \rfloor < \infty, $$

hence FTC follows with $M \lesssim (B/\Delta)^2$. No QM, Bekenstein, or thermal import enters. This is conditional on the cell law $\Delta>0$ — exactly the irreducible posit — so it grounds the count, never the grain.

A.5 The two banked losses — why the posit is honest, not lazy

Finite resources do not force a uniform floor. Two countermodels prove it, and they are why there is a posit to name at all.

Loss 1 — FTC is not free (the delta-test countermodel). DERIVED. Take $R = [0,1]$ with delta-tests $f_x(r) = \mathbb{1}[r=x]$. For distinct $r \ne s$, $d_{\rm op}(r,s) = 1$, while any finite family $\{f_{x_1},\dots,f_{x_M}\}$ returns $0$ on a pair $r,s \notin \{x_j\}$, so $\max_j |f_{x_j}(r) - f_{x_j}(s)| = 0$ and FTC fails for every $\eta < 1$. $\blacksquare$ Finite resources $\nRightarrow$ FTC.

Loss 2 — uniformity is not free (the basin-shallowing countermodel). DERIVED. This is the countermodel the public root summary cites as the reason GRN-I (uniform positive cost floor) is a separate constraint from mere finiteness. Take basins of depth $d_n = B\,2^{-n-1}$. Then $\sum_n d_n = B/2 < B$ — finite resource is fully respected — yet $\inf_n d_n = 0$: infinitely many robust records with arbitrarily fine grain. So finite causal support + finite duration + finite action/energy-time do not imply a uniform $\Delta_0$; they imply at most per-system total boundedness. $\blacksquare$ Finiteness $\nRightarrow$ uniformity.

Diagnostic — the reduction is specific, not trivial. The gap between $\{\eta\text{-dependent floor}\}$ and $\{\text{uniform } \Delta_0\}$ is a theorem (a counterexample to the uniform claim under the stated premises). Were uniformity free, there would be no posit to name; the countermodels show there is. This is the full-precision justification for why the public page insists "finite is not granular" is a red-team trap.

A.6 The obstruction split

$$ G_{\rm gran,local}(\text{compact}) : \;\varepsilon > 0 \;\;\text{(DERIVED via T5)}, \qquad G_{\rm gran}(\text{from below}) : \;\Delta_0 > 0 \;\;\text{(AXIOM-OPEN)}. $$

We do not assert $G_{\rm gran}$ is closed: the uniform floor is named, not derived.

A.7 The "smallest step" phrase, split into honest objects

The single phrase "reality has a smallest step" hides five claims with five different statuses:

1. The floor exists given compactness ($\varepsilon = \min_D c > 0$). DERIVED (T5).
2. Compactness itself. DERIVED-GIVEN FTC + completeness (Theorem B) — conditional, not unconditional.
3. The completeness ($d_{\rm op}$-Cauchy closure) hypothesis. AXIOM-OPEN / declared — on the residue ledger, never silently folded in.
4. The grain is uniform ($\Delta_0$ system-independent). AXIOM-OPEN / declared — the Uniform Operational Cell Law; the basin-shallowing countermodel proves it is not forced by finiteness.
5. The grain equals $\hbar$. MEASURED-ANCHOR / residue — value, not structure; outside any reconstruction.

Conflating these five is exactly the overclaim this root refuses.

A.8 The Pontryagin relocation

A Pontryagin-style existence/discreteness equivalence (existence + discreteness $\Leftrightarrow$ phase compactness) relocates the uniformity posit onto phase compactness; it does not eliminate it. Deriving uniformity from unitarity is circular — it would put granularity downstream of QM. So the granularity posit count is one, not zero. "Zero posits" is forbidden.

A.9 The no-unpaid-labels accounting

The finite-class / no-unpaid-labels discipline (GRN-A, GRN-J) is what keeps the whole ledger honest: every constant sits on the residue ledger $\{\hbar,\ k_B,\ \text{Bekenstein constant},\ \Delta_0,\ \text{completeness}\}$. The reframe from $\{$cost floor $\varepsilon\}$ to $\{$resolution floor $\Delta$ + compactness$\}$ does not remove a constant — it trades one residue ($\varepsilon$) for another, better-motivated one ($\Delta_0$). If $\Delta_0$ cannot be derived from a deeper substrate law, the honest close is documentary: state that one residue replaced another, keeping the ledger complete. No label is free, and no relabel eliminates a posit.

A.10 The open reconstruction family

None of these is closed by the reduction above; each is a concrete, finite, target-blind work-package.

• Hole 1 — derive FTC from strictly weaker primitives (the keystone). OPEN. From a distinguishability test-space + additive-cost axiom set (no Hilbert orthogonality, no trace distance, no Bekenstein, no nuclearity), derive the Hilbert structure so that Margolus–Levitin ($\tau \ge \pi\hbar/2E$), Landauer ($k_BT\ln 2$), and the Bekenstein bound all fall out as theorems.
• Hole 2 — prove FTC (or the compactness step) from bounded-causal-resource axioms alone. OPEN. Defeat the live circularity that the finite budget $B$ must not secretly be the per-milestone floor; keep $B = $ action / energy·time (a finite-information-capacity relabel is illegitimate, giving $N \le 2^B$ trivially).
• Hole 3 — the co-fundamentality certificate. OPEN. The surface distinguishability circle is broken; the deeper certification circle — that the floor sits at-or-below QM in the implication order — is the recognized-open object, the same reconstruction as Hole 1.
• Hole 4 — derive $\Delta_0$ from a deeper resource law. OPEN. $\Delta_0$ is a new residue introduced alongside $\hbar, k_B$. If it cannot be derived, the close is documentary, not a derivation.
• Hole 5 — $\Lambda$-magnitude (cross-gate, RELOCATES). OPEN upgrade path. A $\Lambda$-gate test surfaced by granularity, not the granularity root itself — the $\Lambda$ value stands MEASURED-ANCHOR · RESOLVED +0 (honestly measured, never derived).
• Hole 6 — uniform $SU(3)$ YM gap surviving the continuum limit (cross-gate, Gap-02). The literal Clay problem — borrowed-open, owned by no one. "Discrete ⇒ positive gap" is the easy leg; the uniform-in-$a$ lower bound is the standing Clay Millennium problem, and Gap-02 closes certified-irreducible by naming it rather than faking it (the full-precision form of Worked Example D / W18).

Closing Holes 1/3 (the same reconstruction object) is the single largest possible move on this root — it would strengthen the terminal from CERTIFIED-IRREDUCIBLE toward outright DERIVED, retiring the posit itself. Every hole above is an upgrade path, not a debt: the gate's terminal stands on the ledger, and these are the named ways to make it stronger.

A.11 Anti-claims (what this root refuses to say)

• It does not derive the granularity floor from a strictly weaker principle; the floor is named (the posit), not derived. Ruled out from the stated premises by the delta-test and basin-shallowing countermodels.
• "Zero posits" is forbidden. The granularity posit count is ONE (the Uniform Operational Cell Law). The Pontryagin iff relocates, it does not eliminate.
• It does not derive the value of $\hbar$, $k_B$, the Bekenstein constant, or $\Delta_0$ — residues by construction.
• No spacetime discreteness. A smallest length is explicitly not claimed; only a floor on the Lorentz-scalar cost.
• No strict irreducibility. "No deeper principle anywhere is more fundamental than this floor" is an unprovable universal negative; the honest ceiling is co-fundamentality.
• Conditional ≠ unconditional. Theorem B gives compactness only with completeness; total boundedness alone does not.
• The frozen-branch hashes are audit anchors; they do not validate the physics.
• The reduction is not a derivation, and the terminal says so. The gate closes certified-irreducible because the posit is named and proven non-trivial — it never pretends the floor was derived, and the upgrade paths in A.10 are shown in the open.

A.12 The Granularity page final test — the boxed gate every claim must clear

This is the page's single operational gate, the upgrade of the old reader's-checklist. For any claimed result on this candidate — a survivor, a coefficient, a probability, a lifetime bound — run all ten questions. A result that cannot answer all ten in the affirmative (or honestly mark the negative) is not Granularity-forced. The right-hand column shows how the Granularity root itself answers each, as the worked instance.

 1. Finite object class?                  → yes — the distinguishable-record space D / R_phys
                                            (publish a finite-object manifest)
 2. Uniform floor / cost rule?            → Δ₀ > 0, the Uniform Operational Cell Law
                                            (uniform, not merely finite — GRN-I)
 3. Labels / primitives all paid?         → ħ, k_B, Bekenstein const, Δ₀, completeness
                                            (charged by the precision-cost rule; GRN-A/GRN-J)
 4. Candidate class closed?               → via the six-step closed-class certificate
                                            (generation→closure→quotient→exhaustion→ledger→hole)
 5. Object identity exact?                → yes — fingerprints match
                                            (GRN-C; no Bochner-for-Lichnerowicz swap)
 6. Routes structurally independent?      → graded on the route-independence taxonomy
                                            (Strong / Decision-grade only; GRN-D)
 7. Falsifiers / tolerances frozen?       → yes — fixed before outputs
                                            (GRN-F; the two banked countermodels)
 8. Any hidden continuous precision?      → no — no real knob behind a compact formula
                                            (GRN-J; the precision-cost rule)
 9. Survives equivalence quotienting?     → yes — counted only after relabel/gauge/basis quotient
                                            (the survivor count is post-quotient)
10. Forced / supported / paid / open /    → SUPPORTED sub-claims; gate terminal CERTIFIED-
    failed?                                 IRREDUCIBLE · RESOLVED +0; NOT forced-from-nothing;
                                            0 of 33 physics-closed

Continuum and infinite-tower claims additionally fill the continuum / tower scoping certificate; ledger splits additionally clear the no-free-factorization rule.

Final discipline. This is a completeness upgrade of the Granularity root, not anchor-elimination. The floor stays at ≥ 1: the root bottoms on the uniform positive cost-floor posit, with $\hbar$ as its measured residue. selected ≠ forced · dissolved ≠ solved · anchored ≠ derived · finite ≠ uniform · a numeric match on the wrong object closes nothing. The granularity gate stands CERTIFIED-IRREDUCIBLE · RESOLVED +0 on the live ledger — the posit named, priced, and proven non-trivial. 0 of 33 gates physics-closed, stated plainly; ħ's value is never derived; dissolved is not solved.