Download data/lean/OAI/Probability/RandomSAT/Variance.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 22.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/RandomSAT/Variance.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/RandomSAT/Variance.lean
-
curl -L -o Variance.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/RandomSAT/Variance.lean
22.5 kB
| import OAI.Probability.RandomSAT.Forcing | |
| namespace OAI | |
| /-! | |
| Stopped satisfiable lifetimes, insertion delays, and the coordinate-omission | |
| variance bound in terms of integrated forcing. | |
| -/ | |
| namespace FixedClauseThreshold | |
| open Finset | |
| noncomputable section | |
| attribute [local instance] Classical.propDecidable | |
| theorem addClause_subset {n k : β} (S : Finset (Assignment n)) (C : ProperClause n k) : | |
| addClause S C β S := Finset.filter_subset _ _ | |
| theorem addClause_mono {n k : β} {S T : Finset (Assignment n)} (hST : S β T) | |
| (C : ProperClause n k) : addClause S C β addClause T C := by | |
| intro Ο hΟ | |
| rw [mem_addClause] at hΟ β’ | |
| exact β¨hST hΟ.1, hΟ.2β© | |
| @[simp] theorem addClause_empty {n k : β} (C : ProperClause n k) : | |
| addClause β C = β := by simp [addClause] | |
| @[simp] theorem alive_empty {n : β} : alive (β : Finset (Assignment n)) = 0 := by simp [alive] | |
| @[simp] theorem survival_empty {n k m : β} : survival k m (β : Finset (Assignment n)) = 0 := by | |
| rw [survival_eq_mean] | |
| have h (F : Formula n k m) : restrictSolutions β F = β := by simp [restrictSolutions] | |
| simp only [h, alive_empty, uniformMean_zero] | |
| def lifetime {n : β} (k : β) : (m : β) β Finset (Assignment n) β Formula n k m β β | |
| | 0, _, _ => 0 | |
| | m + 1, S, F => alive (addClause S (F 0)) + | |
| lifetime k m (addClause S (F 0)) (Fin.tail F) | |
| @[simp] theorem lifetime_zero {n k : β} (S : Finset (Assignment n)) (F : Formula n k 0) : | |
| lifetime k 0 S F = 0 := rfl | |
| @[simp] theorem lifetime_cons {n k m : β} (S : Finset (Assignment n)) (C : ProperClause n k) | |
| (F : Formula n k m) : lifetime k (m + 1) S (Fin.cons C F) = | |
| alive (addClause S C) + lifetime k m (addClause S C) F := rfl | |
| @[simp] theorem lifetime_empty {n k m : β} (F : Formula n k m) : lifetime k m β F = 0 := by | |
| induction m with | |
| | zero => rfl | |
| | succ m ih => simp [lifetime, ih] | |
| theorem lifetime_nonneg {n k m : β} (S : Finset (Assignment n)) (F : Formula n k m) : | |
| 0 β€ lifetime k m S F := by | |
| induction m generalizing S with | |
| | zero => exact le_rfl | |
| | succ m ih => exact add_nonneg (alive_nonneg _) (ih _ _) | |
| theorem lifetime_le {n k m : β} (S : Finset (Assignment n)) (F : Formula n k m) : | |
| lifetime k m S F β€ m := by | |
| induction m generalizing S with | |
| | zero => simp [lifetime] | |
| | succ m ih => | |
| simp only [lifetime, Nat.cast_add, Nat.cast_one] | |
| linarith [alive_le_one (addClause S (F 0)), ih (addClause S (F 0)) (Fin.tail F)] | |
| theorem lifetime_mono {n k m : β} {S T : Finset (Assignment n)} (hST : S β T) | |
| (F : Formula n k m) : lifetime k m S F β€ lifetime k m T F := by | |
| induction m generalizing S T with | |
| | zero => exact le_rfl | |
| | succ m ih => | |
| exact add_le_add (alive_mono (addClause_mono hST (F 0))) | |
| (ih (addClause_mono hST (F 0)) (Fin.tail F)) | |
| def lifetimeMean {n : β} (k m : β) (S : Finset (Assignment n)) : β := | |
| uniformMean (lifetime k m S) | |
| def lifetimeVariance {n : β} (k m : β) (S : Finset (Assignment n)) : β := | |
| uniformVariance (lifetime k m S) | |
| theorem lifetimeMean_succ {n k m : β} (hkn : k β€ n) (S : Finset (Assignment n)) : | |
| lifetimeMean k (m + 1) S = clauseAverage k (fun T => alive T + lifetimeMean k m T) S := by | |
| let : Nonempty (ProperClause n k) := nonempty_properClause hkn | |
| unfold lifetimeMean | |
| rw [uniformMean_fin_succ] | |
| simp only [lifetime_cons, uniformMean_add, uniformMean_const] | |
| simp only [clauseAverage, uniformMean_add] | |
| theorem clauseAverage_sum {n k : β} {ΞΉ : Type*} (s : Finset ΞΉ) | |
| (f : ΞΉ β Finset (Assignment n) β β) (S : Finset (Assignment n)) : | |
| clauseAverage k (fun T => β i β s, f i T) S = | |
| β i β s, clauseAverage k (f i) S := uniformMean_sum s _ | |
| theorem lifetimeMean_eq_sum {n k m : β} (hkn : k β€ n) (S : Finset (Assignment n)) : | |
| lifetimeMean k m S = β j β Finset.range m, survival k (j + 1) S := by | |
| induction m generalizing S with | |
| | zero => exact uniformMean_zero | |
| | succ m ih => | |
| rw [lifetimeMean_succ hkn] | |
| have hfun : (fun T : Finset (Assignment n) => alive T + lifetimeMean k m T) = | |
| fun T => β j β Finset.range (m + 1), survival k j T := by | |
| funext T | |
| rw [Finset.sum_range_succ', ih, survival_zero] | |
| ring | |
| rw [hfun, clauseAverage_sum] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| exact clauseAverage_survival S | |
| def killingChance {n : β} (k : β) (S : Finset (Assignment n)) : β := | |
| alive S - survival k 1 S | |
| theorem killingChance_nonneg {n k : β} (hkn : k β€ n) (S : Finset (Assignment n)) : | |
| 0 β€ killingChance k S := by | |
| have h := survival_antitone hkn S (Nat.zero_le 1) | |
| exact sub_nonneg.mpr h | |
| theorem killingChance_le_one {n k : β} (S : Finset (Assignment n)) : killingChance k S β€ 1 := by | |
| unfold killingChance | |
| linarith [alive_le_one S, survival_nonneg (k := k) (m := 1) S] | |
| theorem killingChance_eq_mean {n k : β} (hkn : k β€ n) (S : Finset (Assignment n)) : | |
| killingChance k S = uniformMean (fun C : ProperClause n k => alive S - alive (addClause S C)) := by | |
| let : Nonempty (ProperClause n k) := nonempty_properClause hkn | |
| rw [uniformMean_sub, uniformMean_const] | |
| rfl | |
| theorem killingChance_eq_probability {n k : β} (hkn : k β€ n) {S : Finset (Assignment n)} | |
| (hS : S.Nonempty) : | |
| killingChance k S = uniformProbability (fun C : ProperClause n k => KillsSolutions S C) := by | |
| rw [singleUNSAT_eq hkn] | |
| simp [killingChance, alive, hS] | |
| theorem survival_le_geometric {n k d : β} (hkn : k β€ n) (S : Finset (Assignment n)) : | |
| survival k d S β€ (1 - killingChance k S) ^ d := by | |
| by_cases hS : S.Nonempty | |
| Β· have h := blockUNSAT_lower (g := d) hkn S | |
| rw [blockUNSAT_eq hkn, β killingChance_eq_probability hkn hS] at h | |
| linarith | |
| Β· have he : S = β := Finset.not_nonempty_iff_eq_empty.mp hS | |
| subst S | |
| rw [survival_empty] | |
| exact pow_nonneg (sub_nonneg.mpr (killingChance_le_one β )) _ | |
| def insertionDelay {n : β} (k m : β) (S : Finset (Assignment n)) | |
| (C : ProperClause n k) (F : Formula n k m) : β := | |
| (alive S + lifetime k m S F) - (alive (addClause S C) + lifetime k m (addClause S C) F) | |
| def insertionSecond {n : β} (k m : β) (S : Finset (Assignment n)) : β := | |
| uniformMean (fun C : ProperClause n k => uniformMean (fun F : Formula n k m => | |
| insertionDelay k m S C F ^ 2)) | |
| theorem insertionDelay_zero {n k : β} (S : Finset (Assignment n)) (C : ProperClause n k) | |
| (F : Formula n k 0) : insertionDelay k 0 S C F = alive S - alive (addClause S C) := by | |
| simp [insertionDelay] | |
| theorem insertionDelay_cons {n k m : β} (S : Finset (Assignment n)) (C D : ProperClause n k) | |
| (F : Formula n k m) : insertionDelay k (m + 1) S C (Fin.cons D F) = | |
| alive S - alive (addClause S C) + insertionDelay k m (addClause S D) C F := by | |
| simp only [insertionDelay, lifetime_cons, addClause_comm S C D] | |
| ring | |
| theorem pivot_sq {n k : β} (S : Finset (Assignment n)) (C : ProperClause n k) : | |
| (alive S - alive (addClause S C)) ^ 2 = alive S - alive (addClause S C) := by | |
| have hsub := alive_mono (addClause_subset S C) | |
| unfold alive at hsub β’ | |
| split_ifs at hsub β’ <;> norm_num at * | |
| theorem insertionDelay_cross {n k m : β} {S T : Finset (Assignment n)} (hTS : T β S) | |
| (C : ProperClause n k) (F : Formula n k m) : | |
| (alive S - alive (addClause S C)) * insertionDelay k m T C F = | |
| (alive S - alive (addClause S C)) * (alive T + lifetime k m T F) := by | |
| by_cases hzero : alive S - alive (addClause S C) = 0 | |
| Β· rw [hzero, zero_mul, zero_mul] | |
| Β· have he : addClause S C = β := by | |
| by_contra hn | |
| have hSC := Finset.nonempty_iff_ne_empty.mpr hn | |
| have hS := hSC.mono (addClause_subset S C) | |
| simp [alive, hSC, hS] at hzero | |
| have hf : addClause T C = β := Finset.subset_empty.mp (by | |
| rw [β he] | |
| exact addClause_mono hTS C) | |
| simp [insertionDelay, hf] | |
| theorem insertionDelay_cons_sq {n k m : β} (S : Finset (Assignment n)) (C D : ProperClause n k) | |
| (F : Formula n k m) : insertionDelay k (m + 1) S C (Fin.cons D F) ^ 2 = | |
| insertionDelay k m (addClause S D) C F ^ 2 + (alive S - alive (addClause S C)) + | |
| 2 * (alive S - alive (addClause S C)) * | |
| (alive (addClause S D) + lifetime k m (addClause S D) F) := by | |
| rw [insertionDelay_cons] | |
| have h := insertionDelay_cross (addClause_subset S D) C F | |
| have hs := pivot_sq S C | |
| nlinarith [hs, h] | |
| theorem insertionSecond_zero {n k : β} (hkn : k β€ n) (S : Finset (Assignment n)) : | |
| insertionSecond k 0 S = killingChance k S := by | |
| rw [killingChance_eq_mean hkn] | |
| unfold insertionSecond | |
| apply uniformMean_congr | |
| intro C | |
| simp only [insertionDelay_zero, pivot_sq, uniformMean_const] | |
| theorem insertionSecond_succ {n k m : β} (hkn : k β€ n) (S : Finset (Assignment n)) : | |
| insertionSecond k (m + 1) S = clauseAverage k (insertionSecond k m) S + | |
| killingChance k S * (1 + 2 * lifetimeMean k (m + 1) S) := by | |
| let : Nonempty (ProperClause n k) := nonempty_properClause hkn | |
| unfold insertionSecond | |
| simp_rw [uniformMean_fin_succ, insertionDelay_cons_sq, uniformMean_add, | |
| uniformMean_const_mul, uniformMean_const] | |
| rw [uniformMean_comm (fun C D => uniformMean | |
| (fun F : Formula n k m => insertionDelay k m (addClause S D) C F ^ 2))] | |
| rw [β killingChance_eq_mean hkn] | |
| have hmean : (uniformMean fun D : ProperClause n k => | |
| alive (addClause S D) + uniformMean (lifetime k m (addClause S D))) = | |
| lifetimeMean k (m + 1) S := (lifetimeMean_succ hkn S).symm | |
| simp_rw [uniformMean_add, uniformMean_const] | |
| simp only [uniformMean_add] at hmean | |
| rw [hmean] | |
| simp only [uniformMean_mul_const, uniformMean_const_mul, | |
| β killingChance_eq_mean hkn] | |
| dsimp only [clauseAverage] | |
| ring | |
| theorem killing_geometric_sum {q : β} (hq0 : 0 β€ q) (hq1 : q β€ 1) (t : β) : | |
| q * β j β Finset.range t, (1 - q)^j β€ min ((t : β) * q) 1 := by | |
| have hgeom : q * β j β Finset.range t, (1 - q)^j = 1 - (1 - q)^t := by | |
| induction t with | |
| | zero => simp | |
| | succ t ih => rw [Finset.sum_range_succ, mul_add, ih, pow_succ]; ring | |
| apply le_min | |
| Β· calc | |
| _ β€ q * β _j β Finset.range t, (1 : β) := by | |
| exact mul_le_mul_of_nonneg_left (Finset.sum_le_sum (fun j _ => | |
| pow_le_oneβ (by linarith) (by linarith))) hq0 | |
| _ = _ := by simp; ring | |
| Β· rw [hgeom] | |
| linarith [pow_nonneg (sub_nonneg.mpr hq1) t] | |
| def truncatedKilling {n : β} (k M : β) (S : Finset (Assignment n)) : β := | |
| min ((M : β) * killingChance k S) 1 | |
| theorem pivotal_local_bound {n k m M : β} (hkn : k β€ n) (hm : m + 1 β€ M) | |
| (S : Finset (Assignment n)) : | |
| killingChance k S * (1 + 2 * lifetimeMean k m S) β€ 2 * truncatedKilling k M S := by | |
| have hq0 := killingChance_nonneg hkn S | |
| have hq1 := killingChance_le_one (k := k) S | |
| have hsum : 1 + lifetimeMean k m S β€ | |
| β j β Finset.range (m + 1), (1 - killingChance k S)^j := by | |
| rw [lifetimeMean_eq_sum hkn, Finset.sum_range_succ'] | |
| simp only [pow_zero] | |
| simpa only [add_comm] using add_le_add_left | |
| (Finset.sum_le_sum (fun j (_ : j β Finset.range m) => | |
| survival_le_geometric (d := j + 1) hkn S)) 1 | |
| have hgeom := killing_geometric_sum hq0 hq1 (m + 1) | |
| have hmin : min (((m + 1 : β) : β) * killingChance k S) 1 β€ truncatedKilling k M S := by | |
| exact min_le_min (mul_le_mul_of_nonneg_right (by exact_mod_cast hm) hq0) le_rfl | |
| have hh := mul_le_mul_of_nonneg_left hsum hq0 | |
| nlinarith | |
| def occupation {n : β} (k : β) (f : Finset (Assignment n) β β) : | |
| β β Finset (Assignment n) β β | |
| | 0, _ => 0 | |
| | m + 1, S => f S + clauseAverage k (occupation k f m) S | |
| theorem occupation_eq_sum {n k m : β} (f : Finset (Assignment n) β β) | |
| (S : Finset (Assignment n)) : | |
| occupation k f m S = β j β Finset.range m, ((clauseAverage k)^[j] f) S := by | |
| induction m generalizing S with | |
| | zero => simp [occupation] | |
| | succ m ih => | |
| simp only [occupation] | |
| have he : occupation k f m = fun T => β j β Finset.range m, ((clauseAverage k)^[j] f) T := | |
| funext ih | |
| rw [he, clauseAverage_sum, Finset.sum_range_succ'] | |
| simp only [Function.iterate_succ_apply', Function.iterate_zero, id_eq] | |
| ring | |
| theorem occupation_nonneg {n k m : β} {f : Finset (Assignment n) β β} | |
| (hf : β S, 0 β€ f S) (S : Finset (Assignment n)) : 0 β€ occupation k f m S := by | |
| induction m generalizing S with | |
| | zero => exact le_rfl | |
| | succ m ih => exact add_nonneg (hf S) (uniformMean_nonneg (fun C => ih _)) | |
| theorem insertionSecond_le_occupation {n k m M : β} (hkn : k β€ n) (hm : m + 1 β€ M) | |
| (S : Finset (Assignment n)) : | |
| insertionSecond k m S β€ 2 * occupation k (truncatedKilling k M) (m + 1) S := by | |
| induction m generalizing S with | |
| | zero => | |
| rw [insertionSecond_zero hkn] | |
| have hp := pivotal_local_bound (m := 0) hkn hm S | |
| simpa [occupation, clauseAverage, uniformMean_zero, lifetimeMean, lifetime, uniformMean] using hp | |
| | succ m ih => | |
| rw [insertionSecond_succ hkn, occupation] | |
| have hp := pivotal_local_bound (m := m + 1) hkn hm S | |
| have havg := clauseAverage_mono (k := k) (fun T => ih (by omega) T) S | |
| change clauseAverage k (insertionSecond k m) S β€ | |
| uniformMean (fun C : ProperClause n k => 2 * occupation k (truncatedKilling k M) (m + 1) | |
| (addClause S C)) at havg | |
| rw [uniformMean_const_mul] at havg | |
| change clauseAverage k (insertionSecond k m) S β€ | |
| 2 * clauseAverage k (occupation k (truncatedKilling k M) (m + 1)) S at havg | |
| linarith | |
| theorem uniformVariance_const_add {Ξ± : Type*} [Fintype Ξ±] [Nonempty Ξ±] | |
| (f : Ξ± β β) (c : β) : uniformVariance (fun a => c + f a) = uniformVariance f := by | |
| unfold uniformVariance | |
| rw [uniformMean_add, uniformMean_const] | |
| apply uniformMean_congr | |
| intro a | |
| congr 1 | |
| ring | |
| theorem uniformVariance_product {Ξ± Ξ² : Type*} [Fintype Ξ±] [Fintype Ξ²] | |
| [Nonempty Ξ±] [Nonempty Ξ²] (f : Ξ± β Ξ² β β) : | |
| uniformVariance (fun p : Ξ± Γ Ξ² => f p.1 p.2) = | |
| uniformMean (fun a => uniformVariance (f a)) + | |
| uniformVariance (fun a => uniformMean (f a)) := by | |
| simp only [uniformVariance_eq, uniformMean_prod, uniformMean_sub] | |
| ring | |
| theorem uniformVariance_fin_succ {Ξ± : Type*} [Fintype Ξ±] [Nonempty Ξ±] {m : β} | |
| (f : (Fin (m + 1) β Ξ±) β β) : | |
| uniformVariance f = uniformMean (fun C => uniformVariance (fun F : Fin m β Ξ± => | |
| f (Fin.cons C F))) + uniformVariance (fun C => uniformMean (fun F : Fin m β Ξ± => | |
| f (Fin.cons C F))) := by | |
| simp only [uniformVariance_eq, uniformMean_fin_succ, uniformMean_sub] | |
| ring | |
| theorem lifetimeVariance_succ_le {n k m : β} (hkn : k β€ n) (S : Finset (Assignment n)) : | |
| lifetimeVariance k (m + 1) S β€ | |
| clauseAverage k (lifetimeVariance k m) S + insertionSecond k m S := by | |
| let : Nonempty (ProperClause n k) := nonempty_properClause hkn | |
| unfold lifetimeVariance | |
| rw [uniformVariance_fin_succ] | |
| simp only [lifetime_cons, uniformVariance_const_add] | |
| apply add_le_add le_rfl | |
| let c := alive S + lifetimeMean k m S | |
| calc | |
| _ β€ uniformMean (fun C : ProperClause n k => | |
| (uniformMean (fun F : Formula n k m => | |
| alive (addClause S C) + lifetime k m (addClause S C) F) - c)^2) := | |
| uniformVariance_le_sq_dist _ c | |
| _ β€ insertionSecond k m S := by | |
| apply uniformMean_mono | |
| intro C | |
| have h := uniformMean_sq_ge (fun F : Formula n k m => insertionDelay k m S C F) | |
| have he : uniformMean (fun F : Formula n k m => insertionDelay k m S C F) = | |
| c - uniformMean (fun F : Formula n k m => | |
| alive (addClause S C) + lifetime k m (addClause S C) F) := by | |
| simp only [insertionDelay, uniformMean_sub, uniformMean_add, uniformMean_const, | |
| c, lifetimeMean] | |
| rw [he] at h | |
| nlinarith | |
| theorem clauseAverage_const_mul {n k : β} (c : β) (f : Finset (Assignment n) β β) | |
| (S : Finset (Assignment n)) : | |
| clauseAverage k (fun T => c * f T) S = c * clauseAverage k f S := | |
| uniformMean_const_mul c _ | |
| theorem lifetimeVariance_le_occupation {n k m M : β} (hkn : k β€ n) (hm : m β€ M) | |
| (S : Finset (Assignment n)) : | |
| lifetimeVariance k m S β€ 2 * m * occupation k (truncatedKilling k M) m S := by | |
| induction m generalizing S with | |
| | zero => simp [lifetimeVariance, lifetime, uniformVariance, uniformMean] | |
| | succ m ih => | |
| have hv := lifetimeVariance_succ_le (m := m) hkn S | |
| have hi := insertionSecond_le_occupation hkn hm S | |
| have havg := clauseAverage_mono (k := k) (fun T => ih (by omega) T) S | |
| rw [clauseAverage_const_mul] at havg | |
| have hq : 0 β€ truncatedKilling k M S := | |
| le_min (mul_nonneg (Nat.cast_nonneg _) (killingChance_nonneg hkn S)) zero_le_one | |
| have he : occupation k (truncatedKilling k M) (m + 1) S = | |
| truncatedKilling k M S + clauseAverage k (occupation k (truncatedKilling k M) m) S := rfl | |
| simp only [Nat.cast_add, Nat.cast_one] | |
| nlinarith [mul_nonneg (Nat.cast_nonneg m : (0 : β) β€ m) hq] | |
| theorem killingChance_eq_killingProbability {n k : β} (hkn : k β€ n) | |
| (S : Finset (Assignment n)) : killingChance k S = killingProbability k S := by | |
| by_cases hS : S.Nonempty | |
| Β· rw [killingChance_eq_probability hkn hS] | |
| simp [killingProbability, hS] | |
| Β· have he : S = β := Finset.not_nonempty_iff_eq_empty.mp hS | |
| subst S | |
| simp [killingChance] | |
| def forcedFraction {n : β} (S : Finset (Assignment n)) : β := | |
| ((forcedVariables S).card : β) / n | |
| theorem forcedFraction_nonneg {n : β} (S : Finset (Assignment n)) : 0 β€ forcedFraction S := by | |
| unfold forcedFraction | |
| positivity | |
| theorem forcedFraction_le_one {n : β} (S : Finset (Assignment n)) : forcedFraction S β€ 1 := by | |
| by_cases hn : n = 0 | |
| Β· simp [forcedFraction, hn] | |
| Β· rw [forcedFraction, div_le_one (by exact_mod_cast Nat.pos_of_ne_zero hn)] | |
| exact_mod_cast (show (forcedVariables S).card β€ n by simpa using Finset.card_le_univ (forcedVariables S)) | |
| theorem killingChance_le_forced_pow {n k : β} (hk : 0 < k) (hkn : k β€ n) | |
| (S : Finset (Assignment n)) : killingChance k S β€ forcedFraction S ^ k := by | |
| rw [killingChance_eq_killingProbability hkn, killingProbability_eq hk] | |
| have hn : 0 < n := lt_of_lt_of_le hk hkn | |
| have hbn : (forcedVariables S).card β€ n := by simpa using Finset.card_le_univ (forcedVariables S) | |
| have h := killFraction_le_pow hbn hkn hn | |
| apply h.trans | |
| apply pow_le_pow_leftβ (by positivity) | |
| unfold forcedFraction | |
| apply div_le_div_of_nonneg_left (Nat.cast_nonneg _) (by exact_mod_cast hn) | |
| linarith [(Nat.cast_nonneg n : (0 : β) β€ n)] | |
| theorem truncatedKilling_le_forced {n k M : β} {L : β} | |
| (hk : 0 < k) (hkn : k β€ n) (hL : 1 β€ L) (hM : (M : β) β€ L * n) | |
| (S : Finset (Assignment n)) : | |
| truncatedKilling k M S β€ L * replacementScale n k * forcedFraction S := by | |
| have hn : 0 < n := lt_of_lt_of_le hk hkn | |
| have ha := replacementScale_pos (k := k) hn | |
| have hr := forcedFraction_nonneg S | |
| have ht : 0 β€ replacementScale n k * forcedFraction S := mul_nonneg ha.le hr | |
| by_cases hsmall : replacementScale n k * forcedFraction S β€ 1 | |
| Β· calc | |
| truncatedKilling k M S β€ (M : β) * killingChance k S := min_le_left _ _ | |
| _ β€ (L * n) * forcedFraction S ^ k := | |
| mul_le_mul hM (killingChance_le_forced_pow hk hkn S) | |
| (killingChance_nonneg hkn S) (by positivity) | |
| _ = L * (replacementScale n k * forcedFraction S)^k := by | |
| rw [mul_pow, replacementScale_pow hn hk] | |
| ring | |
| _ β€ L * (replacementScale n k * forcedFraction S) := by | |
| apply mul_le_mul_of_nonneg_left _ (by linarith) | |
| have he : (replacementScale n k * forcedFraction S)^k = | |
| (replacementScale n k * forcedFraction S)^(k - 1) * | |
| (replacementScale n k * forcedFraction S) := by | |
| rw [β pow_succ, Nat.sub_add_cancel hk] | |
| rw [he] | |
| exact mul_le_of_le_one_left ht (pow_le_oneβ ht hsmall) | |
| _ = _ := by ring | |
| Β· calc | |
| truncatedKilling k M S β€ 1 := min_le_right _ _ | |
| _ β€ L * (replacementScale n k * forcedFraction S) := by | |
| nlinarith [mul_nonneg (sub_nonneg.mpr hL) ht] | |
| _ = _ := by ring | |
| theorem clauseAverage_iterate_eq_mean {n k m : β} (f : Finset (Assignment n) β β) | |
| (S : Finset (Assignment n)) : | |
| ((clauseAverage k)^[m] f) S = uniformMean (fun F : Formula n k m => | |
| f (restrictSolutions S F)) := by | |
| induction m generalizing S with | |
| | zero => | |
| simp only [Function.iterate_zero, id_eq, restrictSolutions_zero, uniformMean_const] | |
| | succ m ih => | |
| rw [Function.iterate_succ_apply', uniformMean_fin_succ] | |
| change uniformMean (fun C : ProperClause n k => | |
| ((clauseAverage k)^[m] f) (addClause S C)) = _ | |
| apply uniformMean_congr | |
| intro C | |
| rw [ih] | |
| apply uniformMean_congr | |
| intro F | |
| rw [restrictSolutions_cons] | |
| theorem occupation_forced_eq {n k m : β} : | |
| occupation k (forcedFraction (n := n)) m Finset.univ = | |
| β j β Finset.range m, forcedFractionMean n k j := by | |
| rw [occupation_eq_sum] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| exact clauseAverage_iterate_eq_mean _ _ | |
| theorem occupation_mono {n k m : β} {f g : Finset (Assignment n) β β} | |
| (hfg : β S, f S β€ g S) (S : Finset (Assignment n)) : | |
| occupation k f m S β€ occupation k g m S := by | |
| rw [occupation_eq_sum, occupation_eq_sum] | |
| exact Finset.sum_le_sum fun _ _ => clauseAverage_iterate_mono hfg S | |
| theorem occupation_const_mul {n k m : β} (c : β) (f : Finset (Assignment n) β β) | |
| (S : Finset (Assignment n)) : | |
| occupation k (fun T => c * f T) m S = c * occupation k f m S := by | |
| induction m generalizing S with | |
| | zero => simp [occupation] | |
| | succ m ih => | |
| simp only [occupation] | |
| have he : occupation k (fun T => c * f T) m = fun T => c * occupation k f m T := funext ih | |
| rw [he, clauseAverage_const_mul] | |
| ring | |
| theorem lifetimeVariance_forcing_bound {n k M : β} {L : β} | |
| (hk : 0 < k) (hkn : k β€ n) (hL : 1 β€ L) (hM : (M : β) β€ L * n) : | |
| lifetimeVariance k M (Finset.univ : Finset (Assignment n)) β€ | |
| (2 * M * L * replacementScale n k) * | |
| β j β Finset.range M, forcedFractionMean n k j := by | |
| have hv := lifetimeVariance_le_occupation hkn (le_refl M) (Finset.univ : Finset (Assignment n)) | |
| have ho := occupation_mono (k := k) (m := M) | |
| (fun S => truncatedKilling_le_forced hk hkn hL hM S) Finset.univ | |
| rw [occupation_const_mul, occupation_forced_eq] at ho | |
| have hmul := mul_le_mul_of_nonneg_left ho (by positivity : (0 : β) β€ 2 * M) | |
| nlinarith | |
| end | |
| end FixedClauseThreshold | |
| end OAI | |