@lapxo/obligations 0.4.4 → 0.4.6

package/package.json

@@ -1 +1 @@
-{"name":"@lapxo/obligations","version":"0.4.4","description":"The algebra of a cell: two poles, origins with phase, eight acts.","type":"module","license":"MIT","author":"Lapxo","repository":{"type":"git","url":"git+https://github.com/Lapxo/obligations.git"},"keywords":["obligations","lattice","provenance"],"sideEffects":false,"engines":{"node":">=22.12"},"exports":{".":{"types":"./dist/lattice/index.d.ts","default":"./dist/lattice/index.js"},"./debit":{"types":"./dist/debit/debit.d.ts","default":"./dist/debit/debit.js"},"./encounter":{"types":"./dist/field/encounter.d.ts","default":"./dist/field/encounter.js"},"./field":{"types":"./dist/field/field.d.ts","default":"./dist/field/field.js"},"./forms":{"types":"./dist/lattice/forms.d.ts","default":"./dist/lattice/forms.js"},"./lattice":{"types":"./dist/lattice/lattice.d.ts","default":"./dist/lattice/lattice.js"},"./measures":{"types":"./dist/measures/index.d.ts","default":"./dist/measures/index.js"},"./packed":{"types":"./dist/debit/packed.d.ts","default":"./dist/debit/packed.js"},"./present":{"types":"./dist/field/present.d.ts","default":"./dist/field/present.js"},"./price":{"types":"./dist/lattice/price/index.d.ts","default":"./dist/lattice/price/index.js"},"./replay":{"types":"./dist/replay.d.ts","default":"./dist/replay.js"},"./shuffle":{"types":"./dist/debit/shuffle.d.ts","default":"./dist/debit/shuffle.js"},"./signatures":{"types":"./dist/field/signatures.d.ts","default":"./dist/field/signatures.js"},"./views/field":{"types":"./dist/views/field.d.ts","default":"./dist/views/field.js"},"./views/product":{"types":"./dist/views/product.d.ts","default":"./dist/views/product.js"},"./package.json":"./package.json"},"files":["dist","README.md","LICENSE","TARGET.bound","receipts.bound","docs/measures.md","samples/measures","vectors/measures","samples/yes/algebra-is-closed.json","samples/yes/field-uses-price-and-debit.json","samples/yes/three-theories-one-algebra.json","src/lattice/index.ts","src/field/motion.ts","samples/yes/installed-artifact.json","samples/no/installed-artifact.json","vectors/measures/installed-artifact.cli.json","docs/img","docs/paper.md","docs/reference.md","docs/learn/in-phase.md","docs/learn/price.md","docs/learn/signature.md","docs/learn/thermometer.md","docs/learn/withdrawal.md","vectors/laws/policy.json","vectors/laws/l7-tolerant-k.json","vectors/laws/l8-phase-defect.json","vectors/laws/l9-mix-loss.json","vectors/laws/implementation-043.json","samples/laws/cofailure-pairs/no/sample.json","samples/laws/cofailure-pairs/yes/sample.json","samples/laws/linage-rest/no/sample.json","samples/laws/linage-rest/yes/sample.json","samples/laws/lineage-ceiling/no/sample.json","samples/laws/lineage-ceiling/yes/sample.json","samples/laws/marginal-information/no/sample.json","samples/laws/marginal-information/yes/sample.json","samples/laws/semilattice/no/sample.json","samples/laws/semilattice/yes/sample.json","vectors/laws/cofailure-pairs.json","vectors/laws/cofailure-pairs.native.json","vectors/laws/coordination.json","vectors/laws/f1/finite-arithmetic.json","vectors/laws/f1/path-witness.json","vectors/laws/helly-comb.json","vectors/laws/helly-comb.lean.json","vectors/laws/linage-rest.native.json","vectors/laws/lineage-ceiling.json","vectors/laws/lineage-ceiling.native.json","vectors/laws/marginal-information.json","vectors/laws/marginal-information.native.json","vectors/laws/meet-semilattice.json","vectors/laws/meet-semilattice.native.json","vectors/laws/resolution-encounters.json","proofs/lineage-ceiling.json","proofs/cofailure-pairs.json","proofs/marginal-information.json","proofs/helly-comb.json","proofs/resolution-encounters.json","proofs/coordination.json","proofs/lean/Obligations/Cell.lean","proofs/lean/Obligations/HellyComb.lean","samples/yes/H1-uncertainty.json","samples/no/H1-uncertainty.json","vectors/laws/f1/path-witness.json","vectors/laws/f1/finite-arithmetic.json"],"scripts":{"build":"tsc --build","test":"node --import ./test/setup.ts --test --test-concurrency=2 test/*.test.ts test/measures/*.test.ts"},"devDependencies":{"@types/node":"^22","typescript":"^5.9.3"}}
+{"name":"@lapxo/obligations","version":"0.4.6","description":"The algebra of a cell: two poles, origins with phase, eight acts.","type":"module","license":"MIT","author":"Lapxo","repository":{"type":"git","url":"git+https://github.com/Lapxo/obligations.git"},"keywords":["obligations","lattice","provenance"],"sideEffects":false,"engines":{"node":">=22.12"},"exports":{".":{"types":"./dist/lattice/index.d.ts","default":"./dist/lattice/index.js"},"./debit":{"types":"./dist/debit/debit.d.ts","default":"./dist/debit/debit.js"},"./encounter":{"types":"./dist/field/encounter.d.ts","default":"./dist/field/encounter.js"},"./field":{"types":"./dist/field/field.d.ts","default":"./dist/field/field.js"},"./forms":{"types":"./dist/lattice/forms.d.ts","default":"./dist/lattice/forms.js"},"./lattice":{"types":"./dist/lattice/lattice.d.ts","default":"./dist/lattice/lattice.js"},"./measures":{"types":"./dist/measures/index.d.ts","default":"./dist/measures/index.js"},"./packed":{"types":"./dist/debit/packed.d.ts","default":"./dist/debit/packed.js"},"./present":{"types":"./dist/field/present.d.ts","default":"./dist/field/present.js"},"./price":{"types":"./dist/lattice/price/index.d.ts","default":"./dist/lattice/price/index.js"},"./replay":{"types":"./dist/replay.d.ts","default":"./dist/replay.js"},"./shuffle":{"types":"./dist/debit/shuffle.d.ts","default":"./dist/debit/shuffle.js"},"./signatures":{"types":"./dist/field/signatures.d.ts","default":"./dist/field/signatures.js"},"./views/field":{"types":"./dist/views/field.d.ts","default":"./dist/views/field.js"},"./views/product":{"types":"./dist/views/product.d.ts","default":"./dist/views/product.js"},"./package.json":"./package.json"},"files":["dist","README.md","LICENSE","TARGET.bound","receipts.bound","docs/measures.md","samples/measures","vectors/measures","samples/yes/algebra-is-closed.json","samples/yes/field-uses-price-and-debit.json","samples/yes/three-theories-one-algebra.json","src/lattice/index.ts","src/field/motion.ts","samples/yes/installed-artifact.json","samples/no/installed-artifact.json","vectors/measures/installed-artifact.cli.json","docs/img","docs/paper.md","docs/reference.md","docs/learn/in-phase.md","docs/learn/price.md","docs/learn/signature.md","docs/learn/thermometer.md","docs/learn/withdrawal.md","vectors/laws/policy.json","vectors/laws/l7-tolerant-k.json","vectors/laws/l8-phase-defect.json","vectors/laws/l9-mix-loss.json","vectors/laws/implementation-043.json","samples/laws/cofailure-pairs/no/sample.json","samples/laws/cofailure-pairs/yes/sample.json","samples/laws/linage-rest/no/sample.json","samples/laws/linage-rest/yes/sample.json","samples/laws/lineage-ceiling/no/sample.json","samples/laws/lineage-ceiling/yes/sample.json","samples/laws/marginal-information/no/sample.json","samples/laws/marginal-information/yes/sample.json","samples/laws/semilattice/no/sample.json","samples/laws/semilattice/yes/sample.json","vectors/laws/cofailure-pairs.json","vectors/laws/cofailure-pairs.native.json","vectors/laws/coordination.json","vectors/laws/f1/finite-arithmetic.json","vectors/laws/f1/path-witness.json","vectors/laws/helly-comb.json","vectors/laws/helly-comb.lean.json","vectors/laws/linage-rest.native.json","vectors/laws/lineage-ceiling.json","vectors/laws/lineage-ceiling.native.json","vectors/laws/marginal-information.json","vectors/laws/marginal-information.native.json","vectors/laws/meet-semilattice.json","vectors/laws/meet-semilattice.native.json","vectors/laws/resolution-encounters.json","proofs/lineage-ceiling.json","proofs/cofailure-pairs.json","proofs/marginal-information.json","proofs/helly-comb.json","proofs/resolution-encounters.json","proofs/coordination.json","proofs/lean/Obligations/Cell.lean","proofs/lean/Obligations/HellyComb.lean","samples/yes/H1-uncertainty.json","samples/no/H1-uncertainty.json","proofs/m0-045/Obligations045/ConsensusGrid.lean","proofs/m0-045/Obligations045/M0Coincidence.lean","proofs/m0-045/Obligations045/M0Diagonal.lean","proofs/m0-045/Obligations045/M0Limit.lean","proofs/m0-045/Obligations045/M0Offdiag.lean","proofs/m0-045/Obligations045.lean","proofs/m0-045/lake-manifest.json","proofs/m0-045/lakefile.toml","proofs/m0-045/lean-toolchain","vectors/laws/m0-allocation.lean.json","contracts/m0-allocation.json","samples/laws/m0-allocation/yes/sample.json","samples/laws/m0-allocation/no/sample.json","vectors/laws/m0-allocation.native.json","docs/contracts/m0-allocation.md","vectors/laws/m0-finite-grid.lean.json","contracts/m0-finite-grid.json","samples/laws/m0-finite-grid/yes/sample.json","samples/laws/m0-finite-grid/no/sample.json","vectors/laws/m0-finite-grid.native.json","docs/contracts/m0-finite-grid.md","vectors/laws/m0-limit-offdiag.lean.json","contracts/m0-limit-offdiag.json","samples/laws/m0-limit-offdiag/yes/sample.json","samples/laws/m0-limit-offdiag/no/sample.json","vectors/laws/m0-limit-offdiag.native.json","docs/contracts/m0-limit-offdiag.md","vectors/laws/m0-limit-diag.lean.json","contracts/m0-limit-diag.json","samples/laws/m0-limit-diag/yes/sample.json","samples/laws/m0-limit-diag/no/sample.json","docs/proofs/floor-limit-diag.proof.json","vectors/laws/m0-limit-diag.native.json","docs/contracts/m0-limit-diag.md","vectors/laws/m0-pair-coincidence.lean.json","contracts/m0-pair-coincidence.json","samples/laws/m0-pair-coincidence/yes/sample.json","samples/laws/m0-pair-coincidence/no/sample.json","vectors/laws/m0-pair-coincidence.native.json","docs/contracts/m0-pair-coincidence.md","vectors/laws/definitions.native.json","contracts/extension-lineage-participation.json","docs/contracts/extension-lineage-participation.md","proofs/definitions-046/declaration.json","src/laws/laws.bound","vectors/laws/a7-t90.json","vectors/laws/a9-t99.json","samples/laws/definitions/yes/sample.json","samples/laws/definitions/no/sample.json","vectors/laws/experiment1a-protocol.native.json","contracts/model-collapse-1a.json","protocols/model-collapse-1a.json","docs/contracts/model-collapse-1a.md","proofs/experiment1a-046/declaration.json","vectors/laws/model-collapse-1a.json","samples/laws/experiment1a/yes/sample.json","samples/laws/experiment1a/no/sample.json","proofs/m0-046/BridgeNegatives.lean","proofs/m0-046/M0Bridge.lean","proofs/m0-046/Obligations045.lean","proofs/m0-046/Obligations045/ConsensusGrid.lean","proofs/m0-046/Obligations045/M0Coincidence.lean","proofs/m0-046/Obligations045/M0Diagonal.lean","proofs/m0-046/Obligations045/M0Limit.lean","proofs/m0-046/Obligations045/M0Offdiag.lean","proofs/m0-046/lake-manifest.json","proofs/m0-046/lakefile.toml","proofs/m0-046/lean-toolchain","vectors/laws/m0-binomial-bridge.lean.json","contracts/m0-binomial-bridge.json","docs/contracts/m0-binomial-bridge.md","samples/laws/m0-binomial-bridge/yes/sample.json","samples/laws/m0-binomial-bridge/no/sample.json","samples/laws/m0-binomial-bridge/yes/small-binomial-table.json","samples/laws/m0-binomial-bridge/no/pairwise-is-not-joint.json","contracts/m0-diagonal-conditional.json","proofs/m0-046-diagonal/BridgeNegatives.lean","proofs/m0-046-diagonal/M0Bridge.lean","proofs/m0-046-diagonal/M0Diagonal046.lean","proofs/m0-046-diagonal/M0Lindeberg046.lean","proofs/m0-046-diagonal/M0Moments046.lean","proofs/m0-046-diagonal/M0Threshold046.lean","proofs/m0-046-diagonal/Obligations045.lean","proofs/m0-046-diagonal/Obligations045/ConsensusGrid.lean","proofs/m0-046-diagonal/Obligations045/M0Coincidence.lean","proofs/m0-046-diagonal/Obligations045/M0Diagonal.lean","proofs/m0-046-diagonal/Obligations045/M0Limit.lean","proofs/m0-046-diagonal/Obligations045/M0Offdiag.lean","proofs/m0-046-diagonal/lake-manifest.json","proofs/m0-046-diagonal/lakefile.toml","proofs/m0-046-diagonal/lean-toolchain","samples/laws/m0-diagonal-conditional/no/sample.json","samples/laws/m0-diagonal-conditional/yes/sample.json","vectors/laws/m0-diagonal-lindeberg.lean.json","vectors/laws/m0-diagonal-moments.lean.json","vectors/laws/m0-diagonal-symmetric.lean.json","vectors/laws/m0-diagonal-threshold.lean.json","proofs/m0-046-identification/M0Identification046.lean","proofs/m0-046-identification/Obligations045/M0Coincidence.lean","proofs/m0-046-identification/lake-manifest.json","proofs/m0-046-identification/lakefile.toml","proofs/m0-046-identification/lean-toolchain","vectors/laws/m0-identification.lean.json","contracts/m0-moment-identification.json","samples/laws/m0-moment-identification/yes/sample.json","samples/laws/m0-moment-identification/no/sample.json","proofs/m0-046-uncertainty/BridgeNegatives.lean","proofs/m0-046-uncertainty/M0BlockCoverage046.lean","proofs/m0-046-uncertainty/M0Bridge.lean","proofs/m0-046-uncertainty/M0Diagonal046.lean","proofs/m0-046-uncertainty/M0FiniteDiscord046.lean","proofs/m0-046-uncertainty/M0Interval046.lean","proofs/m0-046-uncertainty/M0Lindeberg046.lean","proofs/m0-046-uncertainty/M0Moments046.lean","proofs/m0-046-uncertainty/M0Threshold046.lean","proofs/m0-046-uncertainty/Obligations045/ConsensusGrid.lean","proofs/m0-046-uncertainty/Obligations045/M0Coincidence.lean","proofs/m0-046-uncertainty/Obligations045/M0Diagonal.lean","proofs/m0-046-uncertainty/Obligations045/M0Limit.lean","proofs/m0-046-uncertainty/Obligations045/M0Offdiag.lean","proofs/m0-046-uncertainty/Obligations045.lean","proofs/m0-046-uncertainty/lake-manifest.json","proofs/m0-046-uncertainty/lakefile.toml","proofs/m0-046-uncertainty/lean-toolchain","contracts/m0-keff-interval.json","samples/laws/m0-keff-interval/yes/sample.json","samples/laws/m0-keff-interval/yes/api-rows.json","samples/laws/m0-keff-interval/no/sample.json","vectors/laws/m0-keff-interval.json","vectors/laws/m0-uncertainty-blocks.lean.json","vectors/laws/m0-uncertainty-interval.lean.json","vectors/laws/m0-uncertainty-finite-discord.lean.json","proofs/m1-046-diagonal/M0Bridge.lean","proofs/m1-046-diagonal/M0Diagonal046.lean","proofs/m1-046-diagonal/M0Lindeberg046.lean","proofs/m1-046-diagonal/M0Moments046.lean","proofs/m1-046-diagonal/M0Threshold046.lean","proofs/m1-046-diagonal/M1Bridge046.lean","proofs/m1-046-diagonal/M1Diagonal046.lean","proofs/m1-046-diagonal/M1Offdiag046.lean","proofs/m1-046-diagonal/Obligations045/M0Limit.lean","proofs/m1-046-diagonal/Obligations045/M0Offdiag.lean","proofs/m1-046-diagonal/lake-manifest.json","proofs/m1-046-diagonal/lakefile.toml","proofs/m1-046-diagonal/lean-toolchain","vectors/laws/m1-diagonal-partial.lean.json","contracts/m1-subcauses.json","contracts/m1-diagonal-regions.json","samples/laws/m1-diagonal-regions/yes/sample.json","samples/laws/m1-diagonal-regions/no/sample.json","proofs/m1-046-bridge/M0Bridge.lean","proofs/m1-046-bridge/M1Bridge046.lean","proofs/m1-046-bridge/Obligations045/M0Limit.lean","proofs/m1-046-bridge/Obligations045/M0Offdiag.lean","proofs/m1-046-bridge/lake-manifest.json","proofs/m1-046-bridge/lakefile.toml","proofs/m1-046-bridge/lean-toolchain","vectors/laws/m1-generator-binomial.lean.json","contracts/m1-generator-binomial.json","samples/laws/m1-generator-binomial/yes/sample.json","samples/laws/m1-generator-binomial/no/sample.json","proofs/m1-046-offdiag/M0Bridge.lean","proofs/m1-046-offdiag/M0Diagonal046.lean","proofs/m1-046-offdiag/M0Moments046.lean","proofs/m1-046-offdiag/M1Bridge046.lean","proofs/m1-046-offdiag/M1Offdiag046.lean","proofs/m1-046-offdiag/Obligations045/M0Limit.lean","proofs/m1-046-offdiag/Obligations045/M0Offdiag.lean","proofs/m1-046-offdiag/lake-manifest.json","proofs/m1-046-offdiag/lakefile.toml","proofs/m1-046-offdiag/lean-toolchain","vectors/laws/m1-offdiag-limit.lean.json","contracts/m1-offdiag-limit.json","samples/laws/m1-offdiag-limit/yes/sample.json","samples/laws/m1-offdiag-limit/no/sample.json","vectors/laws/projection-chain.native.json","contracts/projection-chain.json","proofs/projection-chain.md","vectors/laws/projection-chain.json","samples/laws/projection-chain/yes/sample.json","samples/laws/projection-chain/no/sample.json","vectors/laws/definitions.native-capture.json","vectors/laws/experiment1a-protocol.native-capture.json","vectors/laws/m0-identification.native-capture.json","vectors/laws/m0-uncertainty.native-capture.json","vectors/laws/m1-diagonal-partial.native-capture.json","vectors/laws/m1-generator-binomial.native-capture.json","vectors/laws/m1-offdiag-limit.native-capture.json","vectors/laws/projection-chain.native-capture.json","vectors/laws/experiment1a-public-input.native-capture.json","docs/img/logo.svg","docs/img/logo-fork.svg","docs/img/cell.svg","docs/img/withdrawal.svg","docs/img/price.svg","docs/img/thermometer.svg","docs/contracts/m0-moment-identification.md","docs/contracts/projection-chain.md","docs/contracts/m0-wf-floor-refutation.md","docs/contracts/m0-keff-floor-refutation.md","docs/contracts/m0-diagonal-threshold.md","docs/contracts/m1-generator-binomial.md","docs/contracts/m1-offdiag-limit.md","docs/contracts/m0-diagonal-lindeberg.md","docs/contracts/m1-diagonal-regions.md","docs/contracts/m0-diagonal-symmetric.md","docs/contracts/m0-keff-interval.md","docs/contracts/m0-diagonal-moments.md","docs/contracts/m0-refuted-inverses.md","docs/contracts/experiment1a-public-attribution.md","docs/contracts/installation-046-inputs.md"],"scripts":{"build":"tsc --build","test":"node --import ./test/setup.ts --test --test-concurrency=2 test/*.test.ts test/measures/*.test.ts"},"devDependencies":{"@types/node":"^22","typescript":"^5.9.3"}}

