@lapxo/obligations 0.4.5 → 0.4.6

package/proofs/m0-046-uncertainty/M0Diagonal046.lean

@@ -0,0 +1,235 @@
+import M0Bridge
+import Lean.Elab.Tactic.Omega
+open scoped BigOperators
+open Filter Topology
+noncomputable section
+open Classical Obligations045.M0
+namespace Obligations046.Diagonal
+
+/-- Deterministic mean and Bernoulli variance of the declared product law.
+The probabilistic CLT is not an assumption of either definition. -/
+def mean (M : Domain) (a : Fin M.K → Bool) (N : ℕ) : ℝ :=
+  ∑ i : Fin M.K, (allocation M.w N i : ℝ) * q M (a i)
+def variance (M : Domain) (a : Fin M.K → Bool) (N : ℕ) : ℝ :=
+  ∑ i : Fin M.K, (allocation M.w N i : ℝ) * (q M (a i) * (1-q M (a i)))
+def varianceRate (M : Domain) (a : Fin M.K → Bool) : ℝ :=
+  ∑ i : Fin M.K, M.w i * (q M (a i) * (1-q M (a i)))
+def varianceLower (M : Domain) : ℝ := (1-M.c)^2 * M.p * (1-M.p)
+
+theorem weights_fin_sum (M : Domain) : ∑ i : Fin M.K, M.w i = 1 := by
+  simpa only [Fin.sum_univ_eq_sum_range] using M.weights_sum
+
+theorem variance_lower_pos (M : Domain) : 0 < varianceLower M := by
+  have hp : 0 < M.p := by linarith [M.p_half]
+  unfold varianceLower
+  exact mul_pos (mul_pos (sq_pos_of_pos (by linarith [M.c_lt_one])) hp)
+    (by linarith [M.p_lt_one])
+
+theorem bernoulli_variance_lower (M : Domain) (b : Bool) :
+    varianceLower M ≤ q M b * (1-q M b) := by
+  have hc : 0 ≤ 1-M.c := by linarith [M.c_lt_one]
+  have hp : 0 ≤ M.p := by linarith [M.p_half]
+  have hprod : 0 ≤ (1-M.c)*M.p := mul_nonneg hc hp
+  have hprod' : 0 ≤ (1-M.c)*(1-M.p) := mul_nonneg hc (by linarith [M.p_lt_one])
+  cases b <;> simp only [q, Bool.false_eq_true, ite_false, add_zero, ite_true]
+  · unfold varianceLower
+    nlinarith [mul_nonneg hprod M.c_nonneg]
+  · unfold varianceLower
+    nlinarith [mul_nonneg hprod' M.c_nonneg]
+
+theorem variance_rate_pos (M : Domain) (a : Fin M.K → Bool) :
+    0 < varianceRate M a := by
+  have h : varianceLower M ≤ varianceRate M a := by
+    calc
+      varianceLower M = ∑ i : Fin M.K, M.w i * varianceLower M := by
+        rw [← Finset.sum_mul, weights_fin_sum, one_mul]
+      _ ≤ varianceRate M a := Finset.sum_le_sum (fun i _ =>
+        mul_le_mul_of_nonneg_left (bernoulli_variance_lower M (a i)) (M.w_nonneg i))
+  exact lt_of_lt_of_le (variance_lower_pos M) h
+
+theorem finite_variance_lower (M : Domain) (a : Fin M.K → Bool) (N : ℕ) :
+    (N:ℝ)*varianceLower M ≤ variance M a N := by
+  have hsum : ∑ i : Fin M.K, (allocation M.w N i : ℝ) = (N:ℝ) := by
+    exact_mod_cast (by simpa only [Fin.sum_univ_eq_sum_range] using allocation_sum M N)
+  calc
+    (N:ℝ)*varianceLower M = ∑ i : Fin M.K,
+        (allocation M.w N i : ℝ)*varianceLower M := by rw [← Finset.sum_mul, hsum]
+    _ ≤ variance M a N := Finset.sum_le_sum (fun i _ =>
+      mul_le_mul_of_nonneg_left (bernoulli_variance_lower M (a i)) (by positivity))
+
+theorem mean_rounding_bound (M : Domain) (a : Fin M.K → Bool) (N : ℕ) :
+    |mean M a N - (N:ℝ)*score M a| ≤ (M.K:ℝ) := by
+  have heq : mean M a N - (N:ℝ)*score M a =
+      ∑ i : Fin M.K, ((allocation M.w N i : ℝ)-(N:ℝ)*M.w i)*q M (a i) := by
+    simp only [mean, score, Finset.mul_sum, ← Finset.sum_sub_distrib]
+    apply Finset.sum_congr rfl
+    intro i _
+    ring
+  rw [heq]
+  calc
+    _ ≤ ∑ i : Fin M.K, |((allocation M.w N i : ℝ)-(N:ℝ)*M.w i)*q M (a i)| :=
+      Finset.abs_sum_le_sum_abs _ _
+    _ ≤ ∑ _i : Fin M.K, (1:ℝ) := by
+      apply Finset.sum_le_sum
+      intro i _
+      rw [abs_mul, abs_of_pos (q_pos M (a i))]
+      have hdis : |(allocation M.w N i : ℝ)-(N:ℝ)*M.w i| ≤ 1 :=
+        abs_le.mpr ⟨le_of_lt (allocation_discrepancy M N i).1,
+          le_of_lt (allocation_discrepancy M N i).2⟩
+      exact (mul_le_mul_of_nonneg_right hdis (le_of_lt (q_pos M (a i)))).trans
+        (by simpa using le_of_lt (q_lt_one M (a i)))
+    _ = (M.K:ℝ) := by simp
+
+theorem diagonal_mean_bound (M : Domain) (a : Fin M.K → Bool)
+    (hdiag : score M a = (1:ℝ)/2) (N : ℕ) :
+    |mean M a N - (N:ℝ)/2| ≤ (M.K:ℝ) := by
+  simpa only [hdiag, mul_one_div] using mean_rounding_bound M a N
+
+theorem variance_rate_limit (M : Domain) (a : Fin M.K → Bool) :
+    Tendsto (fun N : ℕ => variance M a N / (N:ℝ)) atTop (𝓝 (varianceRate M a)) := by
+  have h := tendsto_finset_sum Finset.univ (fun (i : Fin M.K) _ =>
+    (allocation_ratio M i).mul_const (q M (a i)*(1-q M (a i))))
+  convert h using 1
+  funext N
+  simp only [variance, Finset.sum_div, div_mul_eq_mul_div]
+
+/-- Variance really diverges for this fixed domain, including zero-weight lineages. -/
+theorem variance_atTop (M : Domain) (a : Fin M.K → Bool) :
+    Tendsto (variance M a) atTop atTop := by
+  apply tendsto_atTop_mono (fun N => finite_variance_lower M a N)
+  exact tendsto_natCast_atTop_atTop.atTop_mul_const (variance_lower_pos M)
+
+/-- On the diagonal the bounded quota drift is negligible compared with variance.
+This is a CLT prerequisite, not a CLT or a probability-tail certificate. -/
+theorem diagonal_drift_squared_limit (M : Domain) (a : Fin M.K → Bool)
+    (hdiag : score M a = (1:ℝ)/2) :
+    Tendsto (fun N : ℕ => (mean M a N - (N:ℝ)/2)^2 / variance M a N)
+      atTop (𝓝 0) := by
+  have hupper : Tendsto (fun N : ℕ => (M.K:ℝ)^2 / variance M a N)
+      atTop (𝓝 0) := tendsto_const_nhds.div_atTop (variance_atTop M a)
+  apply tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds hupper
+  · filter_upwards [(variance_atTop M a).eventually (eventually_ge_atTop 1)] with N hN
+    exact div_nonneg (sq_nonneg _) (by linarith)
+  · filter_upwards [(variance_atTop M a).eventually (eventually_ge_atTop 1)] with N hN
+    apply div_le_div_of_nonneg_right _ (by linarith)
+    have habs := diagonal_mean_bound M a hdiag N
+    nlinarith [sq_abs (mean M a N - (N:ℝ)/2), abs_nonneg (mean M a N - (N:ℝ)/2)]
+
+open Obligations046.Bridge
+
+def complement {ι : Type*} [Fintype ι] {n : ι → ℕ} (x : World n) : World n :=
+  fun i => (x i)ᶜ
+
+theorem complement_involutive {ι : Type*} [Fintype ι] {n : ι → ℕ} (x : World n) :
+    complement (complement x) = x := by funext i; simp [complement]
+
+theorem unbiased_mass_complement (n : ℕ) (x : Finset (Fin n)) :
+    mass (1/2 : ℝ) xᶜ = mass (1/2 : ℝ) x := by
+  have hx : x.card ≤ n := by simpa using x.card_le_univ
+  simp only [mass, Finset.card_compl, Fintype.card_fin]
+  norm_num
+  rw [Nat.sub_sub_self hx, mul_comm]
+
+theorem unbiased_joint_complement {ι : Type*} [Fintype ι] (n : ι → ℕ)
+    (x : World n) :
+    jointMass n (fun _ => (1/2 : ℝ)) (complement x) =
+      jointMass n (fun _ => (1/2 : ℝ)) x := by
+  apply Finset.prod_congr rfl
+  intro i _
+  exact unbiased_mass_complement (n i) (x i)
+
+theorem count_complement (M : Domain) (N : ℕ) (x : World (sizes M N)) :
+    correctCount (complement x) + correctCount x = N := by
+  have hsum : ∑ i : Fin M.K, sizes M N i = N := by
+    simpa only [Fin.sum_univ_eq_sum_range] using allocation_sum M N
+  unfold correctCount
+  rw [← Finset.sum_add_distrib]
+  convert hsum using 1
+  apply Finset.sum_congr rfl
+  intro i _
+  simp only [complement, Finset.card_compl, Fintype.card_fin]
+  exact Nat.sub_add_cancel (by simpa using (x i).card_le_univ)
+
+theorem fair_loss_reflection (b d N : ℕ) (h : b+d=N) :
+    fairLoss b N + fairLoss d N = 1 := by
+  unfold fairLoss
+  split_ifs <;> norm_num <;> omega
+
+/-- Genuine diagonal subdomain, exact for every N (even N=0).
+It is not asserted for arbitrary diagonal scores with unequal q_i. -/
+theorem unbiased_conditional_exact (M : Domain) (a : Fin M.K → Bool)
+    (hunbiased : ∀ i, q M (a i) = (1:ℝ)/2) (N : ℕ) :
+    conditionalError M N a = (1:ℝ)/2 := by
+  let f : World (sizes M N) → ℝ := fun x =>
+    jointMass (sizes M N) (fun _ => (1/2:ℝ)) x * fairLoss (correctCount x) N
+  have hrep : conditionalError M N a = ∑ x, f x := by
+    rw [← conditional_error_representation, modelLaw, memberLaw_expectation]
+    simp only [f, hunbiased]
+  have hsym : ∑ x, f (complement x) = ∑ x, f x :=
+    Fintype.sum_bijective complement
+      ⟨fun x y h => by simpa only [complement_involutive] using congrArg complement h,
+       fun x => ⟨complement x, complement_involutive x⟩⟩ _ _ (fun _ => rfl)
+  have hpair : ∀ x, f (complement x) + f x =
+      jointMass (sizes M N) (fun _ => (1/2:ℝ)) x := by
+    intro x
+    simp only [f, unbiased_joint_complement, ← mul_add]
+    rw [fair_loss_reflection _ _ _ (count_complement M N x), mul_one]
+  have htotal : (∑ x, f (complement x)) + (∑ x, f x) = 1 := by
+    rw [← Finset.sum_add_distrib]
+    simp only [hpair]
+    exact jointMass_sum _ _
+  rw [hrep]
+  linarith
+
+theorem floor_limit_diag_unbiased (M : Domain) (a : Fin M.K → Bool)
+    (hunbiased : ∀ i, q M (a i) = (1:ℝ)/2) :
+    Tendsto (fun N => conditionalError M N a) atTop (𝓝 ((1:ℝ)/2)) := by
+  simpa only [unbiased_conditional_exact M a hunbiased] using
+    (tendsto_const_nhds : Tendsto (fun _ : ℕ => (1:ℝ)/2) atTop (𝓝 ((1:ℝ)/2)))
+
+/-- c=1 lies outside Domain: cumulative-floor quotas alone do not preserve ties.
+With two equal-weight deterministic lineages (false,true), odd sizes favor true. -/
+theorem deterministic_quota_even (m : ℕ) :
+    fairLoss ((2*m) - (2*m)/2) (2*m) = (1:ℝ)/2 := by
+  have h : (2*m)/2 = m := by omega
+  rw [h]
+  have hsub : 2*m-m = m := by omega
+  rw [hsub]
+  simp [fairLoss, Nat.not_lt.mpr (le_refl (2*m))]
+
+theorem deterministic_quota_odd (m : ℕ) :
+    fairLoss ((2*m+1) - (2*m+1)/2) (2*m+1) = 0 := by
+  have h : (2*m+1)/2 = m := by omega
+  rw [h]
+  have hl : ¬ 2*(2*m+1-m) < 2*m+1 := by omega
+  have he : ¬ 2*(2*m+1-m) = 2*m+1 := by omega
+  simp only [fairLoss, if_neg hl, if_neg he]
+
+/-- A legal heterogeneous diagonal; score=1/2 does not imply every q_i=1/2. -/
+def heterogeneous : Domain where
+  K := 2
+  K_pos := by norm_num
+  p := 3/4
+  c := 1/2
+  p_half := by norm_num
+  p_lt_one := by norm_num
+  c_nonneg := by norm_num
+  c_lt_one := by norm_num
+  w := fun i => if i=0 then 3/4 else if i=1 then 1/4 else 0
+  w_nonneg := by intro i; split_ifs <;> norm_num
+  weights_sum := by norm_num [Finset.sum_range_succ]
+
+def heterogeneousA : Fin 2 → Bool := fun i => i.val == 1
+
+theorem heterogeneous_diagonal : score heterogeneous heterogeneousA = (1:ℝ)/2 := by
+  change (∑ i : Fin 2, (if (i:ℕ)=0 then (3:ℝ)/4 else if (i:ℕ)=1 then 1/4 else 0) *
+    ((1-(1:ℝ)/2)*(3/4) + if (i:ℕ)==1 then (1:ℝ)/2 else 0)) = 1/2
+  norm_num [Fin.sum_univ_succ]
+
+theorem heterogeneous_not_unbiased :
+    ¬ (∀ i, q heterogeneous (heterogeneousA i) = (1:ℝ)/2) := by
+  intro h
+  have h0 := h ⟨0, by norm_num [heterogeneous]⟩
+  norm_num [q, heterogeneous, heterogeneousA] at h0
+
+end Obligations046.Diagonal

package/proofs/m0-046-uncertainty/M0FiniteDiscord046.lean

@@ -0,0 +1,207 @@
+import M0BlockCoverage046
+import M0Moments046
+import Obligations045.M0Coincidence
+import Mathlib.Tactic.FieldSimp
+open scoped BigOperators
+noncomputable section
+namespace Obligations046.FiniteDiscord
+open Obligations046.Moments Obligations045.M0Coincidence
+
+def discord (N k : ℕ) : ℝ := 2*(k:ℝ)*((N:ℝ)-(k:ℝ))/((N:ℝ)*((N:ℝ)-1))
+
+theorem discord_bounds (N k : ℕ) (hN : 2 ≤ N) (hk : k ≤ N) :
+    0 ≤ discord N k ∧ discord N k ≤ 1 := by
+  have hN2 : (2:ℝ) ≤ N := by exact_mod_cast hN
+  have hkN : (k:ℝ) ≤ N := by exact_mod_cast hk
+  have hk0 : (0:ℝ) ≤ k := by positivity
+  have hn0 : (0:ℝ) < N := by linarith
+  have hn1 : (0:ℝ) < (N:ℝ)-1 := by linarith
+  have hd : 0 < (N:ℝ)*((N:ℝ)-1) := mul_pos hn0 hn1
+  unfold discord
+  constructor
+  · exact div_nonneg (mul_nonneg (by positivity) (sub_nonneg.mpr hkN)) (le_of_lt hd)
+  · apply (div_le_one hd).mpr
+    nlinarith [sq_nonneg (2*(k:ℝ)-(N:ℝ)), mul_nonneg (sub_nonneg.mpr hN2) (le_of_lt hn0)]
+
+theorem conditional_discord_mean (q : ℝ) (N : ℕ) (hN : 2 ≤ N) :
+    binExpect q N (discord N) = 2*q*(1-q) := by
+  have hf : discord N = (fun k : ℕ => ((k:ℝ)*(N:ℝ)-(k:ℝ)^2)*(2/((N:ℝ)*((N:ℝ)-1)))) := by
+    funext k
+    unfold discord
+    ring
+  have hsub : binExpect q N (fun k : ℕ => (k:ℝ)*(N:ℝ)-(k:ℝ)^2) =
+      binExpect q N (fun k : ℕ => (k:ℝ)*(N:ℝ))-binExpect q N (fun k : ℕ => (k:ℝ)^2) := by
+    simp [binExpect, mul_sub, Finset.sum_sub_distrib]
+  rw [hf, binExpect_mul_const, hsub, binExpect_mul_const, binExpect_mean, binExpect_second]
+  have hN2 : (2:ℝ) ≤ N := by exact_mod_cast hN
+  have hN0 : (N:ℝ) ≠ 0 := by linarith
+  have hN1 : (N:ℝ)-1 ≠ 0 := by linarith
+  field_simp
+  ring
+
+theorem finite_M0_discord_mean (p c : ℝ) (ws : List ℝ) (hw : ws.sum = 1)
+    (N : ℕ) (hN : 2 ≤ N) :
+    expect p ws (fun x => binExpect ((1-c)*p+c*x) N (discord N)) =
+    2*p*(1-p)*(1-c^2*squares ws) := by
+  simp_rw [conditional_discord_mean _ N hN]
+  have hf : (fun x : ℝ => 2*((1-c)*p+c*x)*(1-((1-c)*p+c*x))) =
+      (fun x => (-2*c^2)*x^2+(2*c*(1-2*(1-c)*p))*x+2*(1-c)*p*(1-(1-c)*p)) := by
+    funext x
+    ring
+  rw [hf, expect_quadratic, hw]
+  ring
+
+
+theorem expect_mul (p : ℝ) (ws : List ℝ) (f : ℝ → ℝ) (a : ℝ) :
+    expect p ws (fun x => f x*a) = expect p ws f*a := by
+  induction ws generalizing f with
+  | nil => rfl
+  | cons w ws ih => simp only [Obligations045.M0Coincidence.expect, ih]; ring
+
+theorem expect_sum {ι : Type*} [Fintype ι] (p : ℝ) (ws : List ℝ) (f : ι → ℝ → ℝ) :
+    expect p ws (fun x => ∑ i, f i x) = ∑ i, expect p ws (f i) := by
+  induction ws generalizing f with
+  | nil => rfl
+  | cons w ws ih =>
+    simp only [Obligations045.M0Coincidence.expect, ih, Finset.mul_sum, Finset.sum_add_distrib]
+
+theorem expect_const_one (p : ℝ) (ws : List ℝ) : expect p ws (fun _ => 1) = 1 := by
+  simpa using expect_quadratic p ws 0 0 1
+
+theorem expect_support_nonneg (p : ℝ) (hp : 0 ≤ p) (hp1 : p ≤ 1)
+    (ws : List ℝ) (hw : ∀ w ∈ ws, 0 ≤ w) (f : ℝ → ℝ)
+    (hf : ∀ x, 0 ≤ x → x ≤ ws.sum → 0 ≤ f x) : 0 ≤ expect p ws f := by
+  induction ws generalizing f with
+  | nil => exact hf 0 (by norm_num) (by simp)
+  | cons w ws ih =>
+    have hw0 := hw w (by simp)
+    have htail : ∀ a ∈ ws, 0 ≤ a := fun a ha => hw a (by simp [ha])
+    have h1 : 0 ≤ expect p ws f := ih htail f (fun x hx hxs =>
+      hf x hx (by simp only [List.sum_cons]; linarith))
+    have h2 : 0 ≤ expect p ws (fun x => f (w+x)) := ih htail _ (fun x hx hxs =>
+      hf (w+x) (by linarith) (by simp only [List.sum_cons]; linarith))
+    exact add_nonneg (mul_nonneg (by linarith) h1) (mul_nonneg hp h2)
+
+def memberQ (p c x : ℝ) := (1-c)*p+c*x
+
+def cellMass (p c : ℝ) (ws : List ℝ) (N : ℕ) (k : Fin (N+1)) : ℝ :=
+  expect p ws (fun x => (N.choose k.val : ℝ)*(memberQ p c x)^k.val*(1-memberQ p c x)^(N-k.val))
+
+theorem cellMass_nonneg (p c : ℝ) (hp : 0 ≤ p) (hp1 : p ≤ 1)
+    (hc : 0 ≤ c) (hc1 : c ≤ 1) (ws : List ℝ) (hw : ws.sum = 1)
+    (hws : ∀ w ∈ ws, 0 ≤ w) (N : ℕ) (k : Fin (N+1)) : 0 ≤ cellMass p c ws N k := by
+  apply expect_support_nonneg p hp hp1 ws hws
+  intro x hx hxs
+  have hx1 : x ≤ 1 := by simpa only [hw] using hxs
+  have hq : 0 ≤ memberQ p c x := add_nonneg (mul_nonneg (by linarith) hp) (mul_nonneg hc hx)
+  have hq1 : 0 ≤ 1-memberQ p c x := by
+    have h := add_nonneg (mul_nonneg (by linarith : 0 ≤ 1-c) (by linarith : 0 ≤ 1-p))
+      (mul_nonneg hc (by linarith : 0 ≤ 1-x))
+    unfold memberQ
+    nlinarith
+  exact mul_nonneg (mul_nonneg (by positivity) (pow_nonneg hq _)) (pow_nonneg hq1 _)
+
+theorem cellMass_normalized (p c : ℝ) (ws : List ℝ) (N : ℕ) :
+    (∑ k : Fin (N+1), cellMass p c ws N k) = 1 := by
+  unfold cellMass
+  rw [← expect_sum]
+  have hf : (fun x : ℝ => ∑ k : Fin (N+1),
+      (N.choose k.val : ℝ)*(memberQ p c x)^k.val*(1-memberQ p c x)^(N-k.val)) = (fun _ => 1) := by
+    funext x
+    rw [Fin.sum_univ_eq_sum_range (fun k : ℕ => (N.choose k:ℝ)*(memberQ p c x)^k*(1-memberQ p c x)^(N-k)) (N+1)]
+    simpa only [binExpect, mul_one] using binExpect_one (memberQ p c x) N
+  rw [hf, expect_const_one]
+
+theorem cellMass_discord_mean (p c : ℝ) (ws : List ℝ) (hw : ws.sum = 1)
+    (N : ℕ) (hN : 2 ≤ N) :
+    (∑ k : Fin (N+1), cellMass p c ws N k*discord N k.val) =
+    2*p*(1-p)*(1-c^2*squares ws) := by
+  unfold cellMass
+  simp_rw [← expect_mul]
+  rw [← expect_sum]
+  have hf : (fun x : ℝ => ∑ k : Fin (N+1),
+      ((N.choose k.val : ℝ)*(memberQ p c x)^k.val*(1-memberQ p c x)^(N-k.val))*discord N k.val) =
+      (fun x => binExpect ((1-c)*p+c*x) N (discord N)) := by
+    funext x
+    rw [Fin.sum_univ_eq_sum_range (fun k : ℕ => ((N.choose k:ℝ)*(memberQ p c x)^k*(1-memberQ p c x)^(N-k))*discord N k) (N+1)]
+    rfl
+  rw [hf, finite_M0_discord_mean p c ws hw N hN]
+
+-- Actual binary M0: p=3/4,c=1/2,K=1,N=4. Pair indicators share observations.
+def witnessMass (k : Fin 5) : ℚ :=
+  (1/4)*(Nat.choose 4 k.val : ℚ)*(3/8)^k.val*(5/8)^(4-k.val)+
+  (3/4)*(Nat.choose 4 k.val : ℚ)*(7/8)^k.val*(1/8)^(4-k.val)
+def witnessScore (k : Fin 5) : ℚ := ((2*k.val*(4-k.val):ℕ):ℚ)/12
+
+theorem witness_normalized : (∑ k : Fin 5, witnessMass k) = 1 := by
+  norm_num [witnessMass, Fin.sum_univ_succ, Nat.choose]
+
+theorem witness_mean : (∑ k : Fin 5, witnessMass k*witnessScore k) = 9/32 := by
+  norm_num [witnessMass, witnessScore, Fin.sum_univ_succ, Nat.choose]
+
+theorem witness_variance :
+    (∑ k : Fin 5, witnessMass k*(witnessScore k-9/32)^2) = 157/2048 := by
+  norm_num [witnessMass, witnessScore, Fin.sum_univ_succ, Nat.choose]
+
+theorem pairs_not_iid : (157/2048:ℚ) > 1/(4*6) := by norm_num
+theorem repeated_cells_not_iid : (157/2048:ℚ) > 1/(4*100) := by norm_num
+
+theorem fixed_quota_negative : (3/8:ℚ) ≠ 21/64 := by norm_num
+
+theorem finite_M0_tail (p c : ℝ) (hp : 0 ≤ p) (hp1 : p ≤ 1)
+    (hc : 0 ≤ c) (hc1 : c ≤ 1) (ws : List ℝ) (hw : ws.sum = 1)
+    (hws : ∀ w ∈ ws, 0 ≤ w) (N T : ℕ) (hN : 2 ≤ N) (hT : 0 < T)
+    (eps : ℝ) (heps : 0 < eps) :
+    BlockCoverage.iidSum (cellMass p c ws N) (fun k => discord N k.val) T
+      (BlockCoverage.bad T (2*p*(1-p)*(1-c^2*squares ws)) eps) ≤
+      min 1 (1/(4*(T:ℝ)*eps^2)) := by
+  have hm : BlockCoverage.avg (cellMass p c ws N) (fun k => discord N k.val) =
+      2*p*(1-p)*(1-c^2*squares ws) := cellMass_discord_mean p c ws hw N hN
+  rw [← hm]
+  apply BlockCoverage.clipped_block_tail
+  · exact cellMass_nonneg p c hp hp1 hc hc1 ws hw hws N
+  · exact cellMass_normalized p c ws N
+  · intro k
+    exact discord_bounds N k.val hN (Nat.lt_succ_iff.mp k.isLt)
+  · exact hT
+  · exact heps
+
+
+theorem squares_nonneg (ws : List ℝ) : 0 ≤ squares ws := by
+  exact List.sum_nonneg (fun a ha => by obtain ⟨w, _, rfl⟩ := List.mem_map.mp ha; positivity)
+
+theorem squares_zero_sum (ws : List ℝ) (h : squares ws = 0) : ws.sum = 0 := by
+  induction ws with
+  | nil => rfl
+  | cons w ws ih =>
+    have hs : w^2+squares ws = 0 := by simpa [squares] using h
+    have hw : w = 0 := by nlinarith [squares_nonneg ws, sq_nonneg w]
+    have ht : squares ws = 0 := by nlinarith
+    simp [hw, ih ht]
+
+theorem squares_le_total_square (ws : List ℝ) (hws : ∀ w ∈ ws, 0 ≤ w) :
+    squares ws ≤ ws.sum^2 := by
+  induction ws with
+  | nil => simp [squares]
+  | cons w ws ih =>
+    have htail : ∀ a ∈ ws, 0 ≤ a := fun a ha => hws a (by simp [ha])
+    have hi := ih htail
+    have hsum : 0 ≤ ws.sum := List.sum_nonneg htail
+    have hw0 : 0 ≤ w := hws w (by simp)
+    simp only [squares, List.map_cons, List.sum_cons]
+    change w^2+squares ws ≤ (w+ws.sum)^2
+    nlinarith [mul_nonneg hw0 hsum]
+
+theorem participation_ge_one (ws : List ℝ) (hw : ws.sum = 1)
+    (hws : ∀ w ∈ ws, 0 ≤ w) : 0 < squares ws ∧ 1 ≤ 1/squares ws := by
+  have hp : 0 < squares ws := by
+    have h0 := squares_nonneg ws
+    have hn : squares ws ≠ 0 := by intro h; have hz := squares_zero_sum ws h; linarith
+    exact lt_of_le_of_ne h0 (Ne.symm hn)
+  have hsq := squares_le_total_square ws hws
+  refine ⟨hp, ?_⟩
+  apply (le_div_iff₀ hp).mpr
+  rw [hw] at hsq
+  nlinarith
+
+end Obligations046.FiniteDiscord

package/proofs/m0-046-uncertainty/M0Interval046.lean

@@ -0,0 +1,82 @@
+import Mathlib.Data.Real.Basic
+import Mathlib.Tactic.Linarith
+import Mathlib.Tactic.Positivity
+import Mathlib.Tactic.Ring
+import Mathlib.Tactic.FieldSimp
+
+namespace Obligations046.Interval
+
+def noise (p : ℝ) := 2*p*(1-p)
+
+theorem noise_bounds (pL p pU : ℝ) (hhalf : 1/2 < pL)
+    (hL : pL ≤ p) (hU : p ≤ pU) (hone : pU < 1) :
+    0 < noise pU ∧ noise pU ≤ noise p ∧ noise p ≤ noise pL := by
+  have h0 : 0 < pU := by linarith
+  have h1 : 0 < 1-pU := sub_pos.mpr hone
+  have ha : 0 < noise pU := by unfold noise; positivity
+  refine ⟨ha, ?_, ?_⟩
+  · have h := mul_nonneg (sub_nonneg.mpr hU) (by linarith : 0 ≤ pU+p-1)
+    unfold noise
+    nlinarith
+  · have h := mul_nonneg (sub_nonneg.mpr hL) (by linarith : 0 ≤ p+pL-1)
+    unfold noise
+    nlinarith
+
+theorem denominator_box (DL D DU aL a aU : ℝ) (hDL0 : 0 ≤ DL)
+    (hDL : DL ≤ D) (hDU : D ≤ DU) (haL : 0 < aL)
+    (ha : aL ≤ a) (haU : a ≤ aU) :
+    1-DU/aL ≤ 1-D/a ∧ 1-D/a ≤ 1-DL/aU := by
+  have ha0 : 0 < a := by linarith
+  have haU0 : 0 < aU := by linarith
+  have hD0 : 0 ≤ D := by linarith
+  have h1 : DL/aU ≤ D/a := by
+    apply (div_le_div_iff₀ haU0 ha0).mpr
+    nlinarith [mul_nonneg (sub_nonneg.mpr hDL) (le_of_lt haU0),
+      mul_nonneg hDL0 (sub_nonneg.mpr haU)]
+  have h2 : D/a ≤ DU/aL := by
+    apply (div_le_div_iff₀ ha0 haL).mpr
+    nlinarith [mul_nonneg (sub_nonneg.mpr hDU) (le_of_lt ha0),
+      mul_nonneg hD0 (sub_nonneg.mpr ha)]
+  constructor <;> linarith
+
+theorem ratio_box (cL c cU BL B BU : ℝ) (hcL : 0 ≤ cL)
+    (hc : cL ≤ c) (hcU : c ≤ cU) (hBL : 0 < BL)
+    (hB : BL ≤ B) (hBU : B ≤ BU) :
+    cL^2/BU ≤ c^2/B ∧ c^2/B ≤ cU^2/BL := by
+  have hB0 : 0 < B := by linarith
+  have hBU0 : 0 < BU := by linarith
+  have hlow : 0 ≤ c^2-cL^2 := by
+    nlinarith [mul_nonneg (sub_nonneg.mpr hc) (by linarith : 0 ≤ c+cL)]
+  have hhi : 0 ≤ cU^2-c^2 := by
+    nlinarith [mul_nonneg (sub_nonneg.mpr hcU) (by linarith : 0 ≤ cU+c)]
+  constructor
+  · apply (div_le_div_iff₀ hBU0 hB0).mpr
+    nlinarith [mul_nonneg hlow (le_of_lt hBU0),
+      mul_nonneg (sq_nonneg cL) (sub_nonneg.mpr hBU)]
+  · apply (div_le_div_iff₀ hB0 hBL).mpr
+    nlinarith [mul_nonneg hhi (le_of_lt hB0),
+      mul_nonneg (sq_nonneg c) (sub_nonneg.mpr hB)]
+
+theorem pair_identity_inverse (D p c Q K : ℝ) (ha : noise p ≠ 0)
+    (hQ : Q ≠ 0) (hc : c ≠ 0) (hD : D = noise p*(1-c^2*Q))
+    (hK : K = 1/Q) : K = c^2/(1-D/noise p) := by
+  have hb : 1-D/noise p = c^2*Q := by rw [hD]; field_simp
+  rw [hb,hK]
+  field_simp
+
+-- The reciprocal has no finite upper enclosure when its denominator may approach zero.
+theorem unbounded_reciprocal (c M : ℝ) (hc : 0 < c) (hM : 0 < M) :
+    ∃ B : ℝ, 0 < B ∧ c^2/B > M := by
+  refine ⟨c^2/(M+1), by positivity, ?_⟩
+  have h : c^2/(c^2/(M+1)) = M+1 := by field_simp
+  rw [h]
+  linarith
+
+-- No independence of calibration/data failures is needed for this deterministic union bound.
+theorem three_budget_union (d p c : ℝ) (_hd : 0 ≤ d) (_hp : 0 ≤ p) (_hc : 0 ≤ c)
+    (i j k : ℝ) (_hi : 0 ≤ i) (_hj : 0 ≤ j) (_hk : 0 ≤ k)
+    (hdi : i ≤ d) (hpj : j ≤ p) (hck : k ≤ c) : i+j+k ≤ d+p+c := by linarith
+theorem physical_cap_clip (L K U cap : ℝ) (hL : L ≤ K) (hU : K ≤ U)
+    (hK : 1 ≤ K) (hcap : K ≤ cap) : max 1 L ≤ K ∧ K ≤ min U cap :=
+  ⟨max_le hK hL, le_min hU hcap⟩
+end Obligations046.Interval

package/proofs/m0-046-uncertainty/M0Lindeberg046.lean

@@ -0,0 +1,92 @@
+import M0Moments046
+import Mathlib.Data.Real.Sqrt
+open scoped BigOperators
+open Filter Topology MeasureTheory
+noncomputable section
+open Classical Obligations045.M0 Obligations046.Bridge Obligations046.Diagonal
+namespace Obligations046.Lindeberg
+
+/-- The exact truncated centered second moment of one Bernoulli member.
+Squared cutoff is ε² times the total variance; ε>0 is required below. -/
+def bernoulliTail (q cutoff : ℝ) : ℝ :=
+  q*(if cutoff < (1-q)^2 then (1-q)^2 else 0) +
+    (1-q)*(if cutoff < q^2 then q^2 else 0)
+
+def ratio (M : Domain) (a : Fin M.K → Bool) (N : ℕ) (ε : ℝ) : ℝ :=
+  (∑ i : Fin M.K, (allocation M.w N i:ℝ) *
+    bernoulliTail (q M (a i)) (ε^2 * Obligations046.Diagonal.variance M a N)) /
+      Obligations046.Diagonal.variance M a N
+
+theorem centered_square_le_one (q : ℝ) (hq : 0 ≤ q) (hq1 : q ≤ 1) :
+    q^2 ≤ 1 ∧ (1-q)^2 ≤ 1 := by constructor <;> nlinarith
+
+theorem bernoulli_tail_zero (q cutoff : ℝ) (hq : 0 ≤ q) (hq1 : q ≤ 1)
+    (hc : 1 ≤ cutoff) : bernoulliTail q cutoff = 0 := by
+  have h := centered_square_le_one q hq hq1
+  simp only [bernoulliTail, if_neg (not_lt.mpr (h.2.trans hc)),
+    if_neg (not_lt.mpr (h.1.trans hc)), mul_zero, add_zero]
+
+theorem cutoff_eventually_large (M : Domain) (a : Fin M.K → Bool)
+    (ε : ℝ) (hε : 0 < ε) :
+    ∀ᶠ N : ℕ in atTop, 1 ≤ ε^2*Obligations046.Diagonal.variance M a N := by
+  have hs : 0 < ε^2 := sq_pos_of_pos hε
+  have hv := (variance_atTop M a).eventually (eventually_ge_atTop (1/ε^2))
+  filter_upwards [hv] with N hN
+  simpa only [mul_comm] using (div_le_iff₀ hs).mp hN
+
+theorem lindeberg_eventually_zero (M : Domain) (a : Fin M.K → Bool)
+    (ε : ℝ) (hε : 0 < ε) :
+    ∀ᶠ N : ℕ in atTop, ratio M a N ε = 0 := by
+  filter_upwards [cutoff_eventually_large M a ε hε] with N hN
+  have hz : ∀ i : Fin M.K,
+      bernoulliTail (q M (a i)) (ε^2*Obligations046.Diagonal.variance M a N) = 0 :=
+    fun i => bernoulli_tail_zero _ _ (q_pos M (a i)).le (q_lt_one M (a i)).le hN
+  simp only [ratio, hz, mul_zero, Finset.sum_const_zero, zero_div]
+
+theorem lindeberg_limit (M : Domain) (a : Fin M.K → Bool)
+    (ε : ℝ) (hε : 0 < ε) :
+    Tendsto (fun N => ratio M a N ε) atTop (𝓝 0) := by
+  have he : (fun N => ratio M a N ε) =ᶠ[atTop] (fun _ => 0) :=
+    lindeberg_eventually_zero M a ε hε
+  exact tendsto_const_nhds.congr' he.symm
+
+/-- Explicit two-atom expectation, to prevent treating the cutoff expression as a certificate. -/
+theorem bernoulli_tail_expectation (q cutoff : ℝ) :
+    (∑ b : Bool, (if b then q else 1-q) *
+      (if cutoff < ((if b then (1:ℝ) else 0)-q)^2
+       then ((if b then (1:ℝ) else 0)-q)^2 else 0)) = bernoulliTail q cutoff := by
+  simp only [Fintype.sum_bool, Bool.false_eq_true, ite_false, zero_sub, neg_sq, ite_true,
+    bernoulliTail]
+
+theorem bernoulli_zero_cutoff (q : ℝ) (hq : 0 < q) (hq1 : q < 1) :
+    bernoulliTail q 0 = q*(1-q) := by
+  have h1 : 0 < (1-q)^2 := sq_pos_of_pos (by linarith)
+  have h0 : 0 < q^2 := sq_pos_of_pos hq
+  rw [bernoulliTail, if_pos h1, if_pos h0]
+  ring
+
+/-- Negative boundary: ε=0 gives ratio 1 at every positive sample size, not 0. -/
+theorem zero_epsilon_ratio (M : Domain) (a : Fin M.K → Bool) (N : ℕ) (hN : 0 < N) :
+    ratio M a N 0 = 1 := by
+  have hv : 0 < Obligations046.Diagonal.variance M a N :=
+    lt_of_lt_of_le (mul_pos (by exact_mod_cast hN) (variance_lower_pos M))
+      (finite_variance_lower M a N)
+  have hz : ∀ i : Fin M.K, bernoulliTail (q M (a i)) 0 = q M (a i)*(1-q M (a i)) :=
+    fun i => bernoulli_zero_cutoff _ (q_pos M (a i)) (q_lt_one M (a i))
+  simp only [ratio, zero_pow (by decide : (2:ℕ)≠0), zero_mul, hz]
+  change Obligations046.Diagonal.variance M a N / Obligations046.Diagonal.variance M a N = 1
+  exact div_self hv.ne'
+
+/-- Centering at the majority threshold or at the actual probabilistic mean differs
+by o(standard deviation), with the published quota rule and c<1. -/
+theorem actual_mean_standardized_drift (M : Domain) (a : Fin M.K → Bool)
+    (hdiag : score M a = (1:ℝ)/2) :
+    Tendsto (fun N : ℕ =>
+      |(∫ x, (correctCount x:ℝ) ∂(modelLaw M N a).toMeasure) - (N:ℝ)/2| /
+      Real.sqrt (ProbabilityTheory.variance (fun x => (correctCount x:ℝ))
+        (modelLaw M N a).toMeasure)) atTop (𝓝 0) := by
+  simpa only [Obligations046.Moments.model_mean, Obligations046.Moments.model_variance,
+    Real.sqrt_div (sq_nonneg _), Real.sqrt_sq_eq_abs, Real.sqrt_zero] using
+      (diagonal_drift_squared_limit M a hdiag).sqrt
+
+end Obligations046.Lindeberg