@lapxo/obligations 0.4.5 → 0.4.6

package/proofs/m0-046/BridgeNegatives.lean

@@ -0,0 +1,23 @@
+import M0Bridge
+namespace Obligations046.BridgeTests
+
+def atoms : List (ℚ × ℚ × ℚ × ℚ) :=
+  [(0,0,0,1/16),(0,1,1,3/16),(1,0,1,3/16),(1,1,0,3/16),(1,1,1,6/16)]
+def expect (f : ℚ → ℚ → ℚ → ℚ) : ℚ :=
+  (atoms.map (fun (a,b,c,w) => w*f a b c)).sum
+
+/-- A normalized binary distribution with Bernoulli(3/4) pairwise marginals,
+    but not the jointly independent word law. Exact arithmetic, not simulation. -/
+theorem pairwise_not_joint :
+    expect (fun _ _ _ => 1) = 1 ∧
+    expect (fun a _ _ => a) = 3/4 ∧
+    expect (fun _ b _ => b) = 3/4 ∧
+    expect (fun _ _ c => c) = 3/4 ∧
+    expect (fun a b _ => a*b) = 9/16 ∧
+    expect (fun a _ c => a*c) = 9/16 ∧
+    expect (fun _ b c => b*c) = 9/16 ∧
+    expect (fun a b c => (1-a)*(1-b)*(1-c)) = 1/16 ∧
+    expect (fun a b c => (1-a)*(1-b)*(1-c)) ≠ (1/4:ℚ)^3 := by
+  norm_num [expect, atoms]
+
+end Obligations046.BridgeTests

package/proofs/m0-046/M0Bridge.lean