package/proofs/definitions-046/declaration.json

@@ -0,0 +1,11 @@
+{
+  "about": "# Extension, named lineage and effective participation\n\nExtension is the supplied set of coordinate/interval pairs in A5, compared at fixed coordinate interpretation, resolution and context. Equal extensions identify one extensional class under that convention. They do not identify historical actors, establish a shared cause or prove probabilistic independence. A named lineage is a declared model grouping with a supplied generative/ancestry mechanism, membership and weights. Its name is not observational evidence.\n\nJoint independence is factorization of the declared joint probability law for all joint events. A conditional statement names its conditioning variable and requires factorization in every positive-mass stratum. Different names, disjoint extensions and pairwise zero covariance do not suffice. The fair-bit XOR triple has independent pairs and fails joint factorization.\n\nFor finite nonnegative masses with positive total, set w_i=a_i/sum(a) and K_eff=1/sum(w_i^2). It is dimensionless weight participation, between1 and the positive-support size; equal positive weights give that size. It is not a count of causally independent extensions. For a symmetric PSD covariance C with positive trace, normalized nonnegative eigenvalues instead give spectral participation trace(C)^2/tr(C^2). These are different inputs and need a model before they can be equated. Existing participationRatio checks symmetry and nonnegative diagonal but does not certify PSD. A true covariance constructed from the declared error rows supplies PSD; passing arbitrary matrices directly does not. Zero variation is unmeasured. In O4, K_eff=K and identification from population moments apply only in the declared uniform known-p family; nonuniform moment collisions remain.\n\nA7 concerns fixed coordinates, resolution, context and ceilings under added live narrowing constraints. Withdrawal and witnessed local widening may reopen freedom on the same coordinate. A sum of coordinate log-cardinal freedoms is not automatically joint Shannon entropy. T90 equates log-cardinality with entropy for nonempty finite uniformly distributed admissible states at fixed resolution; it does not establish the identity for arbitrary priors or a physical phase interpretation.\n\nA9 is a representation convention, not a convergence theorem. T99 concerns finite records and worlds, an acyclic reachable dependency graph and total supplied lattice operations: evaluation takes finitely many operations. Reachable ancestral cycles reject, while unreachable cycles do not affect a query. An arbitrary monotone iteration still needs its carrier, operator, seed and progress/height hypotheses; a monotone reflection on incomparable singleton intervals has a two-cycle. Different hypotheses and missing proofs are not a fork.\n\nThe historical C1 independence-is-distance wording supplies no probabilistic factorization. Definitions settle meaning only. Conditional lineage identification, causal subgroup recovery and oracle-free reference remain open. This companion text changes no signed base, algebra, M/3-M/4 or wire.\n",
+  "at": "witness:obligations046/O8",
+  "by": "target",
+  "form": "alphabet",
+  "measure": "text",
+  "role": "writes",
+  "scope": "prose/en/contracts/extension-lineage-participation",
+  "shape": "docs/contracts/extension-lineage-participation.md",
+  "value": "lock"
+}

