@lapxo/obligations 0.4.3 → 0.4.5

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"
+}

package/proofs/m0-045/lakefile.toml

@@ -0,0 +1,9 @@
+name = "obligations_lineage"
+version = "0.0.0"
+defaultTargets = ["Obligations045"]
+[[require]]
+name = "mathlib"
+git = "https://github.com/leanprover-community/mathlib4.git"
+rev = "c44e0c8ee63ca166450922a373c7409c5d26b00b"
+[[lean_lib]]
+name = "Obligations045"

package/proofs/m0-045/lean-toolchain

@@ -0,0 +1 @@
+leanprover/lean4:v4.19.0

package/proofs/marginal-information.json

@@ -0,0 +1,30 @@
+{
+  "id":"marginal-information/one-joint-two-orders",
+  "classification":"measure with an explicit finite joint prior; standard chain-rule and conditional-DPI consequences with distinguishing vectors, not a new universal lineage law",
+  "quantity":"Delta(Y|S)=I(T;Y|S)=H(T|S)-H(T|S,Y). Both orders use the identical full joint law, truth variable, prior, source identities and domain. The selected observation is the full tuple, not an aggregated majority value.",
+  "scope":"Finite named alphabets and rational joint probabilities normalized exactly to one; bits use the existing binary64-log2 approximation. These are model quantities, not certified empirical mutual-information estimates.",
+  "knownIdentities":[
+    {"statement":"Delta>=0; Delta=0 iff T and Y are conditionally independent given S, under the declared joint law.","classification":"standard Shannon identity and nonnegativity; finite vectors here, no new Lean formalization"},
+    {"statement":"For any complete addition order, the sum of marginals is I(T;all sources). The sum is invariant, while individual attribution may depend on order.","classification":"chain rule; no permutation of attributed acts or history is performed"},
+    {"statement":"An exact copy determined by S has zero marginal information. Another source has strictly greater gain only when its conditional information is positive.","classification":"conditional consequence, not a rule inferred from lineage labels"}
+  ],
+  "comparison":{
+    "sufficientHypothesis":"For the same prior and previous tuple S, require T -> (S,Y_other) -> Y_same, equivalently I(T;Y_same|S,Y_other)=0. This is a conditional garbling/order assumption; distinct lineage or equal prediction accuracy does not establish it.",
+    "conclusion":"I(T;Y_same|S)<=I(T;Y_other|S). Strictness additionally requires a positive information difference; it is not automatic.",
+    "argument":"Expand I(T;Y_same,Y_other|S) in both orders. Under the stated conditional independence the expansion beginning with Y_other ends at I(T;Y_other|S). The other expansion adds a nonnegative term to I(T;Y_same|S).",
+    "vectorCheck":"The candidate reader verifies the conditional-independence hypothesis by exact rational factorization of the handed finite table; it does not infer causal lineages."
+  },
+  "existingImplementation":"Reuse published mixProjectionLoss on configurations (truth, selected tuple), with zero weight on truth and unit weight on tuple. Its conditional configuration loss is exactly H(truth|tuple). No entropy engine, causal generator or algebra is replaced.",
+  "counterexamples":[
+    {"id":"equal-quality-reverses-lineage-ranking","result":"All three sources have accuracy 1/2 and individual information 1 bit. After the first source, the same-lineage complementary projection adds 1 bit while the other-lineage redundant projection adds 0. A comparable marginal quality is insufficient; the missing condition concerns joint conditional information."},
+    {"id":"saturated-truth","result":"After a perfect report, a noiseless report from a distinct declared lineage adds zero, so no universal strict ranking holds."},
+    {"id":"xor-synergy","result":"Each masked view alone has zero truth information; after one view the other adds a bit. Mutual-information gains need not have diminishing returns without additional hypotheses."},
+    {"id":"majority-is-not-the-joint-observation","result":"The full tuple preserves the perfect first report. The existing weighted mix becomes constant after two constant-zero reports and loses a bit. That loss is not negative conditional mutual information."}
+  ],
+  "validation":"Missing joint/prior is unmeasured; nonnormalized priors, invalid domains and orders that are not permutations refuse by name. Every prefix is projected from the same complete joint table; no defaults, resampling, inferred independence or truth-free estimation is supplied.",
+  "cache":"Only scalar subset readings are cached by an explicitly named set-of-coordinates key. This sorts neither the handed addition orders nor their attributed history; probabilities and atom IDs remain intact.",
+  "numeric":"Exact rational masses; approximate bits, default vector tolerance 1e-12. Raw floating-point residuals are retained, never clamped to zero to claim a law.",
+  "literature":{"title":"Lecture Notes on Statistics and Information Theory","author":"John Duchi","url":"https://web.stanford.edu/class/stats311/lecture-notes.pdf","references":["Chapter 2.1, mutual-information chain rule","Proposition 2.1.9, data processing"],"alreadyKnown":"Conditional mutual information, the chain rule and data processing.","addsHere":"One-joint two-order vectors, an exact finite check of the comparison hypothesis, and counterexamples to lineage-only ranking; no new Shannon inequality."},
+  "unchanged":"Bound, wire, M/3-M/4, the algebra and signed public exports remain unchanged. The new measure is a candidate beside the algebra.",
+  "open":["No causal lineage identification or optimal source-selection policy follows.","No sampling uncertainty or truth-free estimation of mutual information is claimed.","General Shannon formalization, reader admission, public delivery and export remain pending."]
+}

