@lapxo/obligations 0.4.4 → 0.4.6

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

package/proofs/m1-046-offdiag/M1Bridge046.lean

@@ -0,0 +1,359 @@
+import M0Bridge
+
+open scoped BigOperators
+open MeasureTheory ProbabilityTheory
+noncomputable section
+open Classical
+namespace Obligations046.M1Bridge
+open Obligations046.Bridge
+
+/-- Four EXCLUSIVE outcomes of the sequential ancestor-first generator.
+Fresh success/failure are distinct elementary outcomes, not a count-law premise. -/
+def branchMass (p c1 c2 : ℝ) (e : Fin 4) : ℝ :=
+  if e = 0 then c1 else if e = 1 then (1-c1)*c2
+  else if e = 2 then (1-c1)*(1-c2)*p else (1-c1)*(1-c2)*(1-p)
+def branchBit (A B : Bool) (e : Fin 4) : Bool :=
+  if e = 0 then A else if e = 1 then B else decide (e = 2)
+def success (p c1 c2 : ℝ) (A B : Bool) : ℝ :=
+  c1*(if A then 1 else 0)+(1-c1)*c2*(if B then 1 else 0)+(1-c1)*(1-c2)*p
+
+theorem branch_normalized (p c1 c2 : ℝ) : ∑ e : Fin 4, branchMass p c1 c2 e = 1 := by
+  simp [Fin.sum_univ_succ, branchMass]
+  ring
+
+theorem branch_nonneg (p c1 c2 : ℝ) (hp : 0 ≤ p) (hp1 : p ≤ 1)
+    (hc1 : 0 ≤ c1) (hc1' : c1 ≤ 1) (hc2 : 0 ≤ c2) (hc2' : c2 ≤ 1)
+    (e : Fin 4) : 0 ≤ branchMass p c1 c2 e := by
+  have h1 : 0 ≤ 1-c1 := sub_nonneg.mpr hc1'
+  have h2 : 0 ≤ 1-c2 := sub_nonneg.mpr hc2'
+  have h3 : 0 ≤ 1-p := sub_nonneg.mpr hp1
+  unfold branchMass
+  split_ifs <;> positivity
+
+theorem branch_bit_fiber (p c1 c2 : ℝ) (A B z : Bool) :
+    (∑ e : Fin 4, if branchBit A B e = z then branchMass p c1 c2 e else 0) =
+      if z then success p c1 c2 A B else 1-success p c1 c2 A B := by
+  cases A <;> cases B <;> cases z <;>
+    simp [Fin.sum_univ_succ, branchBit, branchMass, success] <;> ring
+
+/-- Bijection between raw named binary member outcomes and subsets, independent of probabilities. -/
+def subsetBits (n : ℕ) : Finset (Fin n) ≃ (Fin n → Bool) where
+  toFun s j := decide (j ∈ s)
+  invFun z := Finset.univ.filter (fun j => z j)
+  left_inv s := by ext j; simp
+  right_inv z := by funext j; simp
+
+def memberSubset {n : ℕ} (A B : Bool) (x : Fin n → Fin 4) : Finset (Fin n) :=
+  Finset.univ.filter (fun j => branchBit A B (x j))
+
+theorem selector_to_member (p c1 c2 : ℝ) (A B : Bool) (n : ℕ)
+    (f : Finset (Fin n) → ℝ) :
+    (∑ x : Fin n → Fin 4, (∏ j, branchMass p c1 c2 (x j))*f (memberSubset A B x)) =
+      ∑ s : Finset (Fin n), mass (success p c1 c2 A B) s*f s := by
+  have h := product_pushforward (fun (_j : Fin n) e => branchMass p c1 c2 e)
+    (fun _ e => branchBit A B e) (fun z => f ((subsetBits n).symm z))
+  simp only [branch_bit_fiber] at h
+  change _ = _ at h
+  calc
+    _ = ∑ z : Fin n → Bool,
+        (∏ j, if z j then success p c1 c2 A B else 1-success p c1 c2 A B)*
+          f ((subsetBits n).symm z) := by simpa [memberSubset, subsetBits] using h
+    _ = ∑ s : Finset (Fin n), mass (success p c1 c2 A B) s*f s := by
+      rw [← (subsetBits n).sum_comp]
+      apply Finset.sum_congr rfl
+      intro s _
+      simp only [Equiv.symm_apply_apply]
+      rw [mass_eq_individual_product]
+      simp [subsetBits]
+
+/-- Push forward literal independent selectors to every joint lineage COUNT event. -/
+theorem selector_count_fiber (p c1 c2 : ℝ) (A B : Bool) (n : ℕ) (k : Fin (n+1)) :
+    (∑ x : Fin n → Fin 4,
+      if count (memberSubset A B x) = k then ∏ j, branchMass p c1 c2 (x j) else 0) =
+      binMass (success p c1 c2 A B) n k := by
+  have h := selector_to_member p c1 c2 A B n (fun s => if count s = k then 1 else 0)
+  simpa only [mul_ite, mul_one, mul_zero, count_fiber_mass] using h
+
+/-- p and weights/quota domain are exactly the existing M0 domain; c is c1 here.
+The additional conditional child rate and named parent map are new model parameters. -/
+structure Model where
+  base : Obligations045.M0.Domain
+  ancestors : ℕ
+  parent : Fin base.K → Fin ancestors
+  c2 : ℝ
+  c2_nonneg : 0 ≤ c2
+  c2_lt_one : c2 < 1
+
+abbrev sizes (M : Model) (N : ℕ) (i : Fin M.base.K) :=
+  Obligations045.M0.allocation M.base.w N i
+abbrev Ancestors (M : Model) := Fin M.ancestors → Bool
+abbrev Leaves (M : Model) := Fin M.base.K → Bool
+abbrev Raw (M : Model) (N : ℕ) := ∀ i : Fin M.base.K, Fin (sizes M N i) → Fin 4
+
+def q (M : Model) (A : Ancestors M) (B : Leaves M) (i : Fin M.base.K) : ℝ :=
+  success M.base.p M.base.c M.c2 (A (M.parent i)) (B i)
+def rawMass (M : Model) (N : ℕ) (x : Raw M N) : ℝ :=
+  ∏ i, ∏ j, branchMass M.base.p M.base.c M.c2 (x i j)
+def counts (M : Model) (N : ℕ) (A : Ancestors M) (B : Leaves M) (x : Raw M N) :=
+  fun i => count (memberSubset (A (M.parent i)) (B i) (x i))
+
+theorem rawMass_normalized (M : Model) (N : ℕ) : ∑ x : Raw M N, rawMass M N x = 1 := by
+  calc
+    _ = ∏ i : Fin M.base.K, ∑ x : Fin (sizes M N i) → Fin 4,
+        ∏ j, branchMass M.base.p M.base.c M.c2 (x j) :=
+      (Fintype.prod_sum (fun i (x : Fin (sizes M N i) → Fin 4) =>
+        ∏ j, branchMass M.base.p M.base.c M.c2 (x j))).symm
+    _ = 1 := by
+      apply Finset.prod_eq_one
+      intro i _
+      rw [← Fintype.prod_sum (fun (_j : Fin (sizes M N i)) e => branchMass M.base.p M.base.c M.c2 e)]
+      simp only [branch_normalized, Finset.prod_const_one]
+
+theorem rawMass_nonneg (M : Model) (N : ℕ) (x : Raw M N) : 0 ≤ rawMass M N x := by
+  apply Finset.prod_nonneg
+  intro i _
+  apply Finset.prod_nonneg
+  intro j _
+  exact 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 _
+
+/-- Full finite expectation bridge: no binomial count premise, limit premise or CLT. -/
+theorem generator_to_binomial (M : Model) (N : ℕ) (A : Ancestors M) (B : Leaves M)
+    (f : (∀ i : Fin M.base.K, Fin (sizes M N i+1)) → ℝ) :
+    (∑ x : Raw M N, rawMass M N x*f (counts M N A B x)) =
+      ∑ k : ∀ i : Fin M.base.K, Fin (sizes M N i+1),
+        (∏ i, binMass (q M A B i) (sizes M N i) (k i))*f k := by
+  have h := product_pushforward
+    (fun i (x : Fin (sizes M N i) → Fin 4) => ∏ j, branchMass M.base.p M.base.c M.c2 (x j))
+    (fun i x => count (memberSubset (A (M.parent i)) (B i) x)) f
+  simpa only [selector_count_fiber, q, rawMass, counts] using h
+
+def rawError (M : Model) (N : ℕ) (A : Ancestors M) (B : Leaves M) : ℝ :=
+  ∑ x : Raw M N, rawMass M N x *
+    Obligations045.M0.fairLoss (∑ i, (counts M N A B x i : ℕ)) N
+
+def binomialError (M : Model) (N : ℕ) (A : Ancestors M) (B : Leaves M) : ℝ :=
+  ∑ k : ∀ i : Fin M.base.K, Fin (sizes M N i+1),
+    (∏ i, binMass (q M A B i) (sizes M N i) (k i))*
+      Obligations045.M0.fairLoss (∑ i, (k i : ℕ)) N
+
+theorem conditional_error_bridge (M : Model) (N : ℕ) (A : Ancestors M) (B : Leaves M) :
+    rawError M N A B = binomialError M N A B :=
+  by
+    simpa only [rawError, binomialError] using generator_to_binomial M N A B
+      (fun k => Obligations045.M0.fairLoss (∑ i, (k i : ℕ)) N)
+
+/-- Primitive jointly independent ancestor-selector, child-selector and fresh-vote bits.
+Unused primitive draws are retained in the world and summed out, not conditioned away. -/
+abbrev Primitive := Bool × Bool × Bool
+def bernMass (r : ℝ) (b : Bool) : ℝ := if b then r else 1-r
+def primitiveMass (p c1 c2 : ℝ) (t : Primitive) : ℝ :=
+  bernMass c1 t.1 * bernMass c2 t.2.1 * bernMass p t.2.2
+def primitiveBranch (t : Primitive) : Fin 4 :=
+  if t.1 then 0 else if t.2.1 then 1 else if t.2.2 then 2 else 3
+
+theorem primitive_branch_fiber (p c1 c2 : ℝ) (e : Fin 4) :
+    (∑ t : Primitive, if primitiveBranch t = e then primitiveMass p c1 c2 t else 0) =
+      branchMass p c1 c2 e := by
+  fin_cases e <;>
+    simp [Fintype.sum_prod_type, Fintype.sum_bool, primitiveBranch, primitiveMass, bernMass, branchMass] <;> ring
+
+theorem primitive_normalized (p c1 c2 : ℝ) : ∑ t : Primitive, primitiveMass p c1 c2 t = 1 := by
+  simp [Fintype.sum_prod_type, Fintype.sum_bool, primitiveMass, bernMass]
+  ring
+
+theorem primitive_output_is_sequential (A B : Bool) (t : Primitive) :
+    branchBit A B (primitiveBranch t) =
+      if t.1 then A else if t.2.1 then B else t.2.2 := by
+  rcases t with ⟨u,v,f⟩
+  cases u <;> cases v <;> cases f <;> rfl
+
+theorem primitive_member_pushforward (p c1 c2 : ℝ) (n : ℕ)
+    (f : (Fin n → Fin 4) → ℝ) :
+    (∑ t : Fin n → Primitive, (∏ j, primitiveMass p c1 c2 (t j))*
+      f (fun j => primitiveBranch (t j))) =
+      ∑ x : Fin n → Fin 4, (∏ j, branchMass p c1 c2 (x j))*f x := by
+  simpa only [primitive_branch_fiber] using product_pushforward
+    (fun (_j : Fin n) t => primitiveMass p c1 c2 t) (fun _ => primitiveBranch) f
+
+theorem primitive_count_fiber (p c1 c2 : ℝ) (A B : Bool) (n : ℕ) (k : Fin (n+1)) :
+    (∑ t : Fin n → Primitive,
+      if count (memberSubset A B (fun j => primitiveBranch (t j))) = k
+      then ∏ j, primitiveMass p c1 c2 (t j) else 0) =
+      binMass (success p c1 c2 A B) n k := by
+  have h := primitive_member_pushforward p c1 c2 n
+    (fun x => if count (memberSubset A B x) = k then 1 else 0)
+  simpa only [mul_ite, mul_one, mul_zero, selector_count_fiber] using h
+
+abbrev PrimitiveWorld (M : Model) (N : ℕ) :=
+  ∀ i : Fin M.base.K, Fin (sizes M N i) → Primitive
+def primitiveJointMass (M : Model) (N : ℕ) (x : PrimitiveWorld M N) : ℝ :=
+  ∏ i, ∏ j, primitiveMass M.base.p M.base.c M.c2 (x i j)
+def primitiveCounts (M : Model) (N : ℕ) (A : Ancestors M) (B : Leaves M)
+    (x : PrimitiveWorld M N) :=
+  fun i => count (memberSubset (A (M.parent i)) (B i) (fun j => primitiveBranch (x i j)))
+
+/-- The main bridge begins with the THREE INDEPENDENT PRIMITIVE BITS per named member,
+not assumed Bernoulli output bits or an assumed binomial count distribution. -/
+theorem primitive_generator_to_binomial (M : Model) (N : ℕ) (A : Ancestors M) (B : Leaves M)
+    (f : (∀ i : Fin M.base.K, Fin (sizes M N i+1)) → ℝ) :
+    (∑ x : PrimitiveWorld M N, primitiveJointMass M N x*f (primitiveCounts M N A B x)) =
+      ∑ k : ∀ i : Fin M.base.K, Fin (sizes M N i+1),
+        (∏ i, binMass (q M A B i) (sizes M N i) (k i))*f k := by
+  have h := product_pushforward
+    (fun i (x : Fin (sizes M N i) → Primitive) => ∏ j, primitiveMass M.base.p M.base.c M.c2 (x j))
+    (fun i x => count (memberSubset (A (M.parent i)) (B i) (fun j => primitiveBranch (x j)))) f
+  simpa only [primitive_count_fiber, primitiveJointMass, primitiveCounts, q] using h
+
+theorem bern_nonneg (r : ℝ) (hr : 0 ≤ r) (hr1 : r ≤ 1) (b : Bool) :
+    0 ≤ bernMass r b := by
+  cases b <;> simp only [bernMass, Bool.false_eq_true, ite_false, ite_true]
+  · exact sub_nonneg.mpr hr1
+  · exact hr
+
+theorem primitive_joint_nonneg (M : Model) (N : ℕ) (x : PrimitiveWorld M N) :
+    0 ≤ primitiveJointMass M N x := by
+  apply Finset.prod_nonneg
+  intro i _
+  apply Finset.prod_nonneg
+  intro j _
+  exact mul_nonneg
+    (mul_nonneg (bern_nonneg _ M.base.c_nonneg M.base.c_lt_one.le _)
+      (bern_nonneg _ M.c2_nonneg M.c2_lt_one.le _))
+    (bern_nonneg _ (by linarith [M.base.p_half]) M.base.p_lt_one.le _)
+
+theorem primitive_joint_normalized (M : Model) (N : ℕ) :
+    ∑ x : PrimitiveWorld M N, primitiveJointMass M N x = 1 := by
+  calc
+    _ = ∏ i : Fin M.base.K, ∑ x : Fin (sizes M N i) → Primitive,
+        ∏ j, primitiveMass M.base.p M.base.c M.c2 (x j) :=
+      (Fintype.prod_sum (fun i (x : Fin (sizes M N i) → Primitive) =>
+        ∏ j, primitiveMass M.base.p M.base.c M.c2 (x j))).symm
+    _ = 1 := by
+      apply Finset.prod_eq_one
+      intro i _
+      rw [← Fintype.prod_sum (fun (_j : Fin (sizes M N i)) t => primitiveMass M.base.p M.base.c M.c2 t)]
+      simp only [primitive_normalized, Finset.prod_const_one]
+
+instance primitiveMeasurableSpace (M : Model) (N : ℕ) :
+    MeasurableSpace (PrimitiveWorld M N) := ⊤
+instance primitiveDiscreteMeasurable (M : Model) (N : ℕ) :
+    DiscreteMeasurableSpace (PrimitiveWorld M N) := ⟨fun _ => trivial⟩
+
+/-- Genuine finite PMF on independent primitive bits; no binomial premise. -/
+def primitiveLaw (M : Model) (N : ℕ) : PMF (PrimitiveWorld M N) :=
+  PMF.ofFintype (fun x => ENNReal.ofReal (primitiveJointMass M N x)) (by
+    rw [← ENNReal.ofReal_sum_of_nonneg]
+    · simp [primitive_joint_normalized]
+    · intro x _
+      exact primitive_joint_nonneg M N x)
+
+theorem primitive_law_count_expectation (M : Model) (N : ℕ)
+    (A : Ancestors M) (B : Leaves M)
+    (f : (∀ i : Fin M.base.K, Fin (sizes M N i+1)) → ℝ) :
+    (∫ x, f (primitiveCounts M N A B x) ∂(primitiveLaw M N).toMeasure) =
+      ∑ k : ∀ i : Fin M.base.K, Fin (sizes M N i+1),
+        (∏ i, binMass (q M A B i) (sizes M N i) (k i))*f k := by
+  rw [PMF.integral_eq_sum]
+  calc
+    _ = ∑ x : PrimitiveWorld M N,
+        primitiveJointMass M N x*f (primitiveCounts M N A B x) := by
+      apply Finset.sum_congr rfl
+      intro x _
+      simp only [primitiveLaw, PMF.ofFintype_apply, smul_eq_mul]
+      rw [ENNReal.toReal_ofReal (primitive_joint_nonneg M N x)]
+    _ = _ := primitive_generator_to_binomial M N A B f
+
+theorem primitive_law_count_probability (M : Model) (N : ℕ)
+    (A : Ancestors M) (B : Leaves M) (k : ∀ i : Fin M.base.K, Fin (sizes M N i+1)) :
+    (∫ x, if primitiveCounts M N A B x = k then (1:ℝ) else 0
+      ∂(primitiveLaw M N).toMeasure) = ∏ i, binMass (q M A B i) (sizes M N i) (k i) := by
+  simpa using primitive_law_count_expectation M N A B (fun z => if z = k then (1:ℝ) else 0)
+
+theorem primitive_law_error_bridge (M : Model) (N : ℕ) (A : Ancestors M) (B : Leaves M) :
+    (∫ x, Obligations045.M0.fairLoss (∑ i, (primitiveCounts M N A B x i : ℕ)) N
+      ∂(primitiveLaw M N).toMeasure) = binomialError M N A B :=
+  by
+    simpa only [binomialError] using primitive_law_count_expectation M N A B
+      (fun k => Obligations045.M0.fairLoss (∑ i, (k i : ℕ)) N)
+
+def latentMass (M : Model) (A : Ancestors M) (B : Leaves M) : ℝ :=
+  (∏ g, bernMass M.base.p (A g))*(∏ i, bernMass M.base.p (B i))
+
+theorem latent_normalized (M : Model) :
+    ∑ A : Ancestors M, ∑ B : Leaves M, latentMass M A B = 1 := by
+  have ha : (∑ A : Ancestors M, ∏ g, bernMass M.base.p (A g)) = 1 := by
+    rw [← Fintype.prod_sum]
+    simp [Fintype.sum_bool, bernMass]
+  have hb : (∑ B : Leaves M, ∏ i, bernMass M.base.p (B i)) = 1 := by
+    rw [← Fintype.prod_sum]
+    simp [Fintype.sum_bool, bernMass]
+  simp only [latentMass, ← Finset.mul_sum, hb, mul_one, ha]
+
+theorem mixture_error_bridge (M : Model) (N : ℕ) :
+    (∑ A : Ancestors M, ∑ B : Leaves M, latentMass M A B *
+      ∫ x, Obligations045.M0.fairLoss (∑ i, (primitiveCounts M N A B x i : ℕ)) N
+        ∂(primitiveLaw M N).toMeasure) =
+      ∑ A : Ancestors M, ∑ B : Leaves M, latentMass M A B * binomialError M N A B := by
+  simp only [primitive_law_error_bridge]
+
+/-- Pure algebraic reduction only; no new limit or uncertainty certificate. -/
+theorem zero_ancestor_reduction (M : Model) (A : Ancestors M) (B : Leaves M)
+    (hc : M.base.c = 0) (i : Fin M.base.K) :
+    q M A B i = (1-M.c2)*M.base.p + if B i then M.c2 else 0 := by
+  cases h : B i <;> simp [q, success, hc, h, add_comm]
+
+theorem latent_nonneg (M : Model) (A : Ancestors M) (B : Leaves M) :
+    0 ≤ latentMass M A B := by
+  apply mul_nonneg <;> apply Finset.prod_nonneg <;> intro i _ <;>
+    exact bern_nonneg _ (by linarith [M.base.p_half]) M.base.p_lt_one.le _
+
+abbrev FullWorld (M : Model) (N : ℕ) := (Ancestors M × Leaves M) × PrimitiveWorld M N
+def fullMass (M : Model) (N : ℕ) (x : FullWorld M N) : ℝ :=
+  latentMass M x.1.1 x.1.2 * primitiveJointMass M N x.2
+
+theorem fullMass_nonneg (M : Model) (N : ℕ) (x : FullWorld M N) : 0 ≤ fullMass M N x :=
+  mul_nonneg (latent_nonneg M _ _) (primitive_joint_nonneg M N _)
+
+theorem fullMass_normalized (M : Model) (N : ℕ) : ∑ x : FullWorld M N, fullMass M N x = 1 := by
+  simp only [Fintype.sum_prod_type, fullMass, ← Finset.mul_sum,
+    primitive_joint_normalized, mul_one, latent_normalized]
+
+instance fullMeasurableSpace (M : Model) (N : ℕ) : MeasurableSpace (FullWorld M N) := ⊤
+instance fullDiscreteMeasurable (M : Model) (N : ℕ) :
+    DiscreteMeasurableSpace (FullWorld M N) := ⟨fun _ => trivial⟩
+
+/-- The COMPLETE finite generative law includes jointly independent latent bits
+and all independent selector/fresh primitive draws. -/
+def fullLaw (M : Model) (N : ℕ) : PMF (FullWorld M N) :=
+  PMF.ofFintype (fun x => ENNReal.ofReal (fullMass M N x)) (by
+    rw [← ENNReal.ofReal_sum_of_nonneg]
+    · simp [fullMass_normalized]
+    · intro x _
+      exact fullMass_nonneg M N x)
+
+def implementationError (M : Model) (N : ℕ) : ℝ :=
+  ∑ A : Ancestors M, ∑ B : Leaves M, latentMass M A B * binomialError M N A B
+
+/-- Complete generator–implementation bridge for every finiteN. No count distribution,
+error convergence, causal identification or oracle-free calibration is assumed. -/
+theorem full_generator_error_bridge (M : Model) (N : ℕ) :
+    (∫ x, Obligations045.M0.fairLoss
+      (∑ i, (primitiveCounts M N x.1.1 x.1.2 x.2 i : ℕ)) N ∂(fullLaw M N).toMeasure) =
+      implementationError M N := by
+  rw [PMF.integral_eq_sum]
+  have hp (x : FullWorld M N) : ((fullLaw M N) x).toReal = fullMass M N x := by
+    simp only [fullLaw, PMF.ofFintype_apply]
+    exact ENNReal.toReal_ofReal (fullMass_nonneg M N x)
+  simp_rw [smul_eq_mul, hp]
+  simp only [Fintype.sum_prod_type, implementationError, fullMass, mul_assoc]
+  apply Finset.sum_congr rfl
+  intro A _
+  apply Finset.sum_congr rfl
+  intro B _
+  rw [← Finset.mul_sum]
+  congr 1
+  simpa only [binomialError] using primitive_generator_to_binomial M N A B
+    (fun k => Obligations045.M0.fairLoss (∑ i, (k i : ℕ)) N)
+
+end Obligations046.M1Bridge