package/proofs/experiment1a-046/declaration.json

@@ -0,0 +1,11 @@
+{
+  "about": "# Experiment 1a: protocol, no measurement\n\nThe versioned model-collapse-1a protocol is prepared independently of dataset selection. No owner-selected dataset, license, bound training/aggregation model or finite analysis design has been supplied; no data were retrieved and no empirical experiment was run. The result is unmeasured, not zero, pass, fail or a law.\n\nFreeze the protocol digest before retrieval. A separate run manifest must bind the owner-selected snapshot/license, model and training provenance, lineage mechanism, volume grid, truth/quality endpoint, sampling units/dependence blocks, exploratory/holdout split, seed, stopping rule, finite hypothesis, effect threshold and valid uncertainty. Freeze its digest before retrieval, and freeze the final exploratory analysis before opening holdout. Digests identify bytes; they do not certify a signed admission or delivery.\n\nRecord prior exposure, including this session; unknown training exposure remains unknown. Keep related units and duplicates from leaking across splits. Reuse O5 uncertainty only under its actual sampling/calibration hypotheses. Preserve failed runs and report every prespecified outcome whether the falsifier succeeds or fails. No posthoc endpoint or optional stopping is authorized.\n\nA finite within-lineage curve that continues falling is a candidate empirical challenge only to a specified finite prediction or justified bound. It does not by itself refute a positive asymptotic floor. The training process, quality and lineage assumptions must be supplied; no model is invented from the experiment title. Causal interpretations, including the unspecified historical (ii)/(iii), remain unmeasured without an observable intervention, justified assignment and a defined estimand. Descriptive observations cannot close causal identification.\n\nConditional lineage identification, causal subgroup recovery and oracle-free reference remain open. This protocol changes no algebra, M/3-M/4, wire, signed base or protocol instrument.\n",
+  "at": "witness:obligations046/O9",
+  "by": "target",
+  "form": "alphabet",
+  "measure": "text",
+  "role": "writes",
+  "scope": "prose/en/contracts/model-collapse-1a",
+  "shape": "docs/contracts/model-collapse-1a.md",
+  "value": "lock"
+}