@@ -0,0 +1,300 @@
+import Obligations045.M0Offdiag
+import Mathlib.Data.Nat.Choose.Sum
+import Mathlib.Probability.ProbabilityMassFunction.Integrals
+import Mathlib.Algebra.BigOperators.Group.Finset.Pi
+
+open scoped BigOperators
+open MeasureTheory ProbabilityTheory Filter Topology
+noncomputable section
+open Classical
+namespace Obligations046.Bridge
+
+def count {n : ℕ} (s : Finset (Fin n)) : Fin (n+1) :=
+  ⟨s.card, Nat.lt_succ_of_le (by simpa using s.card_le_univ)⟩
+def mass (p : ℝ) {n : ℕ} (s : Finset (Fin n)) : ℝ :=
+  p^s.card*(1-p)^(n-s.card)
+def binMass (p : ℝ) (n : ℕ) (k : Fin (n+1)) : ℝ :=
+  (n.choose k : ℝ)*p^(k:ℕ)*(1-p)^(n-(k:ℕ))
+
+theorem count_fiber_mass (p : ℝ) (n : ℕ) (k : Fin (n+1)) :
+    (∑ s : Finset (Fin n), if count s = k then mass p s else 0) = binMass p n k := by
+  have hfilter : Finset.univ.filter (fun s : Finset (Fin n) => count s = k) =
+      Finset.powersetCard (k:ℕ) (Finset.univ : Finset (Fin n)) := by
+    ext s
+    simp [count, Fin.ext_iff, Finset.mem_powersetCard]
+  rw [← Finset.sum_filter, hfilter]
+  calc
+    _ = ∑ _s ∈ Finset.powersetCard (k:ℕ) (Finset.univ : Finset (Fin n)),
+        p^(k:ℕ)*(1-p)^(n-(k:ℕ)) := by
+      apply Finset.sum_congr rfl
+      intro s hs
+      simp only [Finset.mem_powersetCard] at hs
+      simp [mass, hs.2]
+    _ = binMass p n k := by
+      simp [binMass, Finset.card_powersetCard, nsmul_eq_mul, mul_assoc]
+
+/-- Finite product-law pushforward, before any choice of Bernoulli parameters. -/
+theorem product_pushforward {ι : Type*} [Fintype ι] [DecidableEq ι]
+    {S T : ι → Type*} [∀ i, Fintype (S i)] [∀ i, Fintype (T i)]
+    [∀ i, DecidableEq (T i)] (m : ∀ i, S i → ℝ) (c : ∀ i, S i → T i)
+    (f : (∀ i, T i) → ℝ) :
+    (∑ x : ∀ i, S i, (∏ i, m i (x i))*f (fun i => c i (x i))) =
+      ∑ k : ∀ i, T i, (∏ i, ∑ s : S i, if c i s = k i then m i s else 0)*f k := by
+  have gate (x : ∀ i, S i) (k : ∀ i, T i) :
+      (∏ i, if c i (x i) = k i then m i (x i) else 0) =
+        if (fun i => c i (x i)) = k then ∏ i, m i (x i) else 0 := by
+    by_cases h : (fun i => c i (x i)) = k
+    · subst k
+      simp
+    · rw [if_neg h]
+      have h' : ∃ i, c i (x i) ≠ k i := by
+        by_contra hn
+        push_neg at hn
+        exact h (funext hn)
+      obtain ⟨i, hi⟩ := h'
+      exact Finset.prod_eq_zero (Finset.mem_univ i) (by simp [hi])
+  symm
+  simp_rw [Fintype.prod_sum, Finset.sum_mul]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro x _
+  simp_rw [gate, ite_mul, zero_mul]
+  simp
+
+/-- Raw individual Bernoulli outcomes are subsets of named member indices. -/
+abbrev World {ι : Type*} (n : ι → ℕ) := ∀ i, Finset (Fin (n i))
+instance worldMeasurableSpace {ι : Type*} (n : ι → ℕ) : MeasurableSpace (World n) := ⊤
+instance worldDiscreteMeasurable {ι : Type*} (n : ι → ℕ) : DiscreteMeasurableSpace (World n) := ⟨fun _ => trivial⟩
+
+def jointMass {ι : Type*} [Fintype ι] (n : ι → ℕ) (p : ι → ℝ)
+    (x : World n) : ℝ := ∏ i, mass (p i) (x i)
+
+theorem joint_count_pushforward {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (n : ι → ℕ) (p : ι → ℝ) (f : (∀ i, Fin (n i+1)) → ℝ) :
+    (∑ x : World n, jointMass n p x*f (fun i => count (x i))) =
+      ∑ k : ∀ i, Fin (n i+1), (∏ i, binMass (p i) (n i) (k i))*f k := by
+  simpa [jointMass, count_fiber_mass] using
+    product_pushforward (fun i => mass (p i)) (fun _ => count) f
+
+theorem mass_sum (p : ℝ) (n : ℕ) :
+    ∑ s : Finset (Fin n), mass p s = 1 := by
+  have h := Finset.sum_powerset_apply_card (fun k => p^k*(1-p)^(n-k))
+    (x := (Finset.univ : Finset (Fin n)))
+  simp only [Finset.powerset_univ, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] at h
+  change (∑ s : Finset (Fin n), p^s.card*(1-p)^(n-s.card)) = 1
+  rw [h]
+  calc
+    _ = (p+(1-p))^n := by
+      rw [add_pow]
+      apply Finset.sum_congr rfl
+      intro k _
+      ring
+    _ = 1 := by simp
+
+theorem mass_nonneg (p : ℝ) (hp : 0 ≤ p) (hp1 : p ≤ 1)
+    {n : ℕ} (s : Finset (Fin n)) : 0 ≤ mass p s :=
+  mul_nonneg (pow_nonneg hp _) (pow_nonneg (sub_nonneg.mpr hp1) _)
+
+theorem jointMass_sum {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (n : ι → ℕ) (p : ι → ℝ) : ∑ x : World n, jointMass n p x = 1 := by
+  simp only [jointMass, ← Fintype.prod_sum, mass_sum, Finset.prod_const_one]
+
+def memberLaw {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (n : ι → ℕ) (p : ι → ℝ) (hp : ∀ i, 0 ≤ p i) (hp1 : ∀ i, p i ≤ 1) :
+    PMF (World n) :=
+  PMF.ofFintype (fun x => ENNReal.ofReal (jointMass n p x)) (by
+    rw [← ENNReal.ofReal_sum_of_nonneg]
+    · simp [jointMass_sum]
+    · intro x _
+      exact Finset.prod_nonneg (fun i _ => mass_nonneg (p i) (hp i) (hp1 i) (x i)))
+
+theorem memberLaw_expectation {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (n : ι → ℕ) (p : ι → ℝ) (hp : ∀ i, 0 ≤ p i) (hp1 : ∀ i, p i ≤ 1)
+    (f : World n → ℝ) :
+    (∫ x, f x ∂(memberLaw n p hp hp1).toMeasure) =
+      ∑ x : World n, jointMass n p x*f x := by
+  rw [PMF.integral_eq_sum]
+  apply Finset.sum_congr rfl
+  intro x _
+  simp only [memberLaw, PMF.ofFintype_apply, smul_eq_mul]
+  have hm : 0 ≤ jointMass n p x := Finset.prod_nonneg
+    (fun i _ => mass_nonneg (p i) (hp i) (hp1 i) (x i))
+  rw [ENNReal.toReal_ofReal hm]
+
+open Obligations045.M0
+abbrev sizes (M : Domain) (N : ℕ) (i : Fin M.K) := allocation M.w N i
+def modelLaw (M : Domain) (N : ℕ) (a : Fin M.K → Bool) : PMF (World (sizes M N)) :=
+  memberLaw (sizes M N) (fun i => q M (a i))
+    (fun i => (q_pos M (a i)).le) (fun i => (q_lt_one M (a i)).le)
+def correctCount {ι : Type*} [Fintype ι] {n : ι → ℕ} (x : World n) : ℕ :=
+  ∑ i, (x i).card
+
+/-- Exact finite expectation of individual Bernoulli member outcomes, not an assumed count law. -/
+theorem conditional_error_representation (M : Domain) (N : ℕ) (a : Fin M.K → Bool) :
+    (∫ x, fairLoss (correctCount x) N ∂(modelLaw M N a).toMeasure) =
+      conditionalError M N a := by
+  rw [modelLaw, memberLaw_expectation]
+  have h := joint_count_pushforward (sizes M N) (fun i => q M (a i))
+    (fun k => fairLoss (∑ i, (k i : ℕ)) N)
+  simpa [conditionalError, binMass, count, correctCount, sizes] using h
+
+/-- N=0 has fairLoss=1/2; it is not the average bridge. -/
+theorem conditional_error_zero (M : Domain) (a : Fin M.K → Bool) :
+    conditionalError M 0 a = 1/2 := by
+  rw [← conditional_error_representation]
+  have hz : ∀ x : World (sizes M 0), correctCount x = 0 := by
+    intro x
+    have h : ∀ i, x i = ∅ := by
+      intro i
+      apply Finset.eq_empty_iff_forall_not_mem.mpr
+      intro j _
+      have hj := j.isLt
+      simp [sizes, allocation] at hj
+    simp [correctCount, h]
+  simp [hz, fairLoss]
+
+theorem fair_loss_average_bridge (total N : ℕ) (hN : 0 < N) :
+    fairLoss total N = limitingLoss ((total:ℝ)/(N:ℝ)) := by
+  have hn : (0:ℝ) < N := by exact_mod_cast hN
+  have hlt : (total:ℝ)/(N:ℝ) < (1:ℝ)/2 ↔ 2*total < N := by
+    rw [div_lt_iff₀ hn]
+    constructor
+    · intro h
+      exact_mod_cast (show (2:ℝ)*total < N by linarith)
+    · intro h
+      have h' : (2:ℝ)*total < N := by exact_mod_cast h
+      linarith
+  have heq : (total:ℝ)/(N:ℝ) = (1:ℝ)/2 ↔ 2*total = N := by
+    rw [div_eq_iff hn.ne']
+    constructor
+    · intro h
+      exact_mod_cast (show (2:ℝ)*total = N by linarith)
+    · intro h
+      have h' : (2:ℝ)*total = N := by exact_mod_cast h
+      linarith
+  unfold fairLoss limitingLoss
+  simp only [hlt, heq]
+
+/-- Probability of every joint count event, derived from raw member product probabilities. -/
+theorem lineage_count_binomial_law {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (n : ι → ℕ) (p : ι → ℝ) (hp : ∀ i, 0 ≤ p i) (hp1 : ∀ i, p i ≤ 1)
+    (k : ∀ i, Fin (n i+1)) :
+    (∫ x, if (fun i => count (x i)) = k then (1:ℝ) else 0
+      ∂(memberLaw n p hp hp1).toMeasure) = ∏ i, binMass (p i) (n i) (k i) := by
+  rw [memberLaw_expectation]
+  simpa using joint_count_pushforward n p (fun z => if z = k then (1:ℝ) else 0)
+
+/-- The snapshot retains individual named Bernoulli outcomes; it is not a count-law certificate. -/
+def snapshot {Ω : Type*} (M : Domain) (N : ℕ)
+    (X : Fin M.K → ℕ → Ω → Bool) (ω : Ω) : World (sizes M N) :=
+  fun i => Finset.univ.filter (fun j : Fin (sizes M N i) => X i j ω)
+def indicator {Ω : Type*} {K : ℕ} (X : Fin K → ℕ → Ω → Bool) : Fin K → ℕ → Ω → ℝ :=
+  fun i j ω => if X i j ω then 1 else 0
+
+theorem snapshot_card {Ω : Type*} (M : Domain) (N : ℕ)
+    (X : Fin M.K → ℕ → Ω → Bool) (ω : Ω) (i : Fin M.K) :
+    (((snapshot M N X ω) i).card : ℝ) =
+      ∑ j ∈ Finset.range (allocation M.w N i), indicator X i j ω := by
+  simp only [snapshot, Finset.card_filter, Nat.cast_sum, Nat.cast_ite,
+    Nat.cast_one, Nat.cast_zero, indicator]
+  exact Fin.sum_univ_eq_sum_range (fun j => if X i j ω then (1:ℝ) else 0) _
+
+theorem snapshot_average {Ω : Type*} (M : Domain) (N : ℕ)
+    (X : Fin M.K → ℕ → Ω → Bool) (ω : Ω) :
+    memberAverage M (indicator X) N ω = (correctCount (snapshot M N X ω):ℝ)/(N:ℝ) := by
+  simp only [memberAverage, correctCount, Nat.cast_sum, snapshot_card, Finset.sum_div]
+
+/-- Transfer from a declared joint Bernoulli MEMBER law on an ambient probability space.
+    hproduct names all raw bits, not counts, their expectation, or a tail/convergence law. -/
+theorem ambient_conditional_error_representation {Ω : Type*} [MeasurableSpace Ω]
+    (M : Domain) (N : ℕ) (a : Fin M.K → Bool) (μ : Measure Ω)
+    (X : Fin M.K → ℕ → Ω → Bool) (hN : 0 < N)
+    (hmeas : AEMeasurable (snapshot M N X) μ)
+    (hproduct : Measure.map (snapshot M N X) μ = (modelLaw M N a).toMeasure) :
+    (∫ ω, limitingLoss (memberAverage M (indicator X) N ω) ∂μ) =
+      conditionalError M N a := by
+  have hpoint : (fun ω => limitingLoss (memberAverage M (indicator X) N ω)) =
+      (fun ω => fairLoss (correctCount (snapshot M N X ω)) N) := by
+    funext ω
+    rw [snapshot_average, fair_loss_average_bridge _ _ hN]
+  rw [hpoint]
+  have hf : AEStronglyMeasurable (fun x : World (sizes M N) => fairLoss (correctCount x) N)
+      (Measure.map (snapshot M N X) μ) := Measurable.of_discrete.stronglyMeasurable.aestronglyMeasurable
+  rw [← integral_map hmeas hf, hproduct, conditional_error_representation]
+
+theorem mixture_error_representation {Ω : Type*} [MeasurableSpace Ω]
+    (M : Domain) (N : ℕ) (μ : Measure Ω)
+    (X : (Fin M.K → Bool) → Fin M.K → ℕ → Ω → Bool) (hN : 0 < N)
+    (hmeas : ∀ a, AEMeasurable (snapshot M N (X a)) μ)
+    (hproduct : ∀ a, Measure.map (snapshot M N (X a)) μ = (modelLaw M N a).toMeasure) :
+    error M N = ∑ a : Fin M.K → Bool, latentMass M a *
+      ∫ ω, limitingLoss (memberAverage M (indicator (X a)) N ω) ∂μ := by
+  unfold error
+  apply Finset.sum_congr rfl
+  intro a _
+  rw [ambient_conditional_error_representation M N a μ (X a) hN (hmeas a) (hproduct a)]
+
+/-- The implementation limit follows from the old model theorem and the new representation bridge.
+    No CLT, diagonal theorem, count-law certificate, or convergence premise is assumed. -/
+theorem computational_offdiag_limit {Ω : Type*} [MeasurableSpace Ω]
+    (M : Domain) (μ : Measure Ω) [IsProbabilityMeasure μ]
+    (X : (Fin M.K → Bool) → Fin M.K → ℕ → Ω → Bool)
+    (hsnapshot : ∀ a N, AEMeasurable (snapshot M N (X a)) μ)
+    (hproduct : ∀ a N, Measure.map (snapshot M N (X a)) μ = (modelLaw M N a).toMeasure)
+    (hint : ∀ a i, Integrable (indicator (X a) i 0) μ)
+    (hindep : ∀ a i, Pairwise (fun j k : ℕ => IndepFun (indicator (X a) i j) (indicator (X a) i k) μ))
+    (hident : ∀ a i j, IdentDistrib (indicator (X a) i j) (indicator (X a) i 0) μ μ)
+    (hmean : ∀ a i, ∫ ω, indicator (X a) i 0 ω ∂μ = q M (a i))
+    (hmeas : ∀ a N, AEStronglyMeasurable
+      (fun ω => limitingLoss (memberAverage M (indicator (X a)) N ω)) μ)
+    (hoff : ∀ a, score M a ≠ (1:ℝ)/2) :
+    Tendsto (error M) atTop (𝓝 (floor M)) := by
+  have h := floor_limit_offdiag_mixture M μ (fun a => indicator (X a))
+    hint hindep hident hmean hmeas hoff
+  have heq : (fun N => error M N) =ᶠ[atTop]
+      (fun N => ∑ a : Fin M.K → Bool, latentMass M a *
+        ∫ ω, limitingLoss (memberAverage M (indicator (X a)) N ω) ∂μ) := by
+    filter_upwards [eventually_ge_atTop 1] with N hN
+    exact mixture_error_representation M N μ X (lt_of_lt_of_le Nat.zero_lt_one hN)
+      (fun a => hsnapshot a N) (fun a => hproduct a N)
+  exact h.congr' heq.symm
+
+/-- The starting probability is the product over NAMED INDIVIDUAL bits, with no binomial factor. -/
+theorem mass_eq_individual_product (p : ℝ) {n : ℕ} (s : Finset (Fin n)) :
+    mass p s = ∏ j : Fin n, if j ∈ s then p else 1-p := by
+  have hc : (Finset.univ.filter (fun j : Fin n => j ∉ s)) = sᶜ := by
+    ext j
+    simp
+  rw [Finset.prod_ite]
+  simp [mass, Finset.filter_mem_eq_inter, hc, Finset.card_compl]
+
+theorem memberLaw_individual_probability {ι : Type*} [Fintype ι] [DecidableEq ι]
+    (n : ι → ℕ) (p : ι → ℝ) (hp : ∀ i, 0 ≤ p i) (hp1 : ∀ i, p i ≤ 1)
+    (x : World n) :
+    ((memberLaw n p hp hp1) x).toReal =
+      ∏ i, ∏ j : Fin (n i), if j ∈ x i then p i else 1-p i := by
+  simp only [memberLaw, PMF.ofFintype_apply]
+  have hm : 0 ≤ jointMass n p x := Finset.prod_nonneg
+    (fun i _ => mass_nonneg (p i) (hp i) (hp1 i) (x i))
+  rw [ENNReal.toReal_ofReal hm]
+  simp only [jointMass, mass_eq_individual_product]
+
+theorem zero_average_counterexample : fairLoss 0 0 ≠ limitingLoss ((0:ℝ)/0) := by
+  norm_num [fairLoss, limitingLoss]
+
+theorem latentMass_sum (M : Domain) : ∑ a : Fin M.K → Bool, latentMass M a = 1 := by
+  have h := (Fintype.prod_sum (fun (_i : Fin M.K) (b : Bool) =>
+    if b then M.p else 1-M.p)).symm
+  simpa [latentMass] using h
+
+/-- The finite mixture itself equals the existing implementation for EVERY N,
+    including zero. Its product-Bernoulli latent weights sum to one. -/
+theorem model_mixture_error_representation (M : Domain) (N : ℕ) :
+    (∑ a : Fin M.K → Bool, latentMass M a *
+      ∫ x, fairLoss (correctCount x) N ∂(modelLaw M N a).toMeasure) = error M N := by
+  unfold error
+  apply Finset.sum_congr rfl
+  intro a _
+  rw [conditional_error_representation]
+
+end Obligations046.Bridge

package/proofs/m0-046/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-046/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-046/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-046/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