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

The Granularity — finite-cost discipline 

 The Granularity — finite-cost discipline — rendered package. Rendered from index.md ; frozen technical content unchanged by rendering.

 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.

 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: 0 of 33 gates are physics-closed , and the running status change count is no status changes .

 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.

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

 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.

 Layer 
 What Granularity does here 
 The required precision 

 Observables / audit anchors 
 exact checks, two-route agreement, frozen falsifiers, measured records 
 state the finite observable/audit record and its tolerance before reading outputs 

 Deep roots 
 Granularity is primary for cost; Shape supplies the object class it counts over; Scale supplies the magnitude its floor lives on 
 identify which root controls which cost — no cross-charging 

 Rule / map layer 
 finite rule basis and a closed candidate class 
 no hidden lookup table, no infinite precision, no hand-drawn singleton list 

 Forcing layer 
 distinguish root-forced from merely compatible 
 prove the closed class + uniqueness + a target-blind finite description 

 Verdict layer 
 pass / fail / open / blocked / dissolved 
 no partial enumeration is ever promoted to closure 

 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.

 ID 
 Constraint 
 What it means / what the page enforces 

 GRN-A 
 No unpaid labels 
 Every primitive, table, convention, factorization, assignment, and observable map used by a wall must be finite and charged . There is no free constant, no free projector, no free convention. 

 GRN-B 
 Closed candidate class 
 A survivor is forced only inside a closed / exhausted admissible class — not a hand-drawn list. "Only one option survived" means nothing unless the list is proven closed under the relevant symmetries and admissibility rules. 

 GRN-C 
 Exact object identity 
 Do not silently swap operators, spectra, ghosts, boundary objects, dimensions, schemes, or predicates. A numeric match on the wrong object closes nothing. 

 GRN-D 
 Two-route reproducibility 
 Decision-grade numeric values require structurally independent routes, or a named reason why only one route can exist. One route is a draft, not a result. 

 GRN-E 
 Exact identities as gates 
 Bianchi identities, anomaly sums, index theorems, congruence checks, cohomology / bordism operations, unitarity, and conservation laws are hard correctness gates — pass/fail, not adjustable. 

 GRN-F 
 Frozen falsifiers 
 Falsifiers, tolerances, and target / holdout status must be fixed before reading outputs. A tolerance widened after seeing the number is a fabrication. 

 GRN-G 
 Infinite towers scoped 
 A finite coefficient or mode subset cannot close an infinite tower unless a granularity / floor theorem scopes the tower. One counterterm does not retire an infinite counterterm series. 

 GRN-H 
 Finite records vs ontology 
 Finite observable records support granularity discipline; ontological discreteness is the stronger claim and must be labelled as a posit. 

 GRN-I 
 Uniform positive cost floor (addendum) 
 The root posit is not "finite resources." It is a uniform positive minimum operational / action step. Finiteness without uniformity is provably insufficient (basin-shallowing countermodel). 

 GRN-J 
 No hidden infinite precision (addendum) 
 A rule may not hide arbitrary real precision, continuous labels, infinitely adjustable tolerances, or lookup-table compression behind a finite-looking formula. 

 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-loading 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).

 Label kind 
 How it is charged 

 Integer / finite label 
 by finite-alphabet membership — log of the alphabet size, no more 

 Rational label 
 by numerator + denominator + a declared precision 

 Real-valued anchor 
 by source + uncertainty + significant digits + role — never more digits than the source supplies 

 Fitted continuous parameter 
 a paid input , full stop — unless it was generated target-blind 

 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-loaded 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, and the running status change count across this candidate's gates is no status changes . 

 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:

 Finite object class — define the finite alphabet, finite candidate class, finite rule basis, or finite state space. (Closed candidate class.) 

 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.) 

 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.) 

 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 and no status changes .

 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." 

 Generation rule — state how all candidates are generated (the construction or grammar), not a hand-drawn list.

 Closure — show the generated set is closed under the relevant transforms: symmetry, gauge, basis change, quotient, admissibility, and branch-preserving maps.

 Equivalence quotient — state which candidates are the same up to relabeling / gauge / basis / convention, and quotient by that relation.

 Exhaustion — all generated candidates are listed, or symbolically classified (a finite parametrization of an infinite family counts).

 Survivor ledger — record which survive and which are eliminated, by which constraint — one row per candidate, one named eliminator per casualty.

 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.

 Grade 
 What it means 
 Counts as independent? 

 Same-route-twice 
 same engine, formula, and assumptions, re-run 
 No — a re-run is not a second route 

 Weak 
 same formula, different implementation 
 barely — catches transcription bugs only 

 Medium 
 different implementation and different basis, same theorem 
 partial — shares the theorem's failure mode 

 Strong 
 structurally different routes — e.g. local-analytic vs spectral / global / experimental / theorem 
 yes 

 Decision-grade 
 structurally independent routes with independent failure modes 
 yes — the only grade that closes 

 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 a 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).

 Why this is BLOCKED until the map exists. The smallest residual is that the program needs the actual Shape→SG8 map : the admissible paths, phases, residues, assignments, and overlaps. Until that finite map is on the table, there is no closed candidate class to exhaust (GRN-B), so the flavor result cannot be FORCED — at best it is SUPPORTED / CONSTRAINED , and any "it fits" is target-selection risk.

 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 open wall 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. The program needs a genuine uniform-gap theorem or an honest axiom-conditional finite-floor dissolution — and dissolved is not solved . This is the Gap-02 cross-link.

 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 open — which is exactly why the wall is not closed.

 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.

 Item 
 Endpoint type 
 Status 
 Reduces to (anchor / axiom) 

 Granularity sub-root (cost floor) roll-up 
 deep root 
 REDUCED-TO-AXIOM 
 one named, value-free posit (the Uniform Operational Cell Law, $\Delta_0 > 0$) + one measured anchor ($\hbar$) 

 Floor exists given a compact distinguishable-record space 
 theorem 
 DERIVED 
 extreme-value theorem + pointwise positivity (unconditional given its hypotheses ) 

 Compactness of the record space 
 theorem 
 DERIVED-GIVEN (conditional) 
 finite-test-cover hypothesis + a completeness (Cauchy-closure) hypothesis carried on the ledger 

 The Uniform Operational Cell Law itself ($\Delta_0 > 0$) 
 posit 
 DECLARED ROOT / AXIOM-OPEN 
 posited, not derived from a strictly weaker premise 

 The grain equals $\hbar$ (the floor's size ) 
 measured input 
 MEASURED-ANCHOR 
 $\hbar$ — value, not structure; never derived here 

 No-unpaid-labels discipline (GRN-A) 
 discipline 
 ENFORCED 
 the finite-record / charged-ledger anchor 

 Closed-candidate-class requirement (GRN-B) 
 discipline 
 ENFORCED 
 the forcing-certificate closed-class field 

 Exact object identity (GRN-C) 
 discipline 
 ENFORCED 
 Shape object-identity anchor (no silent swaps) 

 Two-route reproducibility (GRN-D) 
 discipline 
 ENFORCED 
 exact-check / independent-route anchor 

 MDL / full-generator cost metric (W04) 
 bridge 
 OPEN 
 needs a support-to-force proof; Layer-1 description-length bridge 

 Ontological discreteness (GRN-H stronger claim) 
 posit 
 AXIOM-OPEN / declared 
 the uniform-floor posit, carried openly — not proven from finite records 

 Pre-quantum reconstruction (derive the floor from below) 
 proof target 
 OPEN 
 the keystone hole; would upgrade the root toward DERIVED 

 Combined Deep-Roots gate roll-up 
 gate 
 OPEN 
 because the sibling Shape sub-root rests on a permanent wall (absolute minimality) 

 Discipline, restated. anchored ≠ closed · selected ≠ forced · frozen-and-reproducible ≠ proven-unique · finite ≠ uniform · a numeric match on the wrong object closes nothing. The Granularity root is REDUCED-TO-AXIOM — that is a real and largely-proved reduction around the posit, not a derivation of the posit, and not whole-gate closure. 0 of 33 gates are physics-closed. 

 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/ — honest per-gate status across all 33 gates.

 Full-precision cost-floor ledger → the Appendix below, and the gate-by-object DeepRoot-granularity anchor ledger .

 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 status word for the granularity sub-root is REDUCED-TO-AXIOM ; the combined Deep-Roots gate is OPEN . 

 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. The combined Deep-Roots gate stays OPEN because its sibling Shape root rests on a permanent wall (absolute geometric minimality — an uncomputable shortest-description question, a different root). 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 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 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 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:

 The floor exists given compactness ($\varepsilon = \min_D c > 0$). DERIVED (T5).

 Compactness itself. DERIVED-GIVEN FTC + completeness (Theorem B) — conditional, not unconditional.

 The completeness ($d_{\rm op}$-Cauchy closure) hypothesis. AXIOM-OPEN / declared — on the residue ledger, never silently folded in.

 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.

 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 / computation debt. A $\Lambda$-gate test surfaced by granularity, not the granularity root itself.

 Hole 6 — uniform $SU(3)$ YM gap surviving the continuum limit (cross-gate, Gap-02). OPEN. "Discrete ⇒ positive gap" is the easy leg; the open wall is the uniform-in-$a$ lower bound (this is 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 upgrade granularity from REDUCED-TO-AXIOM toward DERIVED . Even then, the combined Deep-Roots gate stays OPEN until the Shape root is addressed.

 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 granularity reduction is not whole-gate closure. REDUCED-TO-AXIOM on the sub-root does not close the combined Deep-Roots gate, which stays OPEN because of the Shape root.

 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 / REDUCED-TO-AXIOM (sub-root);
 failed? NOT forced; combined Deep-Roots gate OPEN; 0/31 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 sub-root is REDUCED-TO-AXIOM ; the combined Deep-Roots gate is OPEN . no status changes. 0 of 33 gates physics-closed.