package/proofs/m0-045/Obligations045/ConsensusGrid.lean

@@ -0,0 +1,72 @@
+import Std
+set_option maxRecDepth 10000
+set_option maxHeartbeats 8000000
+namespace Obligations045
+-- Finite closed-form calculation only. This file does not assert a limit theorem.
+def binom : Nat → Nat → Nat
+  | 0, 0 => 1
+  | 0, _ + 1 => 0
+  | _ + 1, 0 => 1
+  | n + 1, k + 1 => binom n k + binom n (k + 1)
+def configs : Nat → List (List Bool)
+  | 0 => [[]]
+  | k + 1 => (configs k).flatMap (fun xs => [false :: xs, true :: xs])
+def ones (xs : List Bool) : Nat := (xs.filter id).length
+-- p=P/20, c=C/20. Below/equal/above 1/2 encoded as 2/1/0.
+def loss2 (K P C m : Nat) : Nat :=
+  let lhs := 2 * (20 * C * m + (20-C) * P * K)
+  let rhs := 400 * K
+  if lhs < rhs then 2 else if lhs == rhs then 1 else 0
+def grouped (K P C : Nat) : Nat :=
+  ((List.range (K+1)).map (fun m =>
+    binom K m * P^m * (20-P)^(K-m) * loss2 K P C m)).sum
+def enumerated (K P C : Nat) : Nat :=
+  ((configs K).map (fun xs =>
+    P^(ones xs) * (20-P)^(K-ones xs) * loss2 K P C (ones xs))).sum
+def grid : List (Nat × Nat × Nat) :=
+  ([1,2,3,4] : List Nat).flatMap (fun K =>
+    (List.range 9).flatMap (fun i =>
+      (List.range 20).map (fun j => (K,11+i,1+j))))
+theorem grid_has_720_cases : grid.length = 720 := by decide
+theorem closed_form_matches_full_configurations :
+    ∀ x ∈ grid, grouped x.1 x.2.1 x.2.2 = enumerated x.1 x.2.1 x.2.2 := by decide
+theorem grid_probability_range :
+    ∀ x ∈ grid, grouped x.1 x.2.1 x.2.2 ≤ 2*20^x.1 := by decide
+-- p=3/4, c=1/2: two distinct K have the same 1/64 floor.
+theorem inverse_alias :
+    grouped 3 15 10 * (2*20^5) = grouped 5 15 10 * (2*20^3) := by decide
+-- For p=3/4,c=9/10 and counts summing to N, compare score with 17*N/36.
+def score (counts : List Nat) (zs : List Bool) : Nat :=
+  ((counts.zip zs).map (fun x => if x.2 then x.1 else 0)).sum
+def floorNumerator (counts : List Nat) : Nat :=
+  ((configs counts.length).map (fun zs =>
+    let lhs := 36 * score counts zs
+    let rhs := 17 * counts.sum
+    let factor := if lhs < rhs then 2 else if lhs == rhs then 1 else 0
+    3^(ones zs) * factor)).sum
+-- Denominator is 2*4^3=128 in each three-lineage case.
+theorem same_effective_participation_different_floor :
+    (1*1+4*4+4*4 : Nat) = 2*2+2*2+5*5 ∧
+    floorNumerator [1,4,4] = 20 ∧ floorNumerator [2,2,5] = 32 := by decide
+-- WF population N=5, initial counts [3,1,1]; all 21 descendant count states.
+def wfNumerator : Nat :=
+  ((List.range 6).map (fun a =>
+    ((List.range (6-a)).map (fun b =>
+      binom 5 a * binom (5-a) b * 3^a *
+        floorNumerator [a,b,5-a-b])).sum)).sum
+theorem wf_transition_normalized :
+    ((List.range 6).map (fun a =>
+      ((List.range (6-a)).map (fun b =>
+        binom 5 a * binom (5-a) b * 3^a)).sum)).sum = 5^5 := by decide
+theorem wf_floor_decreases_in_expectation :
+    floorNumerator [3,1,1] = 32 ∧ wfNumerator = 92440 ∧
+    wfNumerator < floorNumerator [3,1,1] * 5^5 := by decide
+end Obligations045
+#print axioms Obligations045.grid_has_720_cases
+#print axioms Obligations045.closed_form_matches_full_configurations
+#print axioms Obligations045.grid_probability_range
+#print axioms Obligations045.inverse_alias
+
+#print axioms Obligations045.same_effective_participation_different_floor
+#print axioms Obligations045.wf_transition_normalized
+#print axioms Obligations045.wf_floor_decreases_in_expectation

