@lapxo/obligations 0.4.5 → 0.4.6

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

package/proofs/m0-046-diagonal/M0Moments046.lean

@@ -0,0 +1,295 @@
+import M0Diagonal046
+import Mathlib.Probability.Variance
+open scoped BigOperators
+open Filter Topology MeasureTheory
+noncomputable section
+open Classical Obligations045.M0 Obligations046.Bridge Obligations046.Diagonal
+namespace Obligations046.Moments
+
+/-- Finite binomial expectation; no asymptotic certificate. -/
+def binExpect (p : ℝ) (n : ℕ) (f : ℕ → ℝ) : ℝ :=
+  ∑ k ∈ Finset.range (n+1), (n.choose k : ℝ)*p^k*(1-p)^(n-k)*f k
+
+theorem binExpect_one (p : ℝ) (n : ℕ) : binExpect p n (fun _ => 1) = 1 := by
+  unfold binExpect
+  simp only [mul_one]
+  calc
+    _ = (p+(1-p))^n := by
+      rw [add_pow]
+      apply Finset.sum_congr rfl
+      intro k _
+      ring
+    _ = 1 := by simp
+
+theorem binExpect_succ (p : ℝ) (n : ℕ) (f : ℕ → ℝ) :
+    binExpect p (n+1) f =
+      (1-p)*binExpect p n f + p*binExpect p n (fun k => f (k+1)) := by
+  have h := Finset.sum_choose_succ_mul (fun k j => p^k*(1-p)^j*f k) n
+  unfold binExpect
+  simp only [Nat.add_assoc] at h ⊢
+  calc
+    _ = (∑ k ∈ Finset.range (n+1), (n.choose k:ℝ)*(p^k*(1-p)^(n+1-k)*f k)) +
+        ∑ k ∈ Finset.range (n+1), (n.choose k:ℝ)*(p^(k+1)*(1-p)^(n-k)*f (k+1)) := by
+      convert h using 1
+      apply Finset.sum_congr rfl
+      intro k _
+      ring
+    _ = _ := by
+      rw [Finset.mul_sum, Finset.mul_sum]
+      congr 1
+      · apply Finset.sum_congr rfl
+        intro k hk
+        have hk' : k ≤ n := by simpa only [Finset.mem_range, Nat.lt_succ_iff] using hk
+        rw [show n+1-k = (n-k)+1 by omega, pow_succ]
+        ring
+      · apply Finset.sum_congr rfl
+        intro k _
+        rw [pow_succ]
+        ring
+
+theorem binExpect_add (p : ℝ) (n : ℕ) (f g : ℕ → ℝ) :
+    binExpect p n (fun k => f k+g k) = binExpect p n f + binExpect p n g := by
+  simp [binExpect, mul_add, Finset.sum_add_distrib]
+
+theorem binExpect_mul_const (p : ℝ) (n : ℕ) (f : ℕ → ℝ) (r : ℝ) :
+    binExpect p n (fun k => f k*r) = binExpect p n f*r := by
+  simp only [binExpect, ← mul_assoc, Finset.sum_mul]
+
+theorem binExpect_const (p r : ℝ) (n : ℕ) : binExpect p n (fun _ => r) = r := by
+  simpa only [one_mul, binExpect_one] using binExpect_mul_const p n (fun _ => 1) r
+
+theorem binExpect_mean (p : ℝ) (n : ℕ) : binExpect p n (fun k => (k:ℝ)) = (n:ℝ)*p := by
+  induction n with
+  | zero => simp [binExpect]
+  | succ n ih =>
+    rw [binExpect_succ]
+    have hshift : binExpect p n (fun k => ((k+1:ℕ):ℝ)) = (n:ℝ)*p+1 := by
+      simp only [Nat.cast_add, Nat.cast_one]
+      rw [binExpect_add, ih, binExpect_const]
+    rw [hshift, ih]
+    push_cast
+    ring
+
+theorem binExpect_second (p : ℝ) (n : ℕ) :
+    binExpect p n (fun k => (k:ℝ)^2) = (n:ℝ)*p*(1-p)+((n:ℝ)*p)^2 := by
+  induction n with
+  | zero => simp [binExpect]
+  | succ n ih =>
+    rw [binExpect_succ, ih]
+    have heq : (fun k : ℕ => ((k+1:ℕ):ℝ)^2) =
+        (fun k : ℕ => ((k:ℝ)^2 + (k:ℝ)*2) + 1) := by funext k; push_cast; ring
+    rw [heq, binExpect_add, binExpect_add, binExpect_mul_const,
+      binExpect_mean, binExpect_const, ih]
+    push_cast
+    ring
+
+/-- Finite pushforward of a scalar observable, without an asserted moment. -/
+theorem finite_pushforward {S T : Type*} [Fintype S] [Fintype T] [DecidableEq T]
+    (m : S → ℝ) (c : S → T) (f : T → ℝ) :
+    (∑ x, m x*f (c x)) = ∑ y, (∑ x, if c x=y then m x else 0)*f y := by
+  symm
+  simp_rw [Finset.sum_mul]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro x _
+  simp_rw [ite_mul, zero_mul]
+  simp
+
+theorem mass_card_expect (p : ℝ) (n : ℕ) (f : ℕ → ℝ) :
+    (∑ x : Finset (Fin n), mass p x*f x.card) = binExpect p n f := by
+  calc
+    _ = ∑ k : Fin (n+1), binMass p n k*f k := by
+      simpa only [count_fiber_mass] using
+        finite_pushforward (mass p) (@count n) (fun k => f (k:ℕ))
+    _ = binExpect p n f := by
+      simp only [binMass, binExpect]
+      exact Fin.sum_univ_eq_sum_range
+        (fun k : ℕ => (n.choose k:ℝ)*p^k*(1-p)^(n-k)*f k) (n+1)
+
+section ProductMoments
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+    {S : ι → Type*} [∀ i, Fintype (S i)]
+
+def expect (m : ∀ i, S i → ℝ) (f : (∀ i, S i) → ℝ) : ℝ :=
+  ∑ x, (∏ i, m i (x i))*f x
+
+theorem expect_product (m : ∀ i, S i → ℝ) (f : ∀ i, S i → ℝ) :
+    expect m (fun x => ∏ i, f i (x i)) = ∏ i, ∑ s, m i s*f i s := by
+  simp only [expect, ← Finset.prod_mul_distrib, Fintype.prod_sum]
+
+theorem expect_coordinate (m : ∀ i, S i → ℝ) (hm : ∀ i, ∑ s, m i s = 1)
+    (f : ∀ i, S i → ℝ) (j : ι) :
+    expect m (fun x => f j (x j)) = ∑ s, m j s*f j s := by
+  calc
+    _ = expect m (fun x => ∏ i, if i=j then f i (x i) else 1) := by simp
+    _ = ∏ i, ∑ s, m i s * (if i=j then f i s else 1) := expect_product m (fun i s => if i=j then f i s else 1)
+    _ = ∏ i, if i=j then (∑ s, m i s*f i s) else 1 := by
+      apply Finset.prod_congr rfl
+      intro i _
+      by_cases h : i=j <;> simp [h, hm]
+    _ = _ := by simp
+
+theorem expect_sum {κ : Type*} [Fintype κ] (m : ∀ i, S i → ℝ)
+    (f : κ → (∀ i, S i) → ℝ) :
+    expect m (fun x => ∑ j, f j x) = ∑ j, expect m (f j) := by
+  simp only [expect, Finset.mul_sum]
+  rw [Finset.sum_comm]
+
+theorem expect_cross_centered (m : ∀ i, S i → ℝ)
+    (f : ∀ i, S i → ℝ) (hf : ∀ i, ∑ s, m i s*f i s = 0)
+    (i j : ι) (hne : i≠j) :
+    expect m (fun x => f i (x i)*f j (x j)) = 0 := by
+  calc
+    _ = expect m (fun x => ∏ k, if k=i then f k (x k) else if k=j then f k (x k) else 1) := by
+      congr 1
+      funext x
+      rw [Finset.prod_eq_mul_prod_diff_singleton (Finset.mem_univ i)]
+      simp only [ite_true]
+      congr 1
+      symm
+      calc
+        _ = ∏ k ∈ Finset.univ \ {i}, if k=j then f k (x k) else 1 := by
+          apply Finset.prod_congr rfl
+          intro k hk
+          have hki : k≠i := by simpa using (Finset.mem_sdiff.mp hk).2
+          simp only [if_neg hki]
+        _ = f j (x j) := by simp [Finset.prod_ite_eq', Ne.symm hne]
+    _ = ∏ k, ∑ s, m k s*(if k=i then f k s else if k=j then f k s else 1) :=
+      expect_product m (fun k s => if k=i then f k s else if k=j then f k s else 1)
+    _ = 0 := Finset.prod_eq_zero (Finset.mem_univ i) (by simpa using hf i)
+
+theorem expect_centered_square (m : ∀ i, S i → ℝ)
+    (hm : ∀ i, ∑ s, m i s = 1)
+    (f : ∀ i, S i → ℝ) (hf : ∀ i, ∑ s, m i s*f i s = 0) :
+    expect m (fun x => (∑ i, f i (x i))^2) =
+      ∑ i, ∑ s, m i s*(f i s)^2 := by
+  simp_rw [pow_two, Fintype.sum_mul_sum, expect_sum]
+  apply Finset.sum_congr rfl
+  intro i _
+  have hc : ∀ j, expect m (fun x => f i (x i)*f j (x j)) =
+      if j=i then (∑ s, m i s*(f i s*f i s)) else 0 := by
+    intro j
+    by_cases h : j=i
+    · subst j
+      simp only [ite_true]
+      exact expect_coordinate m hm (fun k s => f k s*f k s) i
+    · rw [if_neg h]
+      exact expect_cross_centered m f hf i j (Ne.symm h)
+  simp_rw [hc]
+  simp
+
+end ProductMoments
+
+theorem mass_card_mean (p : ℝ) (n : ℕ) :
+    (∑ x : Finset (Fin n), mass p x*(x.card:ℝ)) = (n:ℝ)*p := by
+  rw [mass_card_expect, binExpect_mean]
+
+theorem mass_card_second (p : ℝ) (n : ℕ) :
+    (∑ x : Finset (Fin n), mass p x*(x.card:ℝ)^2) =
+      (n:ℝ)*p*(1-p)+((n:ℝ)*p)^2 := by
+  calc
+    _ = binExpect p n (fun k => (k:ℝ)^2) := mass_card_expect _ _ _
+    _ = _ := binExpect_second p n
+
+theorem mass_centered_mean (p : ℝ) (n : ℕ) :
+    (∑ x : Finset (Fin n), mass p x*((x.card:ℝ)-(n:ℝ)*p)) = 0 := by
+  simp only [mul_sub, Finset.sum_sub_distrib, ← Finset.sum_mul]
+  rw [mass_card_mean, mass_sum]
+  ring
+
+theorem mass_centered_second (p : ℝ) (n : ℕ) :
+    (∑ x : Finset (Fin n), mass p x*((x.card:ℝ)-(n:ℝ)*p)^2) =
+      (n:ℝ)*p*(1-p) := by
+  calc
+    _ = (∑ x : Finset (Fin n), mass p x*(x.card:ℝ)^2) -
+        (∑ x : Finset (Fin n), mass p x*(x.card:ℝ))*(2*((n:ℝ)*p)) +
+        (∑ x : Finset (Fin n), mass p x)*((n:ℝ)*p)^2 := by
+      rw [Finset.sum_mul, Finset.sum_mul, ← Finset.sum_sub_distrib, ← Finset.sum_add_distrib]
+      apply Finset.sum_congr rfl
+      intro x _
+      ring
+    _ = _ := by rw [mass_card_second, mass_card_mean, mass_sum]; ring
+
+section ActualMoments
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+theorem member_total_mean (n : ι → ℕ) (p : ι → ℝ)
+    (hp : ∀ i, 0 ≤ p i) (hp1 : ∀ i, p i ≤ 1) :
+    (∫ x, (correctCount x:ℝ) ∂(memberLaw n p hp hp1).toMeasure) =
+      ∑ i, (n i:ℝ)*p i := by
+  rw [memberLaw_expectation]
+  change expect (fun i => mass (p i)) (fun x => (correctCount x:ℝ)) = _
+  have he : (fun x : World n => (correctCount x:ℝ)) =
+      (fun x => ∑ i, ((x i).card:ℝ)) := by funext x; simp [correctCount]
+  rw [he, expect_sum]
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [expect_coordinate _ (fun j => mass_sum (p j) (n j))
+      (fun j (s : Finset (Fin (n j))) => (s.card:ℝ)), mass_card_mean]
+
+theorem member_total_centered_second (n : ι → ℕ) (p : ι → ℝ)
+    (hp : ∀ i, 0 ≤ p i) (hp1 : ∀ i, p i ≤ 1) :
+    (∫ x, ((correctCount x:ℝ) - ∑ i, (n i:ℝ)*p i)^2
+      ∂(memberLaw n p hp hp1).toMeasure) =
+      ∑ i, (n i:ℝ)*p i*(1-p i) := by
+  rw [memberLaw_expectation]
+  change expect (fun i => mass (p i))
+    (fun x => ((correctCount x:ℝ) - ∑ i, (n i:ℝ)*p i)^2) = _
+  have he : (fun x : World n => ((correctCount x:ℝ) - ∑ i, (n i:ℝ)*p i)^2) =
+      (fun x => (∑ i, (((x i).card:ℝ)-(n i:ℝ)*p i))^2) := by
+    funext x
+    simp only [correctCount, Nat.cast_sum, Finset.sum_sub_distrib]
+  rw [he, expect_centered_square _ (fun j => mass_sum (p j) (n j))
+    (fun j (s : Finset (Fin (n j))) => (s.card:ℝ)-(n j:ℝ)*p j)
+    (fun j => mass_centered_mean (p j) (n j))]
+  apply Finset.sum_congr rfl
+  intro i _
+  exact mass_centered_second (p i) (n i)
+
+end ActualMoments
+
+theorem model_mean (M : Domain) (a : Fin M.K → Bool) (N : ℕ) :
+    (∫ x, (correctCount x:ℝ) ∂(modelLaw M N a).toMeasure) = mean M a N := by
+  exact member_total_mean _ _ _ _
+
+theorem model_centered_second (M : Domain) (a : Fin M.K → Bool) (N : ℕ) :
+    (∫ x, ((correctCount x:ℝ)-mean M a N)^2 ∂(modelLaw M N a).toMeasure) =
+      Obligations046.Diagonal.variance M a N := by
+  simpa only [mean, Obligations046.Diagonal.variance, mul_assoc] using
+    member_total_centered_second (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)
+
+theorem model_variance (M : Domain) (a : Fin M.K → Bool) (N : ℕ) :
+    ProbabilityTheory.variance (fun x => (correctCount x:ℝ)) (modelLaw M N a).toMeasure =
+      Obligations046.Diagonal.variance M a N := by
+  rw [ProbabilityTheory.variance_eq_integral (measurable_of_finite _).aemeasurable,
+    model_mean]
+  exact model_centered_second M a N
+
+/-- The asymptotic variance statements now refer to the actual admitted probability law. -/
+theorem model_variance_rate_limit (M : Domain) (a : Fin M.K → Bool) :
+    Tendsto (fun N : ℕ =>
+      ProbabilityTheory.variance (fun x => (correctCount x:ℝ)) (modelLaw M N a).toMeasure /
+        (N:ℝ)) atTop (𝓝 (varianceRate M a)) := by
+  simpa only [model_variance] using variance_rate_limit M a
+
+theorem model_variance_atTop (M : Domain) (a : Fin M.K → Bool) :
+    Tendsto (fun N : ℕ =>
+      ProbabilityTheory.variance (fun x => (correctCount x:ℝ)) (modelLaw M N a).toMeasure)
+      atTop atTop := by
+  simpa only [model_variance] using variance_atTop M a
+
+/-- Counterexample to replacing the joint product law by matching individual marginals.
+Two perfectly correlated Bernoulli(3/4) members have variance 3/4, not 3/8. -/
+theorem correlated_pair_second :
+    (∑ b : Bool, (if b then (3:ℝ)/4 else 1/4)*
+      ((if b then (2:ℝ) else 0)-3/2)^2) = 3/4 := by
+  norm_num [Fintype.sum_bool]
+
+theorem correlated_pair_not_independent_variance :
+    (∑ b : Bool, (if b then (3:ℝ)/4 else 1/4)*
+      ((if b then (2:ℝ) else 0)-3/2)^2) ≠ 2*((3:ℝ)/4)*(1-3/4) := by
+  rw [correlated_pair_second]
+  norm_num
+
+end Obligations046.Moments