@lapxo/obligations 0.4.4 → 0.4.6

package/proofs/m1-046-diagonal/M1Diagonal046.lean

@@ -0,0 +1,334 @@
+import M1Offdiag046
+import M0Lindeberg046
+import M0Threshold046
+
+open scoped BigOperators
+open Filter Topology MeasureTheory ProbabilityTheory
+noncomputable section
+open Classical Obligations046.M1Bridge Obligations046.M1Offdiag Obligations046.Bridge
+namespace Obligations046.M1Diagonal
+
+def fresh (M : Model) : ℝ := (1-M.base.c)*(1-M.c2)
+def varianceLower (M : Model) : ℝ := (fresh M)^2*M.base.p*(1-M.base.p)
+
+theorem fresh_pos (M : Model) : 0 < fresh M :=
+  mul_pos (by linarith [M.base.c_lt_one]) (by linarith [M.c2_lt_one])
+
+theorem variance_lower_pos (M : Model) : 0 < varianceLower M := by
+  unfold varianceLower
+  exact mul_pos (mul_pos (sq_pos_of_pos (fresh_pos M)) (by linarith [M.base.p_half]))
+    (by linarith [M.base.p_lt_one])
+
+theorem fresh_probability_bounds (M : Model) (A : Ancestors M) (B : Leaves M)
+    (i : Fin M.base.K) :
+    fresh M*M.base.p ≤ q M A B i ∧ fresh M*(1-M.base.p) ≤ 1-q M A B i := by
+  let a := M.base.c
+  let b := (1-M.base.c)*M.c2
+  let d := fresh M
+  have ha : 0 ≤ a := M.base.c_nonneg
+  have hb : 0 ≤ b := mul_nonneg (by linarith [M.base.c_lt_one]) M.c2_nonneg
+  have hd : 0 ≤ d := (fresh_pos M).le
+  have hs : a+b+d=1 := by dsimp [a,b,d,fresh]; ring
+  change d*M.base.p ≤ a*(if A (M.parent i) then 1 else 0)+
+      b*(if B i then 1 else 0)+d*M.base.p ∧
+    d*(1-M.base.p) ≤ 1-(a*(if A (M.parent i) then 1 else 0)+
+      b*(if B i then 1 else 0)+d*M.base.p)
+  cases A (M.parent i) <;> cases B i <;> simp only [Bool.false_eq_true, ite_false, ite_true,
+    mul_zero, mul_one, zero_add, add_zero] <;> constructor <;> nlinarith
+
+theorem bernoulli_variance_lower (M : Model) (A : Ancestors M) (B : Leaves M)
+    (i : Fin M.base.K) : varianceLower M ≤ q M A B i*(1-q M A B i) := by
+  have h := fresh_probability_bounds M A B i
+  have hp : 0 ≤ fresh M*M.base.p := mul_nonneg (fresh_pos M).le (by linarith [M.base.p_half])
+  have hmul := mul_le_mul h.1 h.2
+    (mul_nonneg (fresh_pos M).le (by linarith [M.base.p_lt_one])) (q_bounds M A B i).1
+  unfold varianceLower
+  nlinarith only [hmul]
+
+theorem finite_variance_lower (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) :
+    (N:ℝ)*varianceLower M ≤ variance M A B N := by
+  have hsum : ∑ i : Fin M.base.K, (sizes M N i:ℝ) = (N:ℝ) := by
+    exact_mod_cast (by simpa only [Fin.sum_univ_eq_sum_range] using
+      Obligations045.M0.allocation_sum M.base N)
+  calc
+    _ = ∑ i : Fin M.base.K, (sizes M N i:ℝ)*varianceLower M := by
+      rw [← Finset.sum_mul, hsum]
+    _ ≤ _ := by
+      apply Finset.sum_le_sum
+      intro i _
+      simpa only [mul_assoc] using mul_le_mul_of_nonneg_left
+        (bernoulli_variance_lower M A B i) (Nat.cast_nonneg (sizes M N i))
+
+theorem variance_atTop (M : Model) (A : Ancestors M) (B : Leaves M) :
+    Tendsto (variance M A B) atTop atTop := by
+  apply tendsto_atTop_mono (fun N => finite_variance_lower M A B N)
+  exact tendsto_natCast_atTop_atTop.atTop_mul_const (variance_lower_pos M)
+
+theorem mean_rounding_bound (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) :
+    |mean M A B N-(N:ℝ)*score M A B| ≤ (M.base.K:ℝ) := by
+  have heq : mean M A B N-(N:ℝ)*score M A B =
+      ∑ i : Fin M.base.K, ((sizes M N i:ℝ)-(N:ℝ)*M.base.w i)*q M A B 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.base.K, |((sizes M N i:ℝ)-(N:ℝ)*M.base.w i)*q M A B i| :=
+      Finset.abs_sum_le_sum_abs _ _
+    _ ≤ ∑ _i : Fin M.base.K, (1:ℝ) := by
+      apply Finset.sum_le_sum
+      intro i _
+      rw [abs_mul, abs_of_nonneg (q_bounds M A B i).1]
+      have hdis : |(sizes M N i:ℝ)-(N:ℝ)*M.base.w i| ≤ 1 :=
+        abs_le.mpr ⟨(Obligations045.M0.allocation_discrepancy M.base N i).1.le,
+          (Obligations045.M0.allocation_discrepancy M.base N i).2.le⟩
+      exact (mul_le_mul_of_nonneg_right hdis (q_bounds M A B i).1).trans
+        (by simpa using (q_bounds M A B i).2)
+    _ = _ := by simp
+
+theorem diagonal_drift_squared_limit (M : Model) (A : Ancestors M) (B : Leaves M)
+    (hdiag : score M A B=(1:ℝ)/2) :
+    Tendsto (fun N : ℕ => (mean M A B N-(N:ℝ)/2)^2/variance M A B N)
+      atTop (𝓝 0) := by
+  have hupper : Tendsto (fun N : ℕ => (M.base.K:ℝ)^2/variance M A B N) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop (variance_atTop M A B)
+  apply tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds hupper
+  · filter_upwards [(variance_atTop M A B).eventually (eventually_ge_atTop 1)] with N hN
+    exact div_nonneg (sq_nonneg _) (by linarith)
+  · filter_upwards [(variance_atTop M A B).eventually (eventually_ge_atTop 1)] with N hN
+    apply div_le_div_of_nonneg_right _ (by linarith)
+    have habs := mean_rounding_bound M A B N
+    rw [hdiag, mul_one_div] at habs
+    nlinarith [sq_abs (mean M A B N-(N:ℝ)/2), abs_nonneg (mean M A B N-(N:ℝ)/2)]
+
+def sigma (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) : ℝ :=
+  Real.sqrt (variance M A B N)
+def threshold (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) : ℝ :=
+  ((N:ℝ)/2-mean M A B N)/sigma M A B N
+
+theorem sigma_pos (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) (hN : 0<N) :
+    0 < sigma M A B N := by
+  apply Real.sqrt_pos.2
+  exact lt_of_lt_of_le (mul_pos (by exact_mod_cast hN) (variance_lower_pos M))
+    (finite_variance_lower M A B N)
+
+theorem threshold_limit (M : Model) (A : Ancestors M) (B : Leaves M)
+    (hdiag : score M A B=(1:ℝ)/2) : Tendsto (threshold M A B) atTop (𝓝 0) := by
+  have h := (diagonal_drift_squared_limit M A B hdiag).sqrt
+  apply (tendsto_zero_iff_norm_tendsto_zero).mpr
+  simpa only [threshold, sigma, Real.norm_eq_abs, abs_div,
+    abs_of_nonneg (Real.sqrt_nonneg _), abs_sub_comm,
+    Real.sqrt_div (sq_nonneg _), Real.sqrt_sq_eq_abs, Real.sqrt_zero] using h
+
+def lindebergRatio (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) (eps : ℝ) : ℝ :=
+  (∑ i : Fin M.base.K, (sizes M N i:ℝ)*Obligations046.Lindeberg.bernoulliTail
+    (q M A B i) (eps^2*variance M A B N))/variance M A B N
+
+theorem lindeberg_eventually_zero (M : Model) (A : Ancestors M) (B : Leaves M)
+    (eps : ℝ) (he : 0<eps) : ∀ᶠ N in atTop, lindebergRatio M A B N eps=0 := by
+  have hv := (variance_atTop M A B).eventually (eventually_ge_atTop (1/eps^2))
+  filter_upwards [hv] with N hN
+  have hc : 1 ≤ eps^2*variance M A B N := by
+    simpa only [mul_comm] using (div_le_iff₀ (sq_pos_of_pos he)).mp hN
+  have hz (i : Fin M.base.K) := Obligations046.Lindeberg.bernoulli_tail_zero
+    (q M A B i) _ (q_bounds M A B i).1 (q_bounds M A B i).2 hc
+  simp only [lindebergRatio, hz, mul_zero, Finset.sum_const_zero, zero_div]
+
+theorem lindeberg_limit (M : Model) (A : Ancestors M) (B : Leaves M)
+    (eps : ℝ) (he : 0<eps) :
+    Tendsto (fun N => lindebergRatio M A B N eps) atTop (𝓝 0) := by
+  have hEq : (fun N => lindebergRatio M A B N eps) =ᶠ[atTop] (fun _ => 0) :=
+    lindeberg_eventually_zero M A B eps he
+  exact tendsto_const_nhds.congr' hEq.symm
+
+/-- Genuine diagonal region: exact at everyN, without any CLT assumption. -/
+theorem unbiased_conditional_exact (M : Model) (A : Ancestors M) (B : Leaves M)
+    (hunbiased : ∀ i, q M A B i=(1:ℝ)/2) (N : ℕ) :
+    binomialError M N A B=(1:ℝ)/2 := by
+  let f : World (sizes M N) → ℝ := fun x =>
+    jointMass (sizes M N) (fun _ => (1/2:ℝ)) x * Obligations045.M0.fairLoss (correctCount x) N
+  have hq : q M A B=(fun _ => (1:ℝ)/2) := funext hunbiased
+  have hrep : binomialError M N A B=∑ x, f x := by
+    rw [conditional_member_error]
+    simp only [f, weights, hq]
+  have hsym : ∑ x, f (Obligations046.Diagonal.complement x)=∑ x, f x :=
+    Fintype.sum_bijective Obligations046.Diagonal.complement
+      ⟨fun x y h => by simpa only [Obligations046.Diagonal.complement_involutive]
+          using congrArg Obligations046.Diagonal.complement h,
+       fun x => ⟨Obligations046.Diagonal.complement x,
+         Obligations046.Diagonal.complement_involutive x⟩⟩ _ _ (fun _ => rfl)
+  have hpair : ∀ x, f (Obligations046.Diagonal.complement x)+f x=
+      jointMass (sizes M N) (fun _ => (1/2:ℝ)) x := by
+    intro x
+    simp only [f, Obligations046.Diagonal.unbiased_joint_complement, ← mul_add]
+    rw [Obligations046.Diagonal.fair_loss_reflection _ _ _
+      (Obligations046.Diagonal.count_complement M.base N x), mul_one]
+  have htotal : (∑ x, f (Obligations046.Diagonal.complement x))+(∑ x, f x)=1 := by
+    rw [← Finset.sum_add_distrib]
+    simp only [hpair]
+    exact jointMass_sum _ _
+  rw [hrep]
+  linarith
+
+theorem unbiased_score (M : Model) (A : Ancestors M) (B : Leaves M)
+    (hunbiased : ∀ i, q M A B i=(1:ℝ)/2) : score M A B=(1:ℝ)/2 := by
+  have hs : ∑ i : Fin M.base.K, M.base.w i=1 := by
+    simpa only [Fin.sum_univ_eq_sum_range] using M.base.weights_sum
+  simp only [score, hunbiased, ← Finset.sum_mul, hs, one_mul]
+
+theorem conditional_limit_offdiag_or_unbiased (M : Model) (A : Ancestors M) (B : Leaves M)
+    (hregion : score M A B ≠ (1:ℝ)/2 ∨ ∀ i, q M A B i=(1:ℝ)/2) :
+    Tendsto (fun N => binomialError M N A B) atTop
+      (𝓝 (Obligations045.M0.limitingLoss (score M A B))) := by
+  rcases hregion with h | h
+  · exact conditional_offdiag_limit M A B h
+  · rw [unbiased_score M A B h]
+    norm_num [Obligations045.M0.limitingLoss]
+    simpa only [unbiased_conditional_exact M A B h] using
+      (tendsto_const_nhds : Tendsto (fun _ : ℕ => (1:ℝ)/2) atTop (𝓝 ((1:ℝ)/2)))
+
+/-- Full mixture may contain genuinely diagonal states, provided every such state
+is in the proved unbiased subdomain. Heterogeneous diagonal is NOT assumed solved. -/
+theorem implementation_limit_offdiag_or_unbiased (M : Model)
+    (hregions : ∀ (A : Ancestors M) (B : Leaves M),
+      score M A B ≠ (1:ℝ)/2 ∨ ∀ i, q M A B i=(1:ℝ)/2) :
+    Tendsto (implementationError M) atTop (𝓝 (thresholdFunctional M)) := by
+  unfold implementationError thresholdFunctional
+  apply tendsto_finset_sum
+  intro A _
+  apply tendsto_finset_sum
+  intro B _
+  exact tendsto_const_nhds.mul (conditional_limit_offdiag_or_unbiased M A B (hregions A B))
+
+theorem generator_limit_offdiag_or_unbiased (M : Model)
+    (hregions : ∀ (A : Ancestors M) (B : Leaves M),
+      score M A B ≠ (1:ℝ)/2 ∨ ∀ i, q M A B i=(1:ℝ)/2) :
+    Tendsto (fun N : ℕ => ∫ x, Obligations045.M0.fairLoss
+      (∑ i, (primitiveCounts M N x.1.1 x.1.2 x.2 i:ℕ)) N ∂(fullLaw M N).toMeasure)
+      atTop (𝓝 (thresholdFunctional M)) := by
+  simpa only [full_generator_error_bridge] using implementation_limit_offdiag_or_unbiased M hregions
+
+/-- Finite CDF under the declared conditional product-member law. -/
+def cdf (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) (z : ℝ) : ℝ :=
+  ∑ x : members M N, weights M A B N x*
+    (if ((correctCount x:ℝ)-mean M A B N)/sigma M A B N ≤ z then (1:ℝ) else 0)
+
+def primitiveCdf (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) (z : ℝ) : ℝ :=
+  ∫ x, (if (((∑ i, (primitiveCounts M N A B x i:ℕ)):ℝ)-mean M A B N)/sigma M A B N ≤ z
+    then (1:ℝ) else 0) ∂(primitiveLaw M N).toMeasure
+
+theorem primitive_cdf_eq (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) (z : ℝ) :
+    primitiveCdf M A B N z=cdf M A B N z := by
+  let f : (∀ i : Fin M.base.K, Fin (sizes M N i+1)) → ℝ := fun k =>
+    if (((∑ i, (k i:ℕ)):ℝ)-mean M A B N)/sigma M A B N ≤ z then 1 else 0
+  change (∫ x, f (primitiveCounts M N A B x) ∂(primitiveLaw M N).toMeasure)=_
+  rw [primitive_law_count_expectation M N A B f]
+  symm
+  simpa only [cdf, weights, correctCount, count, f, Nat.cast_sum] using
+    joint_count_pushforward (sizes M N) (q M A B) f
+
+theorem lower_cut (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) (hN : 0<N)
+    (z : ℝ) (hz : z<threshold M A B N) : cdf M A B N z ≤ binomialError M N A B := by
+  rw [conditional_member_error]
+  apply Finset.sum_le_sum
+  intro x _
+  exact mul_le_mul_of_nonneg_left
+    (Obligations046.Threshold.lower_cut_pointwise _ _ _ _ _ (sigma_pos M A B N hN) hz)
+    (weights_nonneg M A B N x)
+
+theorem upper_cut (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) (hN : 0<N)
+    (z : ℝ) (hz : threshold M A B N<z) : binomialError M N A B ≤ cdf M A B N z := by
+  rw [conditional_member_error]
+  apply Finset.sum_le_sum
+  intro x _
+  exact mul_le_mul_of_nonneg_left
+    (Obligations046.Threshold.upper_cut_pointwise _ _ _ _ _ (sigma_pos M A B N hN) hz)
+    (weights_nonneg M A B N x)
+
+/-- CONDITIONAL transfer only. The fixed-cut CDF limit hCLT is an explicit
+unpaid hypothesis; Lindeberg vanishing is not silently used as a CLT theorem. -/
+theorem diagonal_transfer_of_fixed_cut_limits (M : Model) (A : Ancestors M) (B : Leaves M)
+    (hdiag : score M A B=(1:ℝ)/2) (F : ℝ→ℝ) (hF : ContinuousAt F 0)
+    (hCLT : ∀ z, Tendsto (fun N => primitiveCdf M A B N z) atTop (𝓝 (F z))) :
+    Tendsto (fun N => binomialError M N A B) atTop (𝓝 (F 0)) := by
+  apply Obligations046.Threshold.moving_cut_sandwich (cdf M A B) F (threshold M A B)
+    (fun N => binomialError M N A B) hF
+    (fun z => by simpa only [primitive_cdf_eq] using hCLT z) (threshold_limit M A B hdiag)
+  · filter_upwards [eventually_ge_atTop 1] with N hN
+    exact lower_cut M A B N (by omega)
+  · filter_upwards [eventually_ge_atTop 1] with N hN
+    exact upper_cut M A B N (by omega)
+
+/-- A two-level model with a genuine positive-mass diagonal latent state. -/
+def exampleModel : Model where
+  base := {
+    K := 1
+    K_pos := by norm_num
+    p := 3/4
+    c := 1/5
+    p_half := by norm_num
+    p_lt_one := by norm_num
+    c_nonneg := by norm_num
+    c_lt_one := by norm_num
+    w := fun _ => 1
+    w_nonneg := fun _ => by norm_num
+    weights_sum := by norm_num [Finset.sum_range_succ] }
+  ancestors := 1
+  parent := fun _ => 0
+  c2 := 1/6
+  c2_nonneg := by norm_num
+  c2_lt_one := by norm_num
+
+/-- All four latent states: one unbiased diagonal, three off-diagonal. -/
+theorem example_regions (A : Ancestors exampleModel) (B : Leaves exampleModel) :
+    score exampleModel A B ≠ (1:ℝ)/2 ∨ ∀ i, q exampleModel A B i=(1:ℝ)/2 := by
+  change (∑ i : Fin 1, (1:ℝ)*success (3/4) (1/5) (1/6) (A (0:Fin 1)) (B i)) ≠ 1/2 ∨
+    ∀ i : Fin 1, success (3/4) (1/5) (1/6) (A (0:Fin 1)) (B i)=1/2
+  cases ha : A (0:Fin 1) <;> cases hb : B (0:Fin 1)
+  · right
+    intro i
+    have hi : i=(0:Fin 1) := Fin.eq_zero i
+    subst i
+    norm_num [success, ha, hb]
+  all_goals
+    left
+    norm_num [success, Fin.sum_univ_succ, ha, hb]
+
+theorem example_generator_limit :
+    Tendsto (fun N : ℕ => ∫ x, Obligations045.M0.fairLoss
+      (∑ i, (primitiveCounts exampleModel N x.1.1 x.1.2 x.2 i:ℕ)) N
+      ∂(fullLaw exampleModel N).toMeasure) atTop (𝓝 (thresholdFunctional exampleModel)) :=
+  generator_limit_offdiag_or_unbiased exampleModel example_regions
+
+/-- Enumerate functions on one named origin, without a finite-grid assumption on probabilities. -/
+theorem sum_one_bit (f : (Fin 1→Bool)→ℝ) :
+    (∑ a : Fin 1→Bool, f a)=f (fun _ => false)+f (fun _ => true) := by
+  have hbij : Function.Bijective (fun a : Fin 1→Bool => a 0) := by
+    constructor
+    · intro a b hab
+      funext i
+      rw [Fin.eq_zero i]
+      exact hab
+    · intro b
+      exact ⟨fun _ => b, rfl⟩
+  have h := Fintype.sum_bijective (fun a : Fin 1→Bool => a 0) hbij f
+    (fun b => f (fun _ => b)) (fun a => congrArg f (funext (fun i => congrArg a (Fin.eq_zero i))))
+  simpa only [Fintype.sum_bool, add_comm] using h
+
+theorem example_threshold_exact : thresholdFunctional exampleModel=(1:ℝ)/32 := by
+  change (∑ A : Fin 1→Bool, ∑ B : Fin 1→Bool,
+    ((∏ g : Fin 1, bernMass (3/4) (A g))*(∏ i : Fin 1, bernMass (3/4) (B i)))*
+      Obligations045.M0.limitingLoss (∑ i : Fin 1,
+        (1:ℝ)*success (3/4) (1/5) (1/6) (A (0:Fin 1)) (B i))) = 1/32
+  rw [sum_one_bit]
+  simp only [sum_one_bit]
+  norm_num [Fin.sum_univ_succ, Fin.prod_univ_succ, bernMass, success, Obligations045.M0.limitingLoss]
+
+theorem example_generator_limit_exact :
+    Tendsto (fun N : ℕ => ∫ x, Obligations045.M0.fairLoss
+      (∑ i, (primitiveCounts exampleModel N x.1.1 x.1.2 x.2 i:ℕ)) N
+      ∂(fullLaw exampleModel N).toMeasure) atTop (𝓝 ((1:ℝ)/32)) := by
+  simpa only [example_threshold_exact] using example_generator_limit
+
+end Obligations046.M1Diagonal