package/proofs/m0-045/Obligations045/M0Coincidence.lean

@@ -0,0 +1,39 @@
+import Mathlib.Data.Real.Basic
+import Mathlib.Tactic.Ring
+namespace Obligations045.M0Coincidence
+/-- Exact expectation over independent Bernoulli(p) latent lineages.
+    The recurrence keeps both branches and their actual probabilities. -/
+def expect (p : ℝ) : List ℝ → (ℝ → ℝ) → ℝ
+  | [], f => f 0
+  | w :: ws, f => (1-p)*expect p ws f + p*expect p ws (fun x => f (w+x))
+def squares (ws : List ℝ) : ℝ := (ws.map (fun w => w^2)).sum
+
+theorem expect_quadratic (p : ℝ) (ws : List ℝ) (a b d : ℝ) :
+    expect p ws (fun x => a*x^2+b*x+d) =
+    a*(p^2*ws.sum^2+p*(1-p)*squares ws)+b*p*ws.sum+d := by
+  induction ws generalizing a b d with
+  | nil => simp [expect, squares]
+  | cons w ws ih =>
+    have hf : (fun x : ℝ => a*(w+x)^2+b*(w+x)+d) =
+        (fun x => a*x^2+(2*a*w+b)*x+(a*w^2+b*w+d)) := by
+      funext x
+      ring
+    simp only [expect, hf]
+    rw [ih, ih]
+    simp only [List.sum_cons, squares, List.map_cons]
+    ring
+
+theorem pair_coincidence (p c : ℝ) (ws : List ℝ) (hw : ws.sum = 1) :
+    expect p ws (fun x => ((1-c)*p+c*x)^2+(1-((1-c)*p+c*x))^2) =
+    p^2+(1-p)^2+2*c^2*p*(1-p)*squares ws := by
+  have hf : (fun x : ℝ => ((1-c)*p+c*x)^2+(1-((1-c)*p+c*x))^2) =
+      (fun x => (2*c^2)*x^2+(2*c*(2*(1-c)*p-1))*x+
+        (((1-c)*p)^2+(1-(1-c)*p)^2)) := by
+    funext x
+    ring
+  rw [hf, expect_quadratic, hw]
+  ring
+
+theorem triple_redundant (q : ℝ) :
+    q^3+(1-q)^3 = (3*(q^2+(1-q)^2)-1)/2 := by ring
+end Obligations045.M0Coincidence

package/proofs/m0-045/Obligations045/M0Diagonal.lean

@@ -0,0 +1,18 @@
+import Obligations045.ConsensusGrid
+set_option maxRecDepth 10000
+set_option maxHeartbeats 8000000
+namespace Obligations045.Diagonal
+/-- Finite diagonal vector only: K=1,p=3/4,c=1/3,w=[1].
+    A=false gives q=1/2, A=true gives q=5/6.
+    No general CLT or diagonal-limit theorem is declared in this file. -/
+def loss2 (b N : Nat) : Nat := if 2*b < N then 2 else if 2*b == N then 1 else 0
+def unbiasedNumerator (N : Nat) : Nat :=
+  ((List.range (N+1)).map (fun b => Obligations045.binom N b * loss2 b N)).sum
+def cases : List Nat := [1,2,3,4,5,6,7,8,9,10,11,12]
+theorem unbiased_diagonal_vector : ∀ N ∈ cases, unbiasedNumerator N = 2^N := by decide
+-- Total error numerator has denominator 8*6^N; the target floor is 1/8.
+def errorNumerator (N : Nat) : Nat :=
+  6^N+3*((List.range (N+1)).map (fun b =>
+    Obligations045.binom N b * 5^b * loss2 b N)).sum
+#eval cases.map (fun N => (N,errorNumerator N,8*6^N))
+end Obligations045.Diagonal

package/proofs/m0-045/Obligations045/M0Limit.lean

