Download data/lean/OAI/Probability/RandomSAT/Interpolation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 19.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/RandomSAT/Interpolation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/RandomSAT/Interpolation.lean
-
curl -L -o Interpolation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/RandomSAT/Interpolation.lean
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 | |