package/proofs/m1-046-diagonal/M1Offdiag046.lean

@@ -0,0 +1,270 @@
+import M1Bridge046
+import M0Moments046
+
+open scoped BigOperators
+open Filter Topology MeasureTheory ProbabilityTheory
+noncomputable section
+open Classical Obligations046.M1Bridge Obligations046.Bridge
+namespace Obligations046.M1Offdiag
+
+/-- Actual finite conditional mean and variance; no convergence premise. -/
+def mean (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) : ℝ :=
+  ∑ i : Fin M.base.K, (sizes M N i : ℝ)*q M A B i
+def variance (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) : ℝ :=
+  ∑ i : Fin M.base.K, (sizes M N i : ℝ)*q M A B i*(1-q M A B i)
+def score (M : Model) (A : Ancestors M) (B : Leaves M) : ℝ :=
+  ∑ i : Fin M.base.K, M.base.w i*q M A B i
+
+theorem q_bounds (M : Model) (A : Ancestors M) (B : Leaves M) (i : Fin M.base.K) :
+    0 ≤ q M A B i ∧ q M A B i ≤ 1 := by
+  have hn (e : Fin 4) : 0 ≤ branchMass M.base.p M.base.c M.c2 e :=
+    branch_nonneg _ _ _ (by linarith [M.base.p_half]) M.base.p_lt_one.le
+      M.base.c_nonneg M.base.c_lt_one.le M.c2_nonneg M.c2_lt_one.le e
+  have ht : 0 ≤ ∑ e : Fin 4, if branchBit (A (M.parent i)) (B i) e = true
+      then branchMass M.base.p M.base.c M.c2 e else 0 := by
+    apply Finset.sum_nonneg
+    intro e _
+    split_ifs
+    · exact hn e
+    · exact le_rfl
+  have hf : 0 ≤ ∑ e : Fin 4, if branchBit (A (M.parent i)) (B i) e = false
+      then branchMass M.base.p M.base.c M.c2 e else 0 := by
+    apply Finset.sum_nonneg
+    intro e _
+    split_ifs
+    · exact hn e
+    · exact le_rfl
+  rw [branch_bit_fiber] at ht hf
+  change 0 ≤ q M A B i at ht
+  change 0 ≤ 1-q M A B i at hf
+  exact ⟨ht, by linarith⟩
+
+theorem mean_ratio_limit (M : Model) (A : Ancestors M) (B : Leaves M) :
+    Tendsto (fun N : ℕ => mean M A B N/(N:ℝ)) atTop (𝓝 (score M A B)) := by
+  have h := tendsto_finset_sum Finset.univ (fun (i : Fin M.base.K) _ =>
+    (Obligations045.M0.allocation_ratio M.base i).mul_const (q M A B i))
+  convert h using 1
+  funext N
+  simp only [mean, score, Finset.sum_div, div_mul_eq_mul_div]
+
+theorem variance_le (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) :
+    variance M A B N ≤ (N:ℝ)/4 := by
+  have hs : ∑ i : Fin M.base.K, (sizes M N i : ℝ) = (N:ℝ) := by
+    exact_mod_cast (by simpa only [Fin.sum_univ_eq_sum_range] using
+      Obligations045.M0.allocation_sum M.base N)
+  calc
+    _ ≤ ∑ i : Fin M.base.K, (sizes M N i : ℝ)*(1/4) := by
+      apply Finset.sum_le_sum
+      intro i _
+      have h : q M A B i*(1-q M A B i) ≤ 1/4 := by
+        nlinarith [sq_nonneg (q M A B i-1/2)]
+      simpa only [mul_assoc] using mul_le_mul_of_nonneg_left h (Nat.cast_nonneg (sizes M N i))
+    _ = _ := by rw [← Finset.sum_mul, hs]; ring
+
+/-- Off-diagonal loss is locally constant; only a squared deviation can change it. -/
+theorem loss_left_bound (x m eps : ℝ) (he : 0 < eps) (hm : m+eps ≤ 1/2) :
+    |Obligations045.M0.limitingLoss x-1| ≤ (x-m)^2/eps^2 := by
+  by_cases hx : x < (1:ℝ)/2
+  · simp only [Obligations045.M0.limitingLoss, if_pos hx, sub_self, abs_zero]
+    positivity
+  · have hx' : (1:ℝ)/2 ≤ x := le_of_not_gt hx
+    have hd : eps^2 ≤ (x-m)^2 := by
+      nlinarith [sq_nonneg (x-m-eps)]
+    have hu : (1:ℝ) ≤ (x-m)^2/eps^2 := by
+      exact (le_div_iff₀ (sq_pos_of_pos he)).mpr (by simpa using hd)
+    have hb : |Obligations045.M0.limitingLoss x-1| ≤ 1 := by
+      unfold Obligations045.M0.limitingLoss
+      split_ifs <;> norm_num [abs_div]
+    exact hb.trans hu
+
+theorem loss_right_bound (x m eps : ℝ) (he : 0 < eps) (hm : 1/2 ≤ m-eps) :
+    |Obligations045.M0.limitingLoss x| ≤ (x-m)^2/eps^2 := by
+  by_cases hx : (1:ℝ)/2 < x
+  · have hn : ¬ x < (1:ℝ)/2 := not_lt.mpr hx.le
+    simp only [Obligations045.M0.limitingLoss, if_neg hn, if_neg (Ne.symm hx.ne), abs_zero]
+    positivity
+  · have hx' : x ≤ (1:ℝ)/2 := le_of_not_gt hx
+    have hd : eps^2 ≤ (x-m)^2 := by
+      nlinarith [sq_nonneg (m-x-eps)]
+    have hu : (1:ℝ) ≤ (x-m)^2/eps^2 := by
+      exact (le_div_iff₀ (sq_pos_of_pos he)).mpr (by simpa using hd)
+    have hb : |Obligations045.M0.limitingLoss x| ≤ 1 := by
+      unfold Obligations045.M0.limitingLoss
+      split_ifs <;> norm_num [abs_div]
+    exact hb.trans hu
+
+abbrev members (M : Model) (N : ℕ) := World (sizes M N)
+def weights (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ)
+    (x : members M N) := jointMass (sizes M N) (q M A B) x
+
+theorem weights_nonneg (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ)
+    (x : members M N) : 0 ≤ weights M A B N x := by
+  unfold weights jointMass
+  exact Finset.prod_nonneg (fun i _ => mass_nonneg _ (q_bounds M A B i).1
+    (q_bounds M A B i).2 (x i))
+
+theorem weights_sum (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) :
+    ∑ x : members M N, weights M A B N x = 1 := jointMass_sum _ _
+
+theorem conditional_member_error (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) :
+    binomialError M N A B = ∑ x : members M N, weights M A B N x*
+      Obligations045.M0.fairLoss (correctCount x) N := by
+  symm
+  simpa only [weights, binomialError, correctCount, count] using
+    joint_count_pushforward (sizes M N) (q M A B)
+      (fun k => Obligations045.M0.fairLoss (∑ i, (k i : ℕ)) N)
+
+theorem centered_second (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ) :
+    (∑ x : members M N, weights M A B N x*((correctCount x:ℝ)-mean M A B N)^2) =
+      variance M A B N := by
+  have h := Obligations046.Moments.member_total_centered_second (sizes M N) (q M A B)
+    (fun i => (q_bounds M A B i).1) (fun i => (q_bounds M A B i).2)
+  rw [memberLaw_expectation] at h
+  exact h
+
+/-- A direct finite Chebyshev bound. The test function is bounded POINTWISE; no
+independence between pair scores, ambient process, CLT or limit is assumed. -/
+theorem conditional_gap_bound (M : Model) (A : Ancestors M) (B : Leaves M) (N : ℕ)
+    (hN : 0 < N) (eps target : ℝ) (he : 0 < eps)
+    (hpoint : ∀ x : ℝ, |Obligations045.M0.limitingLoss x-target| ≤
+      (x-mean M A B N/(N:ℝ))^2/eps^2) :
+    |binomialError M N A B-target| ≤ 1/(4*(N:ℝ)*eps^2) := by
+  have hn : (0:ℝ) < N := by exact_mod_cast hN
+  have hd : 0 < (N:ℝ)^2*eps^2 := by positivity
+  have hnorm := weights_sum M A B N
+  have hrew : binomialError M N A B-target =
+      ∑ x : members M N, weights M A B N x*(Obligations045.M0.fairLoss (correctCount x) N-target) := by
+    rw [conditional_member_error]
+    simp only [mul_sub, Finset.sum_sub_distrib, ← Finset.sum_mul, hnorm, one_mul]
+  rw [hrew]
+  calc
+    _ ≤ ∑ x : members M N, |weights M A B N x*
+        (Obligations045.M0.fairLoss (correctCount x) N-target)| := Finset.abs_sum_le_sum_abs _ _
+    _ = ∑ x : members M N, weights M A B N x*
+        |Obligations045.M0.fairLoss (correctCount x) N-target| := by
+      apply Finset.sum_congr rfl
+      intro x _
+      rw [abs_mul, abs_of_nonneg (weights_nonneg M A B N x)]
+    _ ≤ ∑ x : members M N, weights M A B N x*
+        (((correctCount x:ℝ)-mean M A B N)^2/((N:ℝ)^2*eps^2)) := by
+      apply Finset.sum_le_sum
+      intro x _
+      apply mul_le_mul_of_nonneg_left _ (weights_nonneg M A B N x)
+      rw [fair_loss_average_bridge _ _ hN]
+      have h := hpoint ((correctCount x:ℝ)/(N:ℝ))
+      convert h using 1
+      field_simp
+    _ = variance M A B N/((N:ℝ)^2*eps^2) := by
+      simp_rw [← mul_div_assoc]
+      rw [← Finset.sum_div, centered_second]
+    _ ≤ ((N:ℝ)/4)/((N:ℝ)^2*eps^2) :=
+      div_le_div_of_nonneg_right (variance_le M A B N) hd.le
+    _ = _ := by field_simp; ring
+
+/-- This positive O(1/N) bound tends to zero with epsilon FIXED. -/
+theorem tail_bound_limit (eps : ℝ) :
+    Tendsto (fun N : ℕ => 1/(4*(N:ℝ)*eps^2)) atTop (𝓝 0) := by
+  have h : Tendsto (fun N : ℕ => (1:ℝ)/(N:ℝ)) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop tendsto_natCast_atTop_atTop
+  have heq : (fun N : ℕ => 1/(4*(N:ℝ)*eps^2)) =
+      (fun N : ℕ => ((1:ℝ)/(N:ℝ))/(4*eps^2)) := by funext N; ring
+  rw [heq]
+  simpa using h.div_const (4*eps^2)
+
+/-- New finite M1 conditional probability limit, derived from quota convergence
+and the finite generator/binomial law; no convergence premise or ambient iid oracle. -/
+theorem conditional_offdiag_limit (M : Model) (A : Ancestors M) (B : Leaves M)
+    (hoff : score M A B ≠ (1:ℝ)/2) :
+    Tendsto (fun N : ℕ => binomialError M N A B) atTop
+      (𝓝 (Obligations045.M0.limitingLoss (score M A B))) := by
+  by_cases hs : score M A B < (1:ℝ)/2
+  · let eps : ℝ := (1/2-score M A B)/2
+    have he : 0 < eps := by dsimp [eps]; linarith
+    have hm : ∀ᶠ N in atTop, mean M A B N/(N:ℝ)+eps ≤ (1:ℝ)/2 := by
+      have h := (mean_ratio_limit M A B).eventually
+        (Iio_mem_nhds (show score M A B < (1:ℝ)/2-eps by dsimp [eps]; linarith))
+      filter_upwards [h] with N hN
+      linarith
+    have hb : ∀ᶠ N in atTop, |binomialError M N A B-1| ≤ 1/(4*(N:ℝ)*eps^2) := by
+      filter_upwards [hm, eventually_ge_atTop 1] with N hm hN
+      exact conditional_gap_bound M A B N (by omega) eps 1 he
+        (fun x => loss_left_bound x _ eps he hm)
+    have h := squeeze_zero' (Eventually.of_forall (fun N => abs_nonneg (binomialError M N A B-1))) hb
+      (tail_bound_limit eps)
+    rw [Obligations045.M0.limitingLoss, if_pos hs]
+    exact (tendsto_iff_norm_sub_tendsto_zero).mpr (by simpa only [Real.norm_eq_abs] using h)
+  · have hs' : (1:ℝ)/2 < score M A B := lt_of_le_of_ne (le_of_not_gt hs) (Ne.symm hoff)
+    let eps : ℝ := (score M A B-1/2)/2
+    have he : 0 < eps := by dsimp [eps]; linarith
+    have hm : ∀ᶠ N in atTop, (1:ℝ)/2 ≤ mean M A B N/(N:ℝ)-eps := by
+      have h := (mean_ratio_limit M A B).eventually
+        (Ioi_mem_nhds (show (1:ℝ)/2+eps < score M A B by dsimp [eps]; linarith))
+      filter_upwards [h] with N hN
+      linarith
+    have hb : ∀ᶠ N in atTop, |binomialError M N A B| ≤ 1/(4*(N:ℝ)*eps^2) := by
+      filter_upwards [hm, eventually_ge_atTop 1] with N hm hN
+      simpa only [sub_zero] using conditional_gap_bound M A B N (by omega) eps 0 he
+        (fun x => by simpa only [sub_zero] using loss_right_bound x _ eps he hm)
+    have h := squeeze_zero' (Eventually.of_forall (fun N => abs_nonneg (binomialError M N A B))) hb
+      (tail_bound_limit eps)
+    rw [Obligations045.M0.limitingLoss, if_neg hs, if_neg hoff]
+    exact (tendsto_iff_norm_sub_tendsto_zero).mpr (by simpa only [Real.norm_eq_abs, sub_zero] using h)
+
+def thresholdFunctional (M : Model) : ℝ :=
+  ∑ A : Ancestors M, ∑ B : Leaves M,
+    latentMass M A B * Obligations045.M0.limitingLoss (score M A B)
+
+/-- All latent configurations are positive mass forp in(1/2,1). No diagonal
+configuration is silently discarded or called a fork. -/
+theorem implementation_offdiag_limit (M : Model)
+    (hoff : ∀ (A : Ancestors M) (B : Leaves M), score M A B ≠ (1:ℝ)/2) :
+    Tendsto (implementationError M) atTop (𝓝 (thresholdFunctional M)) := by
+  unfold implementationError thresholdFunctional
+  apply tendsto_finset_sum
+  intro A _
+  apply tendsto_finset_sum
+  intro B _
+  exact tendsto_const_nhds.mul (conditional_offdiag_limit M A B (hoff A B))
+
+/-- Limit of the ACTUAL full generator probabilities via the admitted exact bridge. -/
+theorem generator_offdiag_limit (M : Model)
+    (hoff : ∀ (A : Ancestors M) (B : Leaves M), score M A B ≠ (1:ℝ)/2) :
+    Tendsto (fun N : ℕ => ∫ x, Obligations045.M0.fairLoss
+      (∑ i, (primitiveCounts M N x.1.1 x.1.2 x.2 i : ℕ)) N ∂(fullLaw M N).toMeasure)
+      atTop (𝓝 (thresholdFunctional M)) := by
+  simpa only [full_generator_error_bridge] using implementation_offdiag_limit M hoff
+
+/-- The existing exact shared-parent example: genuinely nonzero rates on both levels. -/
+def exampleModel : Model where
+  base := {
+    K := 2
+    K_pos := by norm_num
+    p := 2/3
+    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 _ => 1/2
+    w_nonneg := fun _ => by norm_num
+    weights_sum := by norm_num [Finset.sum_range_succ] }
+  ancestors := 1
+  parent := fun _ => 0
+  c2 := 1/2
+  c2_nonneg := by norm_num
+  c2_lt_one := by norm_num
+
+theorem example_offdiag (A : Ancestors exampleModel) (B : Leaves exampleModel) :
+    score exampleModel A B ≠ (1:ℝ)/2 := by
+  change (∑ i : Fin 2, (1/2:ℝ)*success (2/3) (1/2) (1/2) (A (0:Fin 1)) (B i)) ≠ 1/2
+  cases ha : A (0:Fin 1) <;> cases hb : B (0:Fin 2) <;> cases hc : B (1:Fin 2) <;>
+    norm_num [success, Fin.sum_univ_succ, ha, hb, hc]
+
+theorem example_generator_limit :
+    Tendsto (fun N : ℕ => ∫ x, Obligations045.M0.fairLoss
+      (∑ i, (primitiveCounts exampleModel N x.1.1 x.1.2 x.2 i : ℕ)) N
+      ∂(fullLaw exampleModel N).toMeasure)
+      atTop (𝓝 (thresholdFunctional exampleModel)) :=
+  generator_offdiag_limit exampleModel example_offdiag
+
+end Obligations046.M1Offdiag