@@ -0,0 +1,134 @@
+import Mathlib.Topology.Instances.Real.Lemmas
+import Mathlib.Data.Real.Archimedean
+import Mathlib.Topology.Algebra.Order.Field
+import Mathlib.Algebra.Order.Floor.Ring
+import Mathlib.Tactic.Linarith
+import Mathlib.Tactic.Ring
+import Mathlib.Tactic.NormNum
+import Mathlib.Tactic.Positivity
+
+open scoped BigOperators
+open Filter Topology
+noncomputable section
+open Classical
+namespace Obligations045.M0
+
+/-- Declared binary M0 domain. This structure contains no limiting-probability axiom. -/
+structure Domain where
+  K : ℕ
+  K_pos : 0 < K
+  p : ℝ
+  c : ℝ
+  p_half : (1:ℝ)/2 < p
+  p_lt_one : p < 1
+  c_nonneg : 0 ≤ c
+  c_lt_one : c < 1
+  w : ℕ → ℝ
+  w_nonneg : ∀ i, 0 ≤ w i
+  weights_sum : ∑ i ∈ Finset.range K, w i = 1
+
+def cumulative (w : ℕ → ℝ) (i : ℕ) : ℝ := ∑ j ∈ Finset.range i, w j
+
+def allocation (w : ℕ → ℝ) (N i : ℕ) : ℕ :=
+  ⌊(N:ℝ) * cumulative w (i+1)⌋₊ - ⌊(N:ℝ) * cumulative w i⌋₊
+
+theorem prefix_succ (w : ℕ → ℝ) (i : ℕ) :
+    cumulative w (i+1) = cumulative w i + w i := by simp [cumulative, Finset.sum_range_succ]
+
+theorem prefix_monotone (w : ℕ → ℝ) (hw : ∀ i, 0 ≤ w i) : Monotone (cumulative w) := by
+  apply monotone_nat_of_le_succ
+  intro i
+  rw [prefix_succ]
+  exact le_add_of_nonneg_right (hw i)
+
+theorem allocation_sum (M : Domain) (N : ℕ) :
+    ∑ i ∈ Finset.range M.K, allocation M.w N i = N := by
+  let f : ℕ → ℕ := fun i => ⌊(N:ℝ) * cumulative M.w i⌋₊
+  have hf : Monotone f := fun i j hij =>
+    Nat.floor_mono (mul_le_mul_of_nonneg_left (prefix_monotone M.w M.w_nonneg hij) (by positivity))
+  change ∑ i ∈ Finset.range M.K, (f (i+1) - f i) = N
+  rw [Finset.sum_range_tsub hf]
+  simp [f, cumulative, M.weights_sum]
+
+theorem allocation_discrepancy (M : Domain) (N i : ℕ) :
+    -1 < (allocation M.w N i : ℝ) - (N:ℝ)*M.w i ∧
+    (allocation M.w N i : ℝ) - (N:ℝ)*M.w i < 1 := by
+  have hpre : 0 ≤ cumulative M.w i := Finset.sum_nonneg (fun j _ => M.w_nonneg j)
+  have hnext : 0 ≤ cumulative M.w (i+1) := Finset.sum_nonneg (fun j _ => M.w_nonneg j)
+  have hm : ⌊(N:ℝ)*cumulative M.w i⌋₊ ≤ ⌊(N:ℝ)*cumulative M.w (i+1)⌋₊ :=
+    Nat.floor_mono (mul_le_mul_of_nonneg_left (prefix_monotone M.w M.w_nonneg (Nat.le_succ i)) (by positivity))
+  have a := Nat.floor_le (mul_nonneg (Nat.cast_nonneg N) hpre)
+  have b := Nat.lt_floor_add_one ((N:ℝ)*cumulative M.w i)
+  have c := Nat.floor_le (mul_nonneg (Nat.cast_nonneg N) hnext)
+  have d := Nat.lt_floor_add_one ((N:ℝ)*cumulative M.w (i+1))
+  have hs := prefix_succ M.w i
+  simp only [allocation, Nat.cast_sub hm]
+  constructor <;> nlinarith
+
+def q (M : Domain) (a : Bool) : ℝ := (1-M.c)*M.p + if a then M.c else 0
+
+theorem q_pos (M : Domain) (a : Bool) : 0 < q M a := by
+  have hp : 0 < M.p := by linarith [M.p_half]
+  cases a <;> simp only [q, Bool.false_eq_true, ite_false, add_zero, ite_true] <;>
+    nlinarith [M.c_nonneg, M.c_lt_one]
+
+theorem q_lt_one (M : Domain) (a : Bool) : q M a < 1 := by
+  have hp : 0 < M.p := by linarith [M.p_half]
+  cases a <;> simp only [q, Bool.false_eq_true, ite_false, add_zero, ite_true] <;>
+    nlinarith [M.c_nonneg, M.c_lt_one, M.p_lt_one]
+
+def score (M : Domain) (a : Fin M.K → Bool) : ℝ :=
+  ∑ i : Fin M.K, M.w i * q M (a i)
+
+def latentMass (M : Domain) (a : Fin M.K → Bool) : ℝ :=
+  ∏ i : Fin M.K, if a i then M.p else 1-M.p
+
+def fairLoss (correct total : ℕ) : ℝ :=
+  if 2*correct < total then 1 else if 2*correct = total then 1/2 else 0
+
+/-- The exact finite conditional error, using independent binomial counts in each lineage. -/
+noncomputable def conditionalError (M : Domain) (N : ℕ) (a : Fin M.K → Bool) : ℝ :=
+  ∑ x : (i : Fin M.K) → Fin (allocation M.w N i + 1),
+    (∏ i : Fin M.K,
+      (Nat.choose (allocation M.w N i) (x i) : ℝ) *
+      q M (a i) ^ (x i : ℕ) *
+      (1-q M (a i)) ^ (allocation M.w N i - (x i : ℕ))) *
+    fairLoss (∑ i : Fin M.K, (x i : ℕ)) N
+
+noncomputable def error (M : Domain) (N : ℕ) : ℝ :=
+  ∑ a : Fin M.K → Bool, latentMass M a * conditionalError M N a
+
+noncomputable def limitingLoss (s : ℝ) : ℝ :=
+  if s < 1/2 then 1 else if s = 1/2 then 1/2 else 0
+
+noncomputable def floor (M : Domain) : ℝ :=
+  ∑ a : Fin M.K → Bool, latentMass M a * limitingLoss (score M a)
+
+/-- Explicit proof obligations, NOT assumptions hidden inside the generative model.
+    The strict branches require concentration. The equality branch requires a CLT.
+    This certificate has no constructed instance in this project. -/
+def ConditionalTailLimits (M : Domain) : Prop :=
+  (∀ a, score M a < 1/2 → Tendsto (fun N => conditionalError M N a) atTop (𝓝 1)) ∧
+  (∀ a, 1/2 < score M a → Tendsto (fun N => conditionalError M N a) atTop (𝓝 0)) ∧
+  (∀ a, score M a = 1/2 → Tendsto (fun N => conditionalError M N a) atTop (𝓝 (1/2)))
+
+/-- Kernel checked finite-mixture transfer. This is intentionally conditional;
+    it does not claim that ConditionalTailLimits follows from Domain. -/
+theorem limit_of_conditional_tail_limits (M : Domain) (h : ConditionalTailLimits M) :
+    Tendsto (error M) atTop (𝓝 (floor M)) := by
+  have hcase : ∀ a, Tendsto (fun N => conditionalError M N a) atTop
+      (𝓝 (limitingLoss (score M a))) := by
+    intro a
+    by_cases hl : score M a < 1/2
+    · rw [limitingLoss, if_pos hl]
+      exact h.1 a hl
+    · by_cases he : score M a = 1/2
+      · rw [limitingLoss, if_neg hl, if_pos he]
+        exact h.2.2 a he
+      · have hg : 1/2 < score M a := lt_of_le_of_ne (le_of_not_gt hl) (Ne.symm he)
+        rw [limitingLoss, if_neg hl, if_neg he]
+        exact h.2.1 a hg
+  unfold error floor
+  exact tendsto_finset_sum _ (fun a _ => tendsto_const_nhds.mul (hcase a))
+
+end Obligations045.M0

package/proofs/m0-045/Obligations045/M0Offdiag.lean

