@lapxo/obligations 0.4.5 → 0.4.6

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