Download data/lean/OAI/Probability/RandomSAT/Replacement.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 17.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/RandomSAT/Replacement.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/RandomSAT/Replacement.lean
-
curl -L -o Replacement.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/RandomSAT/Replacement.lean
17.1 kB
| import OAI.Probability.RandomSAT.Clauses | |
| namespace OAI | |
| /-! | |
| Quantitative comparison of a shorter clause with a block of independent proper | |
| clauses, uniformly over the background solution set. | |
| -/ | |
| namespace FixedClauseThreshold | |
| open Finset | |
| noncomputable section | |
| attribute [local instance] Classical.propDecidable | |
| def killFraction (b n r : β) : β := (b.choose r : β) / ((n.choose r : β) * 2 ^ r) | |
| theorem killFraction_nonneg (b n r : β) : 0 β€ killFraction b n r := by | |
| unfold killFraction | |
| positivity | |
| @[simp] theorem killFraction_zero (b n : β) : killFraction b n 0 = 1 := by | |
| simp [killFraction] | |
| theorem killFraction_succ {b n r : β} (hrn : r + 1 β€ n) : | |
| killFraction b n (r + 1) = | |
| killFraction b n r * ((b - r : β) : β) / (2 * ((n - r : β) : β)) := by | |
| have hnc : (n.choose r : β) β 0 := by | |
| exact_mod_cast Nat.ne_of_gt (Nat.choose_pos (by omega : r β€ n)) | |
| have hncs : (n.choose (r + 1) : β) β 0 := by | |
| exact_mod_cast Nat.ne_of_gt (Nat.choose_pos hrn) | |
| have hnr : ((n - r : β) : β) β 0 := by | |
| exact_mod_cast (by omega : n - r β 0) | |
| have hb : (b.choose (r + 1) : β) * (r + 1) = | |
| (b.choose r : β) * ((b - r : β) : β) := by | |
| exact_mod_cast Nat.choose_succ_right_eq b r | |
| have hn : (n.choose (r + 1) : β) * (r + 1) = | |
| (n.choose r : β) * ((n - r : β) : β) := by | |
| exact_mod_cast Nat.choose_succ_right_eq n r | |
| unfold killFraction | |
| rw [pow_succ] | |
| field_simp | |
| nlinarith [congrArg (fun a : β => a * (n.choose (r + 1) : β)) hb, | |
| congrArg (fun a : β => a * (b.choose (r + 1) : β)) hn] | |
| theorem sub_ratio_le {b n r : β} (hbn : b β€ n) (hrb : r β€ b) (hrn : r < n) : | |
| ((b - r : β) : β) / ((n - r : β) : β) β€ (b : β) / n := by | |
| have hn : (0 : β) < n := by exact_mod_cast (by omega : 0 < n) | |
| have hnr : (0 : β) < (n - r : β) := by exact_mod_cast Nat.sub_pos_of_lt hrn | |
| rw [div_le_div_iffβ hnr hn, Nat.cast_sub hrb, Nat.cast_sub (Nat.le_of_lt hrn)] | |
| have hbn' : (b : β) β€ n := by exact_mod_cast hbn | |
| nlinarith [mul_nonneg (Nat.cast_nonneg r : (0 : β) β€ r) (sub_nonneg.mpr hbn')] | |
| theorem killFraction_le_pow {b n r : β} (hbn : b β€ n) (hrn : r β€ n) | |
| (hn : 0 < n) : killFraction b n r β€ ((b : β) / (2 * n)) ^ r := by | |
| induction r with | |
| | zero => simp | |
| | succ r ih => | |
| by_cases hbr : b < r + 1 | |
| Β· simp only [killFraction, Nat.choose_eq_zero_of_lt hbr, Nat.cast_zero, zero_div] | |
| positivity | |
| Β· have hrb : r β€ b := by omega | |
| have ih' := ih (by omega) | |
| rw [killFraction_succ hrn, pow_succ] | |
| have hratio := sub_ratio_le hbn hrb (by omega : r < n) | |
| have hhalf : ((b - r : β) : β) / (2 * ((n - r : β) : β)) β€ | |
| (b : β) / (2 * n) := by | |
| simpa only [div_mul_eq_div_div_swap] using div_le_div_of_nonneg_right hratio | |
| (by norm_num : (0 : β) β€ 2) | |
| calc | |
| killFraction b n r * ((b - r : β) : β) / (2 * ((n - r : β) : β)) = | |
| killFraction b n r * (((b - r : β) : β) / (2 * ((n - r : β) : β))) := by ring | |
| _ β€ ((b : β) / (2 * n)) ^ r * ((b : β) / (2 * n)) := | |
| mul_le_mul ih' hhalf (by positivity) (by positivity) | |
| theorem killFraction_le_half_pow {b n r : β} (hbn : b β€ n) (hrn : r β€ n) | |
| (hn : 0 < n) : killFraction b n r β€ (1 / 2 : β) ^ r := by | |
| apply (killFraction_le_pow hbn hrn hn).trans | |
| apply pow_le_pow_leftβ (by positivity) | |
| have hn' : (0 : β) < n := by exact_mod_cast hn | |
| apply (div_le_iffβ (by positivity : (0 : β) < 2 * n)).mpr | |
| have hbn' : (b : β) β€ n := by exact_mod_cast hbn | |
| linarith | |
| theorem nat_le_internal_choose {n r : β} (hr : 1 β€ r) (hrn : r < n) : | |
| n β€ n.choose r := by | |
| induction n generalizing r with | |
| | zero => omega | |
| | succ n ih => | |
| cases r with | |
| | zero => omega | |
| | succ r => | |
| by_cases h : r = 0 | |
| Β· subst r | |
| simp | |
| Β· rw [Nat.choose_succ_succ] | |
| have hlow := ih (by omega : 1 β€ r) (by omega : r < n) | |
| have hpos := Nat.choose_pos (by omega : r.succ β€ n) | |
| omega | |
| theorem killFraction_small_forcing {b n r : β} (hr : 1 β€ r) (hrn : r < n) | |
| (hbr : b β€ r) : killFraction b n r β€ 1 / (n + 1 : β) := by | |
| have hn : (1 : β) β€ n := by exact_mod_cast (by omega : 1 β€ n) | |
| have hnc : (n : β) β€ n.choose r := by exact_mod_cast nat_le_internal_choose hr hrn | |
| have hb : (b.choose r : β) β€ 1 := by | |
| exact_mod_cast (Nat.choose_le_choose r hbr).trans_eq (Nat.choose_self r) | |
| have hp : (2 : β) β€ 2 ^ r := by | |
| simpa using pow_le_pow_rightβ (by norm_num : (1 : β) β€ 2) hr | |
| have hncpos : (0 : β) < n.choose r := by linarith | |
| have hden : (0 : β) < (n.choose r : β) * 2 ^ r := by positivity | |
| unfold killFraction | |
| apply (div_le_div_iffβ hden (by positivity : (0 : β) < n + 1)).mpr | |
| nlinarith [mul_le_mul hnc hp (by positivity : (0 : β) β€ 2) (by positivity : (0 : β) β€ n.choose r)] | |
| theorem succ_ratio_lower {b n r : β} (hrb : r + 1 β€ b) (hrn : r < n) : | |
| (b : β) / (2 * n * (r + 1)) β€ | |
| ((b - r : β) : β) / (2 * ((n - r : β) : β)) := by | |
| have hn : (0 : β) < n := by exact_mod_cast (by omega : 0 < n) | |
| have hnr : (0 : β) < (n - r : β) := by exact_mod_cast Nat.sub_pos_of_lt hrn | |
| have hrb' : (r + 1 : β) β€ b := by exact_mod_cast hrb | |
| have hr : (0 : β) β€ r := by positivity | |
| rw [div_le_div_iffβ (by positivity : (0 : β) < 2 * n * (r + 1)) | |
| (by positivity : (0 : β) < 2 * (n - r : β))] | |
| rw [Nat.cast_sub (by omega : r β€ b), Nat.cast_sub (Nat.le_of_lt hrn)] | |
| have haux : (b : β) β€ (b - r) * (r + 1) := by | |
| nlinarith [mul_nonneg hr (sub_nonneg.mpr hrb')] | |
| nlinarith [mul_le_mul_of_nonneg_right haux hn.le, | |
| mul_nonneg (Nat.cast_nonneg b : (0 : β) β€ b) hr] | |
| theorem killFraction_succ_lower {b n r : β} (hrb : r + 1 β€ b) (hrn : r < n) : | |
| killFraction b n r * ((b : β) / (2 * n)) / (r + 1) β€ | |
| killFraction b n (r + 1) := by | |
| rw [killFraction_succ (by omega : r + 1 β€ n)] | |
| have h := mul_le_mul_of_nonneg_left (succ_ratio_lower hrb hrn) | |
| (killFraction_nonneg b n r) | |
| simpa only [div_eq_mul_inv, mul_inv_rev, mul_assoc, mul_comm, mul_left_comm] using h | |
| theorem power_survival_bound {q : β} (_hq0 : 0 β€ q) (hq1 : q β€ 1) (g : β) : | |
| (1 - q) ^ g * (1 + (g : β) * q) β€ 1 := by | |
| induction g with | |
| | zero => simp | |
| | succ g ih => | |
| have hstep : (1 - q) * (1 + ((g : β) + 1) * q) β€ 1 + (g : β) * q := by | |
| nlinarith [mul_nonneg (by positivity : (0 : β) β€ g + 1) (sq_nonneg q)] | |
| calc | |
| (1 - q) ^ (g + 1) * (1 + ((g + 1 : β) : β) * q) = | |
| (1 - q) ^ g * ((1 - q) * (1 + ((g : β) + 1) * q)) := by | |
| push_cast | |
| ring | |
| _ β€ (1 - q) ^ g * (1 + (g : β) * q) := | |
| mul_le_mul_of_nonneg_left hstep (pow_nonneg (sub_nonneg.mpr hq1) _) | |
| _ β€ 1 := ih | |
| theorem block_ge_of_double {x q : β} {g : β} | |
| (hx0 : 0 β€ x) (hxhalf : x β€ 1 / 2) (hq0 : 0 β€ q) (hq1 : q β€ 1) | |
| (hg : 2 * x β€ (g : β) * q) : x β€ 1 - (1 - q) ^ g := by | |
| have h := power_survival_bound hq0 hq1 g | |
| have hx1 : 0 β€ 1 - x := by linarith | |
| have hg0 : 0 β€ (g : β) * q := by positivity | |
| have hh : 1 β€ (1 - x) * (1 + (g : β) * q) := by | |
| nlinarith [mul_le_mul_of_nonneg_right hg hx1, mul_nonneg hx0 (by linarith : 0 β€ 1 - 2 * x)] | |
| have hb : (1 - q) ^ g β€ 1 - x := by | |
| exact (mul_le_mul_iff_leftβ (by positivity : 0 < 1 + (g : β) * q)).mp | |
| (by nlinarith) | |
| linarith | |
| theorem uniformProbability_true {Ξ± : Type*} [Fintype Ξ±] [Nonempty Ξ±] : | |
| uniformProbability (fun _ : Ξ± => True) = 1 := by | |
| classical | |
| unfold uniformProbability | |
| simp only [β Nat.card_eq_fintype_card] | |
| rw [Nat.card_congr (Equiv.subtypeUnivEquiv (fun _ => trivial))] | |
| rw [Nat.card_eq_fintype_card] | |
| exact div_self (by exact_mod_cast Fintype.card_ne_zero) | |
| theorem uniformProbability_false {Ξ± : Type*} [Fintype Ξ±] : | |
| uniformProbability (fun _ : Ξ± => False) = 0 := by | |
| simp [uniformProbability] | |
| theorem uniformProbability_congr {Ξ± : Type*} [Fintype Ξ±] {p q : Ξ± β Prop} | |
| (h : β a, p a β q a) : uniformProbability p = uniformProbability q := by | |
| unfold uniformProbability | |
| rw [Fintype.card_congr (Equiv.subtypeEquivRight h)] | |
| theorem uniformProbability_not {Ξ± : Type*} [Fintype Ξ±] [Nonempty Ξ±] (p : Ξ± β Prop) : | |
| uniformProbability (fun a => Β¬ p a) = 1 - uniformProbability p := by | |
| unfold uniformProbability | |
| rw [Fintype.card_subtype_compl, Nat.cast_sub (Fintype.card_subtype_le p), sub_div, | |
| div_self (by exact_mod_cast Fintype.card_ne_zero)] | |
| theorem uniformProbability_forall {Ξ± : Type*} [Fintype Ξ±] (p : Ξ± β Prop) (m : β) : | |
| uniformProbability (fun f : Fin m β Ξ± => β i, p (f i)) = uniformProbability p ^ m := by | |
| unfold uniformProbability | |
| have hc : Fintype.card {f : Fin m β Ξ± // β i, p (f i)} = | |
| Fintype.card (Fin m β {a : Ξ± // p a}) := | |
| Fintype.card_congr (Equiv.subtypePiEquivPi (p := fun _ : Fin m => p)) | |
| simp only [β Nat.card_eq_fintype_card] at hc β’ | |
| rw [hc] | |
| simp only [Nat.card_eq_fintype_card, Fintype.card_fun, Fintype.card_fin, Nat.cast_pow, | |
| div_pow] | |
| theorem uniformProbability_exists {Ξ± : Type*} [Fintype Ξ±] [Nonempty Ξ±] | |
| (p : Ξ± β Prop) (m : β) : | |
| uniformProbability (fun f : Fin m β Ξ± => β i, p (f i)) = | |
| 1 - (1 - uniformProbability p) ^ m := by | |
| calc | |
| _ = uniformProbability (fun f : Fin m β Ξ± => Β¬ β i, Β¬ p (f i)) := | |
| uniformProbability_congr (fun _ => by simp) | |
| _ = 1 - uniformProbability (fun f : Fin m β Ξ± => β i, Β¬ p (f i)) := | |
| uniformProbability_not _ | |
| _ = _ := by rw [uniformProbability_forall (fun a => Β¬ p a) m, uniformProbability_not] | |
| def blockUNSATProbability {n : β} (k g : β) (S : Finset (Assignment n)) : β := | |
| uniformProbability (fun F : Formula n k g => | |
| Β¬ β Ο β S, Satisfies Ο F) | |
| theorem blockUNSAT_lower {n k g : β} (hkn : k β€ n) (S : Finset (Assignment n)) : | |
| 1 - (1 - uniformProbability (fun C : ProperClause n k => KillsSolutions S C)) ^ g β€ | |
| blockUNSATProbability k g S := by | |
| let : Nonempty (ProperClause n k) := nonempty_properClause hkn | |
| rw [β uniformProbability_exists] | |
| apply uniformProbability_mono | |
| rintro F β¨i, hiβ© β¨Ο, hΟ, hsβ© | |
| exact hi Ο hΟ (hs i) | |
| theorem replacement_numeric {b v r g : β} {a : β} | |
| (hr : 1 β€ r) (hrv : r < v) (hbv : b β€ v) (ha : 0 < a) | |
| (hsmall : 1 / (v + 1 : β) β€ aβ»ΒΉ ^ r) | |
| (hg : 2 * (r + 1 : β) * a β€ (g : β)) : | |
| killFraction b v r - aβ»ΒΉ ^ r β€ 1 - (1 - killFraction b v (r + 1)) ^ g := by | |
| let x := killFraction b v r | |
| let q := killFraction b v (r + 1) | |
| have hv : 0 < v := by omega | |
| have hx0 : 0 β€ x := killFraction_nonneg _ _ _ | |
| have hq0 : 0 β€ q := killFraction_nonneg _ _ _ | |
| have hxhalf : x β€ 1 / 2 := by | |
| apply (killFraction_le_half_pow hbv (Nat.le_of_lt hrv) hv).trans | |
| calc | |
| (1 / 2 : β) ^ r β€ (1 / 2 : β) ^ 1 := | |
| pow_le_pow_of_le_one (by norm_num) (by norm_num) hr | |
| _ = 1 / 2 := by simp | |
| have hq1 : q β€ 1 := by | |
| apply (killFraction_le_half_pow hbv (by omega) hv).trans | |
| exact pow_le_oneβ (by norm_num) (by norm_num) | |
| by_cases hx : x β€ aβ»ΒΉ ^ r | |
| Β· have hpow : (1 - q) ^ g β€ 1 := | |
| pow_le_oneβ (sub_nonneg.mpr hq1) (by linarith) | |
| change x - aβ»ΒΉ ^ r β€ 1 - (1 - q) ^ g | |
| linarith | |
| Β· have hrb : r + 1 β€ b := by | |
| by_contra h | |
| have hb : b β€ r := by omega | |
| have hbound := killFraction_small_forcing hr hrv hb | |
| exact hx (hbound.trans hsmall) | |
| have ht : aβ»ΒΉ β€ (b : β) / (2 * v) := by | |
| by_contra h | |
| have hle : (b : β) / (2 * v) β€ aβ»ΒΉ := (lt_of_not_ge h).le | |
| have hpow := pow_le_pow_leftβ (by positivity : (0 : β) β€ (b : β) / (2 * v)) hle r | |
| have hbound := killFraction_le_pow hbv (Nat.le_of_lt hrv) hv | |
| exact hx (hbound.trans hpow) | |
| have hat : 1 β€ a * ((b : β) / (2 * v)) := by | |
| simpa [ne_of_gt ha] using mul_le_mul_of_nonneg_left ht ha.le | |
| have hqlo := killFraction_succ_lower hrb hrv | |
| have hprod : (2 * (r + 1 : β) * a) * | |
| (x * ((b : β) / (2 * v)) / (r + 1)) β€ (g : β) * q := | |
| mul_le_mul hg hqlo (by positivity) (by positivity) | |
| have hrpos : (r + 1 : β) β 0 := by positivity | |
| have heq : (2 * (r + 1 : β) * a) * | |
| (x * ((b : β) / (2 * v)) / (r + 1)) = | |
| 2 * x * (a * ((b : β) / (2 * v))) := by | |
| field_simp | |
| rw [heq] at hprod | |
| have hdbl : 2 * x β€ (g : β) * q := by | |
| nlinarith [mul_le_mul_of_nonneg_left hat (by positivity : 0 β€ 2 * x)] | |
| have hb := block_ge_of_double hx0 hxhalf hq0 hq1 hdbl | |
| have heps : 0 β€ aβ»ΒΉ ^ r := by positivity | |
| change x - aβ»ΒΉ ^ r β€ 1 - (1 - q) ^ g | |
| linarith | |
| def replacementScale (n k : β) : β := (n : β) ^ (1 / (k : β)) | |
| def replacementError (n k : β) : β := (replacementScale n k)β»ΒΉ ^ (k - 1) | |
| def replacementBlock (n k : β) : β := β2 * (k : β) * replacementScale n kββ | |
| theorem replacementScale_pos {n k : β} (hn : 0 < n) : | |
| 0 < replacementScale n k := by | |
| exact Real.rpow_pos_of_pos (by exact_mod_cast hn) _ | |
| theorem replacementScale_pow {n k : β} (hn : 0 < n) (hk : 0 < k) : | |
| replacementScale n k ^ k = (n : β) := by | |
| unfold replacementScale | |
| rw [β Real.rpow_natCast, β Real.rpow_mul (by positivity : (0 : β) β€ n)] | |
| have hk' : (k : β) β 0 := by exact_mod_cast Nat.ne_of_gt hk | |
| rw [one_div_mul_cancel hk', Real.rpow_one] | |
| theorem replacementScale_one_le {n k : β} (hn : 1 β€ n) : | |
| 1 β€ replacementScale n k := by | |
| unfold replacementScale | |
| exact Real.one_le_rpow (by exact_mod_cast hn) (by positivity) | |
| theorem replacementError_eq {n k : β} (hn : 0 < n) : | |
| replacementError n k = (n : β) ^ (-((k - 1 : β) : β) / k) := by | |
| unfold replacementError replacementScale | |
| rw [inv_pow, β Real.rpow_natCast, β Real.rpow_mul (by positivity : (0 : β) β€ n), | |
| β Real.rpow_neg (by positivity : (0 : β) β€ n)] | |
| congr 1 | |
| ring | |
| theorem replacementError_small {n k : β} (hn : 0 < n) (hk : 0 < k) : | |
| 1 / (n : β) β€ replacementError n k := by | |
| have ha := replacementScale_pos (k := k) hn | |
| have hpow : replacementScale n k ^ (k - 1) β€ (n : β) := by | |
| calc | |
| replacementScale n k ^ (k - 1) β€ replacementScale n k ^ k := | |
| pow_le_pow_rightβ (replacementScale_one_le (Nat.succ_le_of_lt hn)) (Nat.sub_le _ _) | |
| _ = _ := replacementScale_pow hn hk | |
| unfold replacementError | |
| rw [inv_pow, β one_div] | |
| exact one_div_le_one_div_of_le (by positivity) hpow | |
| theorem shorter_clause_replacement {n k : β} (hk : 3 β€ k) (hn : k + 1 β€ n) | |
| (S : Finset (Assignment (n - 1))) : | |
| uniformProbability (fun Q : ProperClause (n - 1) (k - 1) => KillsSolutions S Q) - | |
| replacementError n k β€ blockUNSATProbability k (replacementBlock n k) S := by | |
| have hkn : k β€ n - 1 := by omega | |
| let : Nonempty (ProperClause (n - 1) k) := nonempty_properClause hkn | |
| have heps : 0 β€ replacementError n k := | |
| pow_nonneg (inv_nonneg.mpr (replacementScale_pos (k := k) (by omega)).le) _ | |
| by_cases hS : S.Nonempty | |
| Β· have hkill (r : β) : | |
| uniformProbability (fun Q : ProperClause (n - 1) r => KillsSolutions S Q) = | |
| killFraction (forcedVariables S).card (n - 1) r := by | |
| unfold killFraction | |
| rw [β killingProbability_of_nonempty S hS] | |
| exact (uniformProbability_congr (fun _ => by simp [hS])).symm | |
| rw [hkill] | |
| apply le_trans _ (blockUNSAT_lower hkn S) | |
| rw [hkill] | |
| have hb : (forcedVariables S).card β€ n - 1 := by | |
| simpa using Finset.card_le_univ (forcedVariables S) | |
| have hg : 2 * ((k - 1 : β) + 1 : β) * replacementScale n k β€ | |
| (replacementBlock n k : β) := by | |
| have he : ((k - 1 : β) : β) + 1 = k := by | |
| exact_mod_cast (Nat.sub_add_cancel (by omega : 1 β€ k)) | |
| rw [he] | |
| exact Nat.le_ceil _ | |
| have hsmall : 1 / ((n - 1 : β) + 1 : β) β€ (replacementScale n k)β»ΒΉ ^ (k - 1) := by | |
| have he : ((n - 1 : β) : β) + 1 = n := by | |
| exact_mod_cast (Nat.sub_add_cancel (by omega : 1 β€ n)) | |
| rw [he] | |
| exact replacementError_small (by omega) (by omega) | |
| have hrep := replacement_numeric (r := k - 1) (b := (forcedVariables S).card) | |
| (v := n - 1) (g := replacementBlock n k) (a := replacementScale n k) | |
| (by omega) (by omega) hb (replacementScale_pos (by omega)) hsmall hg | |
| simpa only [Nat.sub_add_cancel (by omega : 1 β€ k), replacementError] using hrep | |
| Β· have hSe : S = β := Finset.not_nonempty_iff_eq_empty.mp hS | |
| subst S | |
| have hb : blockUNSATProbability k (replacementBlock n k) | |
| (β : Finset (Assignment (n - 1))) = 1 := by | |
| unfold blockUNSATProbability | |
| have hf : (fun F : Formula (n - 1) k (replacementBlock n k) => | |
| Β¬ β Ο β (β : Finset (Assignment (n - 1))), Satisfies Ο F) = | |
| (fun _ => True) := by | |
| funext F | |
| simp | |
| rw [hf] | |
| exact uniformProbability_true | |
| rw [hb] | |
| have hu := uniformProbability_le_one | |
| (fun Q : ProperClause (n - 1) (k - 1) => KillsSolutions β Q) | |
| linarith | |
| end | |
| end FixedClauseThreshold | |
| end OAI | |