@@ -0,0 +1,171 @@
+import Obligations045.M0Limit
+import Mathlib.Probability.StrongLaw
+import Mathlib.MeasureTheory.Integral.DominatedConvergence
+open scoped BigOperators
+open Filter Topology MeasureTheory ProbabilityTheory
+noncomputable section
+namespace Obligations045.M0
+
+theorem floor_quota_bounds (M : Domain) (N i : ℕ) :
+    (∑ j ∈ Finset.range M.K, allocation M.w N j = N) ∧
+    (-1 < (allocation M.w N i : ℝ)-(N:ℝ)*M.w i ∧
+      (allocation M.w N i : ℝ)-(N:ℝ)*M.w i < 1) :=
+  ⟨allocation_sum M N, allocation_discrepancy M N i⟩
+
+theorem allocation_ratio (M : Domain) (i : ℕ) :
+    Tendsto (fun N : ℕ => (allocation M.w N i : ℝ)/(N:ℝ)) atTop (𝓝 (M.w i)) := by
+  have hInv : Tendsto (fun N : ℕ => (1:ℝ)/(N:ℝ)) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop
+  apply tendsto_of_tendsto_of_tendsto_of_le_of_le'
+    (by simpa using tendsto_const_nhds.sub hInv)
+    (by simpa using tendsto_const_nhds.add hInv)
+  · filter_upwards [eventually_ge_atTop 1] with N hN
+    have hp : 0 < (N:ℝ) := by exact_mod_cast (lt_of_lt_of_le Nat.zero_lt_one hN)
+    rw [le_div_iff₀ hp, sub_mul, inv_mul_cancel₀ hp.ne']
+    linarith [(allocation_discrepancy M N i).1]
+  · filter_upwards [eventually_ge_atTop 1] with N hN
+    have hp : 0 < (N:ℝ) := by exact_mod_cast (lt_of_lt_of_le Nat.zero_lt_one hN)
+    rw [div_le_iff₀ hp, add_mul, inv_mul_cancel₀ hp.ne']
+    linarith [(allocation_discrepancy M N i).2]
+
+theorem allocation_zero (M : Domain) (i : ℕ) (hw : M.w i = 0) (N : ℕ) :
+    allocation M.w N i = 0 := by
+  simp [allocation, prefix_succ, hw]
+
+theorem allocation_atTop (M : Domain) (i : ℕ) (hw : 0 < M.w i) :
+    Tendsto (fun N => allocation M.w N i) atTop atTop := by
+  apply (tendsto_natCast_atTop_iff (R := ℝ)).mp
+  apply tendsto_atTop.2
+  intro r
+  have he : ∀ᶠ N : ℕ in atTop, (r+1)/M.w i ≤ (N:ℝ) :=
+    tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop _)
+  filter_upwards [he] with N hN
+  have hmul := (div_le_iff₀ hw).mp hN
+  linarith [(allocation_discrepancy M N i).1]
+
+theorem lineage_quota_limit (M : Domain) (i : ℕ) (z : ℕ → ℝ) (q : ℝ)
+    (hz0 : z 0 = 0)
+    (hz : Tendsto (fun n : ℕ => z n/(n:ℝ)) atTop (𝓝 q)) :
+    Tendsto (fun N : ℕ => z (allocation M.w N i)/(N:ℝ)) atTop (𝓝 (M.w i*q)) := by
+  by_cases hw : M.w i = 0
+  · simp [allocation_zero M i hw, hz0, hw]
+  · have hp : 0 < M.w i := lt_of_le_of_ne (M.w_nonneg i) (Ne.symm hw)
+    have h := (allocation_ratio M i).mul (hz.comp (allocation_atTop M i hp))
+    convert h using 1
+    funext N
+    by_cases hn : allocation M.w N i = 0
+    · simp [hn, hz0]
+    · dsimp
+      rw [div_mul_div_comm, mul_comm (allocation M.w N i : ℝ), mul_div_mul_right _ _ (by exact_mod_cast hn : (allocation M.w N i : ℝ) ≠ 0)]
+
+/-- The imported strong law is applied to actual lineage variables; no convergence certificate. -/
+theorem lineage_lgn {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    (X : ℕ → Ω → ℝ) (q : ℝ)
+    (hint : Integrable (X 0) μ)
+    (hindep : Pairwise (fun i j : ℕ => IndepFun (X i) (X j) μ))
+    (hident : ∀ i, IdentDistrib (X i) (X 0) μ μ)
+    (hmean : ∫ ω, X 0 ω ∂μ = q) :
+    ∀ᵐ ω ∂μ, Tendsto (fun n : ℕ => (∑ j ∈ Finset.range n, X j ω)/(n:ℝ))
+      atTop (𝓝 q) := by
+  simpa only [hmean] using strong_law_ae_real X hint hindep hident
+
+def memberAverage {Ω : Type*} (M : Domain) (X : Fin M.K → ℕ → Ω → ℝ)
+    (N : ℕ) (ω : Ω) : ℝ :=
+  ∑ i : Fin M.K, (∑ j ∈ Finset.range (allocation M.w N i), X i j ω)/(N:ℝ)
+
+theorem member_average_lgn {Ω : Type*} [MeasurableSpace Ω]
+    (M : Domain) (a : Fin M.K → Bool) (μ : Measure Ω)
+    (X : Fin M.K → ℕ → Ω → ℝ)
+    (hint : ∀ i, Integrable (X i 0) μ)
+    (hindep : ∀ i, Pairwise (fun j k : ℕ => IndepFun (X i j) (X i k) μ))
+    (hident : ∀ i j, IdentDistrib (X i j) (X i 0) μ μ)
+    (hmean : ∀ i, ∫ ω, X i 0 ω ∂μ = q M (a i)) :
+    ∀ᵐ ω ∂μ, Tendsto (fun N => memberAverage M X N ω) atTop (𝓝 (score M a)) := by
+  have hall : ∀ᵐ ω ∂μ, ∀ i : Fin M.K,
+      Tendsto (fun n : ℕ => (∑ j ∈ Finset.range n, X i j ω)/(n:ℝ))
+        atTop (𝓝 (q M (a i))) := by
+    rw [ae_all_iff]
+    intro i
+    exact lineage_lgn μ (X i) (q M (a i)) (hint i) (hindep i) (hident i) (hmean i)
+  filter_upwards [hall] with ω hω
+  unfold memberAverage score
+  apply tendsto_finset_sum
+  intro i _
+  exact lineage_quota_limit M i (fun n => ∑ j ∈ Finset.range n, X i j ω)
+    (q M (a i)) (by simp) (hω i)
+
+theorem floor_limit_offdiag_scalar {f : ℕ → ℝ} {s : ℝ}
+    (hf : Tendsto f atTop (𝓝 s)) (hne : s ≠ (1:ℝ)/2) :
+    Tendsto (fun N => limitingLoss (f N)) atTop (𝓝 (limitingLoss s)) := by
+  by_cases hs : s < (1:ℝ)/2
+  · have he : ∀ᶠ N in atTop, f N < (1:ℝ)/2 := hf.eventually (Iio_mem_nhds hs)
+    have hEq : (fun N => limitingLoss (f N)) =ᶠ[atTop] (fun _ => (1:ℝ)) :=
+      he.mono (fun N hN => by change limitingLoss (f N) = 1; rw [limitingLoss, if_pos hN])
+    rw [limitingLoss, if_pos hs]
+    exact tendsto_const_nhds.congr' hEq.symm
+  · have hg : (1:ℝ)/2 < s := lt_of_le_of_ne (le_of_not_gt hs) (Ne.symm hne)
+    have he : ∀ᶠ N in atTop, (1:ℝ)/2 < f N := hf.eventually (Ioi_mem_nhds hg)
+    have hEq : (fun N => limitingLoss (f N)) =ᶠ[atTop] (fun _ => (0:ℝ)) :=
+      he.mono (fun N hN => by
+        change limitingLoss (f N) = 0
+        rw [limitingLoss, if_neg (not_lt.mpr hN.le), if_neg (Ne.symm hN.ne)])
+    rw [limitingLoss, if_neg hs, if_neg hne]
+    exact tendsto_const_nhds.congr' hEq.symm
+
+/-- Off-diagonal passage from actual sample averages to error probabilities.
+    Unlike the diagonal, no CLT is needed. The lineage strong laws and quota
+    composition must supply haverage for the chosen M0 array. -/
+theorem floor_limit_offdiag {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (average : ℕ → Ω → ℝ) (s : ℝ)
+    (hmeas : ∀ N, AEStronglyMeasurable (fun ω => limitingLoss (average N ω)) μ)
+    (haverage : ∀ᵐ ω ∂μ, Tendsto (fun N => average N ω) atTop (𝓝 s))
+    (hne : s ≠ (1:ℝ)/2) :
+    Tendsto (fun N => ∫ ω, limitingLoss (average N ω) ∂μ)
+      atTop (𝓝 (limitingLoss s)) := by
+  have hbound : ∀ N, ∀ᵐ ω ∂μ, ‖limitingLoss (average N ω)‖ ≤ (1:ℝ) := by
+    intro N
+    filter_upwards [] with ω
+    unfold limitingLoss
+    split_ifs <;> norm_num
+  have hlim : ∀ᵐ ω ∂μ, Tendsto (fun N => limitingLoss (average N ω))
+      atTop (𝓝 (limitingLoss s)) := haverage.mono (fun ω hω => floor_limit_offdiag_scalar hω hne)
+  simpa using tendsto_integral_of_dominated_convergence (fun _ => (1:ℝ)) hmeas
+    (integrable_const (1:ℝ)) hbound hlim
+
+/-- M0 off-diagonal probability limit from declared lineage laws and the proved quotas.
+    The only extra technical input is measurability of the loss; no asymptotic
+    convergence hypothesis and no CLT certificate is assumed. -/
+theorem floor_limit_offdiag_M0 {Ω : Type*} [MeasurableSpace Ω]
+    (M : Domain) (a : Fin M.K → Bool) (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (X : Fin M.K → ℕ → Ω → ℝ)
+    (hint : ∀ i, Integrable (X i 0) μ)
+    (hindep : ∀ i, Pairwise (fun j k : ℕ => IndepFun (X i j) (X i k) μ))
+    (hident : ∀ i j, IdentDistrib (X i j) (X i 0) μ μ)
+    (hmean : ∀ i, ∫ ω, X i 0 ω ∂μ = q M (a i))
+    (hmeas : ∀ N, AEStronglyMeasurable (fun ω => limitingLoss (memberAverage M X N ω)) μ)
+    (hoff : score M a ≠ (1:ℝ)/2) :
+    Tendsto (fun N => ∫ ω, limitingLoss (memberAverage M X N ω) ∂μ)
+      atTop (𝓝 (limitingLoss (score M a))) := by
+  exact floor_limit_offdiag μ (memberAverage M X) (score M a) hmeas
+    (member_average_lgn M a μ X hint hindep hident hmean) hoff
+
+theorem floor_limit_offdiag_mixture {Ω : Type*} [MeasurableSpace Ω]
+    (M : Domain) (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (X : (Fin M.K → Bool) → Fin M.K → ℕ → Ω → ℝ)
+    (hint : ∀ a i, Integrable (X a i 0) μ)
+    (hindep : ∀ a i, Pairwise (fun j k : ℕ => IndepFun (X a i j) (X a i k) μ))
+    (hident : ∀ a i j, IdentDistrib (X a i j) (X a i 0) μ μ)
+    (hmean : ∀ a i, ∫ ω, X a i 0 ω ∂μ = q M (a i))
+    (hmeas : ∀ a N, AEStronglyMeasurable (fun ω => limitingLoss (memberAverage M (X a) N ω)) μ)
+    (hoff : ∀ a, score M a ≠ (1:ℝ)/2) :
+    Tendsto (fun N => ∑ a : Fin M.K → Bool, latentMass M a *
+      ∫ ω, limitingLoss (memberAverage M (X a) N ω) ∂μ)
+      atTop (𝓝 (floor M)) := by
+  unfold floor
+  apply tendsto_finset_sum
+  intro a _
+  exact tendsto_const_nhds.mul (floor_limit_offdiag_M0 M a μ (X a)
+    (hint a) (hindep a) (hident a) (hmean a) (hmeas a) (hoff a))
+
+end Obligations045.M0

package/proofs/m0-045/Obligations045.lean

@@ -0,0 +1,5 @@
+import Obligations045.M0Limit
+import Obligations045.M0Coincidence
+import Obligations045.ConsensusGrid
+import Obligations045.M0Offdiag
+import Obligations045.M0Diagonal

package/proofs/m0-045/lake-manifest.json

@@ -0,0 +1,116 @@
+{
+  "version": "1.1.0",
+  "packagesDir": ".lake/packages",
+  "packages": [
+    {
+      "url": "https://github.com/leanprover-community/plausible",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "77e08eddc486491d7b9e470926b3dbe50319451a",
+      "name": "plausible",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "main",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/LeanSearchClient",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "25078369972d295301f5a1e53c3e5850cf6d9d4c",
+      "name": "LeanSearchClient",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "main",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/import-graph",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "e6a9f0f5ee3ccf7443a0070f92b62f8db12ae82b",
+      "name": "importGraph",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "main",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/ProofWidgets4",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "c4919189477c3221e6a204008998b0d724f49904",
+      "name": "proofwidgets",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "v0.0.57",
+      "inherited": true,
+      "configFile": "lakefile.lean"
+    },
+    {
+      "url": "https://github.com/leanprover-community/aesop",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "5d50b08dedd7d69b3d9b3176e0d58a23af228884",
+      "name": "aesop",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "master",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/quote4",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "fa4f7f15d97591a9cf3aa7724ba371c7fc6dda02",
+      "name": "Qq",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "master",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/batteries",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover-community",
+      "rev": "f5d04a9c4973d401c8c92500711518f7c656f034",
+      "name": "batteries",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "main",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover/lean4-cli",
+      "type": "git",
+      "subDir": null,
+      "scope": "leanprover",
+      "rev": "02dbd02bc00ec4916e99b04b2245b30200e200d0",
+      "name": "Cli",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "main",
+      "inherited": true,
+      "configFile": "lakefile.toml"
+    },
+    {
+      "url": "https://github.com/leanprover-community/mathlib4.git",
+      "type": "git",
+      "subDir": null,
+      "scope": "",
+      "rev": "c44e0c8ee63ca166450922a373c7409c5d26b00b",
+      "name": "mathlib",
+      "manifestFile": "lake-manifest.json",
+      "inputRev": "c44e0c8ee63ca166450922a373c7409c5d26b00b",
+      "inherited": false,
+      "configFile": "lakefile.lean"
+    }
+  ],
+  "name": "obligations_lineage",
+  "lakeDir": ".lake"
+}