math / data /lean /OAI /Probability /RandomSAT /Interpolation.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
19.4 kB
import OAI.Probability.RandomSAT.CenterBounds
namespace OAI
/-!
Auxiliary ordered clauses allow repeated variables. Commuting finite averaging
operators give the fixed-count partition interpolation corresponding to the
marked-Poisson comparison.
-/
namespace FixedClauseThreshold
open Finset
noncomputable section
attribute [local instance] Classical.propDecidable
abbrev AuxiliaryClause (n k : β„•) := Fin k β†’ (Fin n Γ— Bool)
def auxiliarySatisfies {n k : β„•} (Οƒ : Assignment n) (C : AuxiliaryClause n k) : Prop :=
βˆƒ j, Οƒ (C j).1 = (C j).2
def finiteClauseAverage {n : β„•} {C : Type*} [Fintype C]
(sat : C β†’ Assignment n β†’ Prop) (f : Finset (Assignment n) β†’ ℝ)
(S : Finset (Assignment n)) : ℝ := uniformMean (fun c => f (S.filter (sat c)))
theorem finiteClauseAverage_mono {n : β„•} {C : Type*} [Fintype C]
(sat : C β†’ Assignment n β†’ Prop) {f g : Finset (Assignment n) β†’ ℝ}
(hfg : βˆ€ S, f S ≀ g S) : βˆ€ S, finiteClauseAverage sat f S ≀ finiteClauseAverage sat g S := by
intro S
exact uniformMean_mono (fun c => hfg _)
theorem finiteClauseAverage_add {n : β„•} {C : Type*} [Fintype C]
(sat : C β†’ Assignment n β†’ Prop) (f g : Finset (Assignment n) β†’ ℝ) :
finiteClauseAverage sat (fun S => f S + g S) =
(fun S => finiteClauseAverage sat f S + finiteClauseAverage sat g S) := by
funext S
exact uniformMean_add _ _
theorem finiteClauseAverage_const_mul {n : β„•} {C : Type*} [Fintype C]
(sat : C β†’ Assignment n β†’ Prop) (f : Finset (Assignment n) β†’ ℝ) (c : ℝ) :
finiteClauseAverage sat (fun S => c * f S) = (fun S => c * finiteClauseAverage sat f S) := by
funext S
exact uniformMean_const_mul _ _
theorem finiteClauseAverage_mul_const {n : β„•} {C : Type*} [Fintype C]
(sat : C β†’ Assignment n β†’ Prop) (f : Finset (Assignment n) β†’ ℝ) (c : ℝ) :
finiteClauseAverage sat (fun S => f S * c) = (fun S => finiteClauseAverage sat f S * c) := by
funext S
exact uniformMean_mul_const _ _
theorem finiteClauseAverage_commute {n : β„•} {C D : Type*} [Fintype C] [Fintype D]
(satC : C β†’ Assignment n β†’ Prop) (satD : D β†’ Assignment n β†’ Prop) :
Function.Commute (finiteClauseAverage satC) (finiteClauseAverage satD) := by
intro f
funext S
unfold finiteClauseAverage
rw [uniformMean_comm]
apply uniformMean_congr
intro d
apply uniformMean_congr
intro c
congr 1
ext Οƒ
simp only [Finset.mem_filter]
tauto
theorem finiteClauseAverage_binomialMean {n : β„•} {C : Type*} [Fintype C]
(sat : C β†’ Assignment n β†’ Prop) (p : ℝ) (m : β„•)
(f : β„• β†’ Finset (Assignment n) β†’ ℝ) :
finiteClauseAverage sat (fun S => binomialMean p m (fun j => f j S)) =
(fun S => binomialMean p m (fun j => finiteClauseAverage sat (f j) S)) := by
funext S
exact uniformMean_binomialMean _ _ _
theorem iterate_compare_of_commute {X : Type*}
(A B : (X β†’ ℝ) β†’ (X β†’ ℝ)) (hA : Monotone A) (hB : Monotone B)
(hcomm : Function.Commute A B) {f : X β†’ ℝ} (hf : B f ≀ A f) (m : β„•) :
B^[m] f ≀ A^[m] f := by
induction m with
| zero => exact le_rfl
| succ m ih =>
rw [Function.iterate_succ_apply', Function.iterate_succ_apply']
calc
B (B^[m] f) ≀ B (A^[m] f) := hB ih
_ = A^[m] (B f) := (hcomm.symm.iterate_right m f)
_ ≀ A^[m] (A f) := hA.iterate m hf
_ = A (A^[m] f) := (Function.iterate_succ_apply A m f).symm.trans
(Function.iterate_succ_apply' A m f)
def mixedAverage {X : Type*} (p : ℝ) (A B : (X β†’ ℝ) β†’ (X β†’ ℝ))
(f : X β†’ ℝ) : X β†’ ℝ := fun S => (1 - p) * B f S + p * A f S
theorem mixedAverage_mono {X : Type*} {p : ℝ} (hp0 : 0 ≀ p) (hp1 : p ≀ 1)
{A B : (X β†’ ℝ) β†’ (X β†’ ℝ)} (hA : Monotone A) (hB : Monotone B) :
Monotone (mixedAverage p A B) := by
intro f g hfg S
exact add_le_add (mul_le_mul_of_nonneg_left (hB hfg S) (sub_nonneg.mpr hp1))
(mul_le_mul_of_nonneg_left (hA hfg S) hp0)
theorem finiteClauseAverage_commute_mix {n : β„•} {C D E : Type*}
[Fintype C] [Fintype D] [Fintype E] (satC : C β†’ Assignment n β†’ Prop)
(satD : D β†’ Assignment n β†’ Prop) (satE : E β†’ Assignment n β†’ Prop) (p : ℝ) :
Function.Commute (finiteClauseAverage satC)
(mixedAverage p (finiteClauseAverage satD) (finiteClauseAverage satE)) := by
intro f
unfold mixedAverage
rw [finiteClauseAverage_add, finiteClauseAverage_const_mul, finiteClauseAverage_const_mul,
finiteClauseAverage_commute satC satD f, finiteClauseAverage_commute satC satE f]
def embedAuxiliaryClause {n v k : β„•} (e : Fin v β†’ Fin n) (C : AuxiliaryClause v k) :
AuxiliaryClause n k := fun j => (e (C j).1, (C j).2)
def embeddedAverage {n v : β„•} (e : Fin v β†’ Fin n) (k : β„•) :
(Finset (Assignment n) β†’ ℝ) β†’ (Finset (Assignment n) β†’ ℝ) :=
finiteClauseAverage (fun C : AuxiliaryClause v k => fun Οƒ => auxiliarySatisfies Οƒ (embedAuxiliaryClause e C))
def auxiliaryAverage {n : β„•} (k : β„•) :
(Finset (Assignment n) β†’ ℝ) β†’ (Finset (Assignment n) β†’ ℝ) :=
embeddedAverage (id : Fin n β†’ Fin n) k
def auxiliarySurvival {n : β„•} (k m : β„•) (S : Finset (Assignment n)) : ℝ :=
((auxiliaryAverage k)^[m] alive) S
def auxiliaryProbability (n k m : β„•) : ℝ :=
auxiliarySurvival k m (Finset.univ : Finset (Assignment n))
def embeddedForced {n v : β„•} (S : Finset (Assignment n)) (e : Fin v β†’ Fin n) : Finset (Fin v) :=
Finset.univ.filter (fun i => e i ∈ forcedVariables S)
@[simp] theorem mem_embeddedForced {n v : β„•} (S : Finset (Assignment n)) (e : Fin v β†’ Fin n) (i : Fin v) :
i ∈ embeddedForced S e ↔ e i ∈ forcedVariables S := by simp [embeddedForced]
@[simp] theorem embeddedForced_id {n : β„•} (S : Finset (Assignment n)) :
embeddedForced S (id : Fin n β†’ Fin n) = forcedVariables S := by ext i; simp
theorem opposing_literal_iff {n v : β„•} (S : Finset (Assignment n)) (e : Fin v β†’ Fin n)
(Οƒβ‚€ : Assignment n) (hΟƒβ‚€ : Οƒβ‚€ ∈ S) (l : Fin v Γ— Bool) :
(βˆ€ Οƒ ∈ S, Οƒ (e l.1) β‰  l.2) ↔
l.1 ∈ embeddedForced S e ∧ l.2 = !(Οƒβ‚€ (e l.1)) := by
rw [mem_embeddedForced, forcedVariables_eq_frozen hσ₀]
simp only [frozenCoordinates, Finset.mem_filter, Finset.mem_univ, true_and]
constructor
Β· intro h
have h0 := h σ₀ hσ₀
constructor
· intro σ hσ
have hs := h σ hσ
cases h1 : Οƒ (e l.1) <;> cases h2 : Οƒβ‚€ (e l.1) <;> cases h3 : l.2 <;> simp_all
Β· cases h2 : Οƒβ‚€ (e l.1) <;> cases h3 : l.2 <;> simp_all
Β· rintro ⟨h, hb⟩ Οƒ hΟƒ
rw [h σ hσ, hb]
cases Οƒβ‚€ (e l.1) <;> decide
theorem opposing_literal_probability {n v : β„•} (S : Finset (Assignment n))
(e : Fin v β†’ Fin n) (hS : S.Nonempty) :
uniformProbability (fun l : Fin v Γ— Bool => βˆ€ Οƒ ∈ S, Οƒ (e l.1) β‰  l.2) =
((embeddedForced S e).card : ℝ) / (2 * v) := by
obtain βŸ¨Οƒβ‚€, hΟƒβ‚€βŸ© := hS
let eqv : {l : Fin v Γ— Bool // βˆ€ Οƒ ∈ S, Οƒ (e l.1) β‰  l.2} ≃ β†₯(embeddedForced S e) := {
toFun := fun l => ⟨l.val.1, ((opposing_literal_iff S e Οƒβ‚€ hΟƒβ‚€ l.val).mp l.property).1⟩
invFun := fun i => ⟨(i.val, !(Οƒβ‚€ (e i.val))),
(opposing_literal_iff S e Οƒβ‚€ hΟƒβ‚€ _).mpr ⟨i.property, rfl⟩⟩
left_inv := fun l => by
apply Subtype.ext
change (l.val.1, !(Οƒβ‚€ (e l.val.1))) = l.val
apply Prod.ext
Β· rfl
· exact ((opposing_literal_iff S e σ₀ hσ₀ l.val).mp l.property).2.symm
right_inv := fun _ => rfl }
unfold uniformProbability
simp only [← Nat.card_eq_fintype_card]
rw [Nat.card_congr eqv]
simp only [Nat.card_eq_fintype_card, Fintype.card_coe, Fintype.card_prod,
Fintype.card_fin, Fintype.card_bool, Nat.cast_mul, Nat.cast_ofNat]
rw [mul_comm (v : ℝ) 2]
theorem embedded_kill_probability {n v k : β„•} (S : Finset (Assignment n))
(e : Fin v β†’ Fin n) (hS : S.Nonempty) :
uniformProbability (fun C : AuxiliaryClause v k =>
Β¬ (S.filter fun Οƒ => auxiliarySatisfies Οƒ (embedAuxiliaryClause e C)).Nonempty) =
(((embeddedForced S e).card : ℝ) / (2 * v))^k := by
calc
_ = uniformProbability (fun C : AuxiliaryClause v k =>
βˆ€ j, βˆ€ Οƒ ∈ S, Οƒ (e (C j).1) β‰  (C j).2) := by
apply uniformProbability_congr
intro C
constructor
· intro h j σ hσ heq
apply h
exact βŸ¨Οƒ, Finset.mem_filter.mpr ⟨hΟƒ, ⟨j, heq⟩⟩⟩
Β· intro h βŸ¨Οƒ, hΟƒβŸ©
obtain ⟨hΟƒ, j, hj⟩ := Finset.mem_filter.mp hΟƒ
exact h j σ hσ hj
_ = _ := by
change (uniformProbability (fun C : Fin k β†’ Fin v Γ— Bool =>
βˆ€ j, (fun l : Fin v Γ— Bool => βˆ€ Οƒ ∈ S, Οƒ (e l.1) β‰  l.2) (C j))) = _
have hf := uniformProbability_forall_fintype (Ξ± := Fin v Γ— Bool) (Ξ² := Fin k)
(fun l => βˆ€ Οƒ ∈ S, Οƒ (e l.1) β‰  l.2)
simpa only [Fintype.card_fin, opposing_literal_probability S e hS] using hf
theorem embeddedAverage_alive {n v k : β„•} (hv : 0 < v) (e : Fin v β†’ Fin n)
(S : Finset (Assignment n)) :
embeddedAverage e k alive S = alive S *
(1 - (((embeddedForced S e).card : ℝ) / (2 * v))^k) := by
let : NeZero v := ⟨Nat.ne_of_gt hv⟩
by_cases hS : S.Nonempty
Β· have ha : alive S = 1 := by simp [alive, hS]
rw [ha, one_mul]
have h := uniformProbability_not (fun C : AuxiliaryClause v k =>
(S.filter fun Οƒ => auxiliarySatisfies Οƒ (embedAuxiliaryClause e C)).Nonempty)
rw [embedded_kill_probability S e hS] at h
have he : embeddedAverage e k alive S = uniformProbability (fun C : AuxiliaryClause v k =>
(S.filter fun Οƒ => auxiliarySatisfies Οƒ (embedAuxiliaryClause e C)).Nonempty) := by
rw [uniformProbability_eq_mean]
unfold embeddedAverage finiteClauseAverage
apply uniformMean_congr
intro C
by_cases hC : (S.filter fun Οƒ => auxiliarySatisfies Οƒ (embedAuxiliaryClause e C)).Nonempty
Β· simp only [alive, ite_eq_left hC]
Β· simp only [alive, ite_eq_right hC]
rw [he]
linarith
Β· have he : S = βˆ… := Finset.not_nonempty_iff_eq_empty.mp hS
subst S
simp [embeddedAverage, finiteClauseAverage, alive_empty, uniformMean_zero]
theorem auxiliaryAverage_alive {n k : β„•} (hn : 0 < n) (S : Finset (Assignment n)) :
auxiliaryAverage k alive S = alive S * (1 - (forcedFraction S / 2)^k) := by
rw [auxiliaryAverage, embeddedAverage_alive hn, embeddedForced_id]
congr 2
unfold forcedFraction
ring
theorem forced_card_partition {r s : β„•} (S : Finset (Assignment (r + s))) :
(forcedVariables S).card = (embeddedForced S (Fin.castAdd s)).card +
(embeddedForced S (Fin.natAdd r)).card := by
have h := Fin.sum_univ_add (fun i : Fin (r + s) =>
if i ∈ forcedVariables S then (1 : β„•) else 0)
simpa only [← Finset.sum_filter, Finset.sum_const, smul_eq_mul, mul_one,
Finset.filter_mem_eq_inter, Finset.univ_inter, embeddedForced] using h
theorem partition_kill_convex {r s k : β„•} (hr : 0 < r) (hs : 0 < s)
(S : Finset (Assignment (r + s))) :
(forcedFraction S / 2)^k ≀
((r : ℝ) / (r + s)) * (((embeddedForced S (Fin.castAdd s)).card : ℝ) / (2 * r))^k +
((s : ℝ) / (r + s)) * (((embeddedForced S (Fin.natAdd r)).card : ℝ) / (2 * s))^k := by
have hr' : (0 : ℝ) < r := by exact_mod_cast hr
have hs' : (0 : ℝ) < s := by exact_mod_cast hs
have hsum : (r : ℝ) / (r + s) + (s : ℝ) / (r + s) = 1 := by field_simp
have h := (convexOn_pow (π•œ := ℝ) k).2
(show ((embeddedForced S (Fin.castAdd s)).card : ℝ) / (2 * r) ∈ Set.Ici (0 : ℝ) by simp only [Set.mem_Ici]; positivity)
(show ((embeddedForced S (Fin.natAdd r)).card : ℝ) / (2 * s) ∈ Set.Ici (0 : ℝ) by simp only [Set.mem_Ici]; positivity)
(show 0 ≀ (r : ℝ) / (r + s) by positivity)
(show 0 ≀ (s : ℝ) / (r + s) by positivity) hsum
simp only [smul_eq_mul] at h
convert h using 1
congr 1
unfold forcedFraction
rw [forced_card_partition, Nat.cast_add, Nat.cast_add]
field_simp
theorem globalAverage_ge_local {r s k : β„•} (hr : 0 < r) (hs : 0 < s) :
mixedAverage ((r : ℝ) / (r + s)) (embeddedAverage (Fin.castAdd s) k)
(embeddedAverage (Fin.natAdd r) k) alive ≀ auxiliaryAverage k alive := by
intro S
have hr' : (0 : ℝ) < r := by exact_mod_cast hr
have hs' : (0 : ℝ) < s := by exact_mod_cast hs
have hw : 1 - (r : ℝ) / (r + s) = (s : ℝ) / (r + s) := by field_simp; ring
unfold mixedAverage
rw [embeddedAverage_alive hr, embeddedAverage_alive hs, auxiliaryAverage_alive (by omega), hw]
have h := mul_le_mul_of_nonneg_left (partition_kill_convex (k := k) hr hs S) (alive_nonneg S)
have hsum : (r : ℝ) / (r + s) + (s : ℝ) / (r + s) = 1 := by field_simp
have hsum_mul := congrArg (fun x : ℝ => alive S * x) hsum
nlinarith
theorem mixed_finiteAverage_iterate {n : β„•} {C D : Type*} [Fintype C] [Fintype D]
(satC : C β†’ Assignment n β†’ Prop) (satD : D β†’ Assignment n β†’ Prop)
(p : ℝ) (m : β„•) (f : Finset (Assignment n) β†’ ℝ) :
(mixedAverage p (finiteClauseAverage satC) (finiteClauseAverage satD))^[m] f =
(fun S => binomialMean p m (fun j =>
((finiteClauseAverage satC)^[j] ((finiteClauseAverage satD)^[m - j] f)) S)) := by
induction m with
| zero => simp [binomialMean]
| succ m ih =>
rw [Function.iterate_succ_apply', ih]
unfold mixedAverage
rw [finiteClauseAverage_binomialMean, finiteClauseAverage_binomialMean]
funext S
rw [binomialMean]
congr 1
Β· congr 1
apply binomialMean_congr
intro j hj
rw [(finiteClauseAverage_commute satD satC).iterate_right j,
← Function.iterate_succ_apply' (finiteClauseAverage satD) (m - j) f]
rw [show (m - j).succ = m.succ - j by omega]
Β· congr 1
apply binomialMean_congr
intro j hj
rw [← Function.iterate_succ_apply' (finiteClauseAverage satC) j]
simp only [Nat.add_sub_add_right]
def blockSet {r s : β„•} (S : Finset (Assignment r)) (T : Finset (Assignment s)) :
Finset (Assignment (r + s)) :=
Finset.univ.filter (fun Οƒ => (fun i => Οƒ (Fin.castAdd s i)) ∈ S ∧
(fun i => Οƒ (Fin.natAdd r i)) ∈ T)
@[simp] theorem mem_blockSet {r s : β„•} (S : Finset (Assignment r)) (T : Finset (Assignment s))
(Οƒ : Assignment (r + s)) : Οƒ ∈ blockSet S T ↔
(fun i => Οƒ (Fin.castAdd s i)) ∈ S ∧ (fun i => Οƒ (Fin.natAdd r i)) ∈ T := by
simp [blockSet]
@[simp] theorem blockSet_univ (r s : β„•) :
blockSet (Finset.univ : Finset (Assignment r)) (Finset.univ : Finset (Assignment s)) =
Finset.univ := by ext Οƒ; simp
theorem blockSet_nonempty {r s : β„•} (S : Finset (Assignment r)) (T : Finset (Assignment s)) :
(blockSet S T).Nonempty ↔ S.Nonempty ∧ T.Nonempty := by
constructor
Β· rintro βŸ¨Οƒ, hΟƒβŸ©
have h := (mem_blockSet S T σ).mp hσ
exact ⟨⟨_, h.1⟩, ⟨_, h.2⟩⟩
Β· rintro βŸ¨βŸ¨Οƒ, hΟƒβŸ©, βŸ¨Ο„, hΟ„βŸ©βŸ©
refine ⟨Fin.addCases Οƒ Ο„, ?_⟩
simpa only [mem_blockSet, Fin.addCases_left, Fin.addCases_right] using And.intro hσ hτ
theorem alive_blockSet {r s : β„•} (S : Finset (Assignment r)) (T : Finset (Assignment s)) :
alive (blockSet S T) = alive S * alive T := by
simp only [alive, blockSet_nonempty]
split_ifs <;> simp_all
theorem filter_blockSet_left {r s k : β„•} (S : Finset (Assignment r))
(T : Finset (Assignment s)) (C : AuxiliaryClause r k) :
(blockSet S T).filter (fun Οƒ => auxiliarySatisfies Οƒ (embedAuxiliaryClause (Fin.castAdd s) C)) =
blockSet (S.filter (fun Οƒ => auxiliarySatisfies Οƒ C)) T := by
ext Οƒ
constructor
Β· intro h
obtain ⟨hΟƒ, hC⟩ := Finset.mem_filter.mp h
obtain ⟨hS, hT⟩ := (mem_blockSet S T Οƒ).mp hΟƒ
exact (mem_blockSet _ _ Οƒ).mpr ⟨Finset.mem_filter.mpr ⟨hS, hC⟩, hT⟩
Β· intro h
obtain ⟨hS, hT⟩ := (mem_blockSet _ _ Οƒ).mp h
obtain ⟨hS, hC⟩ := Finset.mem_filter.mp hS
exact Finset.mem_filter.mpr ⟨(mem_blockSet S T Οƒ).mpr ⟨hS, hT⟩, hC⟩
theorem filter_blockSet_right {r s k : β„•} (S : Finset (Assignment r))
(T : Finset (Assignment s)) (C : AuxiliaryClause s k) :
(blockSet S T).filter (fun Οƒ => auxiliarySatisfies Οƒ (embedAuxiliaryClause (Fin.natAdd r) C)) =
blockSet S (T.filter (fun Οƒ => auxiliarySatisfies Οƒ C)) := by
ext Οƒ
constructor
Β· intro h
obtain ⟨hΟƒ, hC⟩ := Finset.mem_filter.mp h
obtain ⟨hS, hT⟩ := (mem_blockSet S T Οƒ).mp hΟƒ
exact (mem_blockSet _ _ Οƒ).mpr ⟨hS, Finset.mem_filter.mpr ⟨hT, hC⟩⟩
Β· intro h
obtain ⟨hS, hT⟩ := (mem_blockSet _ _ Οƒ).mp h
obtain ⟨hT, hC⟩ := Finset.mem_filter.mp hT
exact Finset.mem_filter.mpr ⟨(mem_blockSet S T Οƒ).mpr ⟨hS, hT⟩, hC⟩
theorem auxiliarySurvival_succ {n k m : β„•} (S : Finset (Assignment n)) :
auxiliarySurvival k (m + 1) S = uniformMean (fun C : AuxiliaryClause n k =>
auxiliarySurvival k m (S.filter (fun Οƒ => auxiliarySatisfies Οƒ C))) := by
unfold auxiliarySurvival
rw [Function.iterate_succ_apply']
rfl
theorem local_iterates_block {r s k : β„•} (j l : β„•) (S : Finset (Assignment r))
(T : Finset (Assignment s)) :
((embeddedAverage (Fin.castAdd s) k)^[j]
((embeddedAverage (Fin.natAdd r) k)^[l] alive)) (blockSet S T) =
auxiliarySurvival k j S * auxiliarySurvival k l T := by
induction j generalizing S T with
| zero =>
simp only [Function.iterate_zero, id_eq]
change _ = alive S * auxiliarySurvival k l T
induction l generalizing T with
| zero => exact alive_blockSet S T
| succ l ih =>
rw [Function.iterate_succ_apply', auxiliarySurvival_succ, ← uniformMean_const_mul]
unfold embeddedAverage finiteClauseAverage
apply uniformMean_congr
intro C
rw [filter_blockSet_right]
exact ih _
| succ j ih =>
rw [Function.iterate_succ_apply', auxiliarySurvival_succ, ← uniformMean_mul_const]
unfold embeddedAverage finiteClauseAverage
apply uniformMean_congr
intro C
rw [filter_blockSet_left]
exact ih _ _
theorem auxiliary_interpolation {r s k : β„•} (hr : 0 < r) (hs : 0 < s) (m : β„•) :
binomialMean ((r : ℝ) / (r + s)) m (fun j =>
auxiliaryProbability r k j * auxiliaryProbability s k (m - j)) ≀
auxiliaryProbability (r + s) k m := by
have hp0 : 0 ≀ (r : ℝ) / (r + s) := by positivity
have hp1 : (r : ℝ) / (r + s) ≀ 1 := by
apply (div_le_one (by positivity : (0 : ℝ) < r + s)).mpr
exact le_add_of_nonneg_right (Nat.cast_nonneg s)
have h := iterate_compare_of_commute (auxiliaryAverage (n := r + s) k)
(mixedAverage ((r : ℝ) / (r + s)) (embeddedAverage (Fin.castAdd s) k)
(embeddedAverage (Fin.natAdd r) k))
(fun _ _ h => finiteClauseAverage_mono _ h) (mixedAverage_mono hp0 hp1
(fun _ _ h => finiteClauseAverage_mono _ h) (fun _ _ h => finiteClauseAverage_mono _ h))
(finiteClauseAverage_commute_mix _ _ _ _) (globalAverage_ge_local hr hs) m Finset.univ
change _ ≀ auxiliaryProbability (r + s) k m at h
convert h using 1
unfold embeddedAverage
rw [mixed_finiteAverage_iterate]
apply binomialMean_congr
intro j hj
change _ = ((embeddedAverage (Fin.castAdd s) k)^[j]
((embeddedAverage (Fin.natAdd r) k)^[m - j] alive)) Finset.univ
rw [← blockSet_univ r s, local_iterates_block]
rfl
end
end FixedClauseThreshold
end OAI