package/proofs/resolution-encounters.json

@@ -0,0 +1,23 @@
+{
+  "id": "resolution-encounters@1",
+  "policy": "vectors/laws/policy.json",
+  "classification": "conjecture with falsifiers; H1 remains open",
+  "statement": "No unconditional monotonicity, floor K or ceiling N follows for resolution times encounters from the published H1 statement.",
+  "existing": "Published law/H1-uncertainty is a conjecture, not a law. Its sample has resolutions and fractional origins but no K, N, counting population or sampling model.",
+  "unresolved": [
+    "Meaning of r: chain depth is not number of cells.",
+    "Definition and units of encounters per cell, population, multiplicity and denominator.",
+    "Definitions of K and N, fixed across comparisons.",
+    "Coupling of observations across refinements, coverage preservation and admissible withdrawals.",
+    "An explicit assumption about independent observations, if that word is retained; source names are insufficient."
+  ],
+  "conditionalArithmetic": "If independently specified nonnegative r,e satisfy K<=r*e<=N this checks the inequalities only; it does not derive a counting model or prove H1. A refinement needs r_next*e_next>=r*e for monotonicity; increasing r alone is insufficient.",
+  "falsifierCorrection": "A rising product is compatible with a lower bound. A fixed declared positive floor is refuted by a valid product below that floor; monotonicity by a decrease; an upper bound by an exceedance. A sample minimum selected after seeing the data is not an a priori floor.",
+  "positive": "Replay the published six decimal sample values using exact decimal rationals; its products increase. This is an experiment, not independent empirical origins or a universal law.",
+  "negative": "Resolution [1,2] and encounters [4,1] give [4,2], a decrease. With separately handed K=3, N=5, resolution [1,2,4], encounters [2,2,2] give [2,4,8], violating both bounds. Diagnostic countertables have no claimed physical realization or unstated counting model.",
+  "adds": "Explicit failure modes and a corrected falsifier proposal only. No signed README or declaration edited.",
+  "status": "open: counting/refinement model absent",
+  "signatures": 0,
+  "admission": false,
+  "existingNegative": "samples/no/H1-uncertainty.json checks products [4,2,3,4] against floor 4.8. The numeric failure is valid for that declared floor; the prose reason (a rising product refutes a floor) is incorrect."
+}