Download data/lean/OAI/Probability/RandomSAT/Concentration.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/RandomSAT/Concentration.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/RandomSAT/Concentration.lean
-
curl -L -o Concentration.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/RandomSAT/Concentration.lean
12.3 kB
| import OAI.Probability.RandomSAT.Variance | |
| namespace OAI | |
| /-! | |
| Normalized capped centers and polynomial concentration of the proper-clause | |
| satisfiability probability. | |
| -/ | |
| namespace FixedClauseThreshold | |
| open Finset | |
| noncomputable section | |
| attribute [local instance] Classical.propDecidable | |
| def capMultiplier (k : β) : β := 2^(k + 1) | |
| def mainCap (n k : β) : β := capMultiplier k * n | |
| def center (n k : β) : β := | |
| lifetimeMean k (mainCap n k) (Finset.univ : Finset (Assignment n)) / n | |
| def varianceConstant (k : β) : β := | |
| 2 * (capMultiplier k : β)^3 * k * (2 * k + capMultiplier k + 2) | |
| theorem capMultiplier_pos (k : β) : 0 < capMultiplier k := by | |
| unfold capMultiplier | |
| positivity | |
| theorem replacementBlock_le {n k : β} (hn : 1 β€ n) : | |
| (replacementBlock n k : β) β€ (2 * k + 1) * replacementScale n k := by | |
| have ha := replacementScale_one_le (k := k) hn | |
| have hc := Nat.ceil_lt_add_one (show 0 β€ 2 * (k : β) * replacementScale n k by positivity) | |
| change (replacementBlock n k : β) < 2 * k * replacementScale n k + 1 at hc | |
| nlinarith | |
| theorem replacementError_mul {n k : β} (hn : 0 < n) (hk : 0 < k) : | |
| (n : β) * replacementError n k = replacementScale n k := by | |
| have ha := replacementScale_pos (k := k) hn | |
| have hp : replacementScale n k ^ (k - 1) * replacementScale n k = (n : β) := by | |
| rw [β pow_succ, Nat.sub_add_cancel hk, replacementScale_pow hn hk] | |
| unfold replacementError | |
| rw [inv_pow] | |
| rw [mul_inv_eq_iff_eq_mulβ (pow_ne_zero _ (ne_of_gt ha))] | |
| nlinarith [hp] | |
| theorem integrated_forcing_capped {n k L : β} (hk : 3 β€ k) (hn : k + 1 β€ n) : | |
| β j β Finset.range (L * n), forcedFractionMean n k j β€ | |
| ((L : β) * k * (2 * k + L + 2)) * replacementScale n k := by | |
| have hn0 : 0 < n := by omega | |
| have hn1 : (1 : β) β€ n := by exact_mod_cast hn0 | |
| have h := integrated_forcing_finite hk hn (L * n) | |
| have hpartial : (β j β Finset.range (L * n), forcedFractionMean n k j) β€ | |
| β j β Finset.range (L * n + 1), forcedFractionMean n k j := by | |
| rw [Finset.sum_range_succ] | |
| exact le_add_of_nonneg_right (uniformMean_nonneg (fun _ => by positivity)) | |
| have heps := replacementError_mul (k := k) hn0 (by omega) | |
| have hg := replacementBlock_le (k := k) (by omega : 1 β€ n) | |
| have ha := replacementScale_pos (k := k) hn0 | |
| have he0 := replacementError_nonneg n k | |
| have hclean : (replacementBlock n k : β) * ((L * n : β) : β) * ((k : β) / n) + | |
| ((L * n + 1 : β) : β) * ((L * n : β) : β) * ((k : β) / n) * replacementError n k = | |
| (L : β) * k * replacementBlock n k + | |
| ((L : β) * n + 1) * L * k * replacementError n k := by | |
| simp only [Nat.cast_add, Nat.cast_mul, Nat.cast_one] | |
| field_simp | |
| rw [hclean] at h | |
| have he : replacementError n k β€ replacementScale n k := by | |
| nlinarith [mul_nonneg (sub_nonneg.mpr hn1) he0] | |
| have hg' := mul_le_mul_of_nonneg_left hg (by positivity : (0 : β) β€ L * k) | |
| have he' := mul_le_mul_of_nonneg_left he (by positivity : (0 : β) β€ L * k) | |
| have hp : ((L : β) * n + 1) * L * k * replacementError n k = | |
| (L : β)^2 * k * replacementScale n k + L * k * replacementError n k := by | |
| nlinarith [congrArg (fun x : β => (L : β)^2 * k * x) heps] | |
| rw [hp] at h | |
| nlinarith | |
| theorem variance_capped {n k : β} (hk : 3 β€ k) (hn : k + 1 β€ n) : | |
| lifetimeVariance k (mainCap n k) (Finset.univ : Finset (Assignment n)) β€ | |
| varianceConstant k * n * replacementScale n k ^ 2 := by | |
| have hL : (1 : β) β€ capMultiplier k := by exact_mod_cast capMultiplier_pos k | |
| have hv := lifetimeVariance_forcing_bound (n := n) (k := k) (M := mainCap n k) | |
| (L := capMultiplier k) (by omega) (by omega) hL (by simp [mainCap]) | |
| have hf := integrated_forcing_capped (L := capMultiplier k) hk hn | |
| have hmul := mul_le_mul_of_nonneg_left hf | |
| (show 0 β€ 2 * (mainCap n k : β) * capMultiplier k * replacementScale n k by | |
| have ha := replacementScale_pos (k := k) (by omega : 0 < n) | |
| positivity) | |
| apply hv.trans | |
| exact hmul.trans_eq (by simp only [mainCap, Nat.cast_mul, varianceConstant]; ring) | |
| theorem uniform_chebyshev {Ξ± : Type*} [Fintype Ξ±] [Nonempty Ξ±] | |
| (f : Ξ± β β) {t : β} (ht : 0 < t) : | |
| uniformProbability (fun a => t β€ |f a - uniformMean f|) β€ uniformVariance f / t^2 := by | |
| rw [le_div_iffβ (sq_pos_of_pos ht), uniformProbability_eq_mean, β uniformMean_mul_const] | |
| apply uniformMean_mono | |
| intro a | |
| by_cases h : t β€ |f a - uniformMean f| | |
| Β· simp only [ite_eq_left h, one_mul] | |
| nlinarith [sq_abs (f a - uniformMean f)] | |
| Β· simp only [ite_eq_right h, zero_mul] | |
| exact sq_nonneg _ | |
| theorem alive_univ (n : β) : alive (Finset.univ : Finset (Assignment n)) = 1 := by | |
| simp [alive] | |
| theorem uniformProbability_fin_succ {Ξ± : Type*} [Fintype Ξ±] {m : β} | |
| (p : (Fin (m + 1) β Ξ±) β Prop) : | |
| uniformProbability p = uniformMean (fun C : Ξ± => uniformProbability | |
| (fun F : Fin m β Ξ± => p (Fin.cons C F))) := by | |
| rw [uniformProbability_eq_mean, uniformMean_fin_succ] | |
| apply uniformMean_congr | |
| intro C | |
| exact (uniformProbability_eq_mean _).symm | |
| theorem lifetime_tail_probability {n k m M : β} (hkn : k β€ n) (hm : m β€ M) | |
| (S : Finset (Assignment n)) : | |
| uniformProbability (fun F : Formula n k M => S.Nonempty β§ (m : β) β€ lifetime k M S F) = | |
| survival k m S := by | |
| let : Nonempty (ProperClause n k) := nonempty_properClause hkn | |
| induction m generalizing M S with | |
| | zero => | |
| rw [uniformProbability_eq_mean, survival_zero] | |
| have he : (fun F : Formula n k M => if S.Nonempty β§ (0 : β) β€ lifetime k M S F | |
| then (1 : β) else 0) = fun _ => alive S := by | |
| funext F | |
| simp only [and_iff_left (lifetime_nonneg S F), alive] | |
| simp only [Nat.cast_zero, he, uniformMean_const] | |
| | succ m ih => | |
| cases M with | |
| | zero => omega | |
| | succ M => | |
| rw [uniformProbability_fin_succ] | |
| have he (C : ProperClause n k) (F : Formula n k M) : | |
| (S.Nonempty β§ ((m + 1 : β) : β) β€ lifetime k (M + 1) S (Fin.cons C F)) β | |
| (addClause S C).Nonempty β§ (m : β) β€ lifetime k M (addClause S C) F := by | |
| rw [lifetime_cons, Nat.cast_add, Nat.cast_one] | |
| by_cases hC : (addClause S C).Nonempty | |
| Β· have hS : S.Nonempty := hC.mono (addClause_subset S C) | |
| simp only [hS, hC, alive, ite_true, true_and] | |
| constructor <;> intro h <;> linarith | |
| Β· have hempty : addClause S C = β := Finset.not_nonempty_iff_eq_empty.mp hC | |
| simp only [hempty, alive_empty, lifetime_empty, add_zero, Finset.not_nonempty_empty, | |
| false_and] | |
| have hm0 : (0 : β) β€ m := Nat.cast_nonneg _ | |
| constructor | |
| Β· rintro β¨_, hhβ©; linarith | |
| Β· exact False.elim | |
| rw [survival_succ] | |
| apply uniformMean_congr | |
| intro C | |
| exact (uniformProbability_congr (he C)).trans (ih (M := M) (by omega) (addClause S C)) | |
| theorem properSATProbability_eq_lifetime_tail {n k m M : β} (hkn : k β€ n) (hm : m β€ M) : | |
| properSATProbability n k m = uniformProbability (fun F : Formula n k M => | |
| (m : β) β€ lifetime k M Finset.univ F) := by | |
| rw [properSATProbability_eq_survival, β lifetime_tail_probability hkn hm] | |
| congr 1 | |
| funext F | |
| simp | |
| def delta (k : β) : β := ((k : β) - 2) / (4 * k) | |
| def eta (k : β) : β := ((k : β) - 2) / (2 * k) | |
| def fluctuationWindow (n k : β) : β := (n : β) ^ (1 - delta k) | |
| def concentrationError (n k : β) : β := varianceConstant k * (n : β) ^ (-eta k) | |
| theorem delta_pos {k : β} (hk : 3 β€ k) : 0 < delta k := by | |
| have hk' : (3 : β) β€ k := by exact_mod_cast hk | |
| unfold delta | |
| exact div_pos (by linarith) (by positivity) | |
| theorem delta_lt_half {k : β} (hk : 3 β€ k) : delta k < 1 / 2 := by | |
| have hk' : (3 : β) β€ k := by exact_mod_cast hk | |
| rw [delta, div_lt_iffβ (by positivity : (0 : β) < 4 * k)] | |
| linarith | |
| theorem eta_eq_twice_delta (k : β) : eta k = 2 * delta k := by | |
| unfold eta delta | |
| ring | |
| theorem varianceConstant_nonneg (k : β) : 0 β€ varianceConstant k := by | |
| unfold varianceConstant | |
| positivity | |
| theorem fluctuationWindow_pos {n k : β} (hn : 0 < n) : 0 < fluctuationWindow n k := | |
| Real.rpow_pos_of_pos (by exact_mod_cast hn) _ | |
| theorem concentrationError_nonneg (n k : β) : 0 β€ concentrationError n k := | |
| mul_nonneg (varianceConstant_nonneg k) (Real.rpow_nonneg (Nat.cast_nonneg _) _) | |
| theorem variance_window_identity {n k : β} (hn : 0 < n) (hk : 0 < k) : | |
| (n : β) * replacementScale n k ^ 2 = | |
| fluctuationWindow n k ^ 2 * (n : β)^(-eta k) := by | |
| have hn' : (0 : β) < n := by exact_mod_cast hn | |
| have hk' : (k : β) β 0 := by exact_mod_cast Nat.ne_of_gt hk | |
| have hexp : 1 + (1 / (k : β)) * 2 = (1 - delta k) * 2 + -eta k := by | |
| unfold delta eta | |
| field_simp | |
| ring | |
| calc | |
| _ = (n : β)^(1 + (1 / (k : β)) * 2) := by | |
| rw [Real.rpow_add hn', Real.rpow_one, Real.rpow_mul hn'.le, Real.rpow_two] | |
| rfl | |
| _ = (n : β)^((1 - delta k) * 2 + -eta k) := by rw [hexp] | |
| _ = _ := by | |
| rw [Real.rpow_add hn', Real.rpow_mul hn'.le, Real.rpow_two] | |
| rfl | |
| theorem concentration_capped {n k : β} (hk : 3 β€ k) (hn : k + 1 β€ n) : | |
| uniformProbability (fun F : Formula n k (mainCap n k) => | |
| fluctuationWindow n k β€ |lifetime k (mainCap n k) Finset.univ F - | |
| (n : β) * center n k|) β€ concentrationError n k := by | |
| let : Nonempty (ProperClause n k) := nonempty_properClause (by omega) | |
| have hn0 : 0 < n := by omega | |
| have hn' : (n : β) β 0 := by exact_mod_cast Nat.ne_of_gt hn0 | |
| have hm : (n : β) * center n k = lifetimeMean k (mainCap n k) (Finset.univ : Finset (Assignment n)) := by | |
| unfold center | |
| field_simp | |
| rw [hm] | |
| have h := uniform_chebyshev (lifetime k (mainCap n k) (Finset.univ : Finset (Assignment n))) | |
| (fluctuationWindow_pos (k := k) hn0) | |
| apply h.trans | |
| have hv := div_le_div_of_nonneg_right (variance_capped hk hn) | |
| (sq_nonneg (fluctuationWindow n k)) | |
| apply hv.trans_eq | |
| have hid := variance_window_identity (k := k) hn0 (by omega) | |
| unfold concentrationError | |
| calc | |
| _ = varianceConstant k * ((n : β) * replacementScale n k^2) / fluctuationWindow n k^2 := by ring | |
| _ = _ := by | |
| rw [hid] | |
| field_simp [ne_of_gt (fluctuationWindow_pos (k := k) hn0)] | |
| theorem center_nonneg (n k : β) : 0 β€ center n k := by | |
| unfold center lifetimeMean | |
| exact div_nonneg (uniformMean_nonneg (fun F => lifetime_nonneg _ F)) (Nat.cast_nonneg _) | |
| theorem center_le_capMultiplier {n k : β} (hkn : k β€ n) (hn : 0 < n) : | |
| center n k β€ capMultiplier k := by | |
| let : Nonempty (ProperClause n k) := nonempty_properClause hkn | |
| have h := uniformMean_mono (fun F : Formula n k (mainCap n k) => lifetime_le Finset.univ F) | |
| rw [uniformMean_const] at h | |
| unfold center lifetimeMean | |
| rw [div_le_iffβ (by exact_mod_cast hn : (0 : β) < n)] | |
| simpa [mainCap] using h | |
| theorem properSATProbability_center_upper {n k m : β} (hk : 3 β€ k) (hn : k + 1 β€ n) | |
| (hm : m β€ mainCap n k) | |
| (hgap : (n : β) * center n k + fluctuationWindow n k β€ m) : | |
| properSATProbability n k m β€ concentrationError n k := by | |
| rw [properSATProbability_eq_lifetime_tail (by omega) hm] | |
| apply (uniformProbability_mono (fun F hF => ?_)).trans (concentration_capped hk hn) | |
| exact le_trans (by linarith) (le_abs_self _) | |
| theorem properSATProbability_center_lower {n k m : β} (hk : 3 β€ k) (hn : k + 1 β€ n) | |
| (hm : m β€ mainCap n k) | |
| (hgap : (m : β) + fluctuationWindow n k β€ (n : β) * center n k) : | |
| 1 - concentrationError n k β€ properSATProbability n k m := by | |
| let : Nonempty (ProperClause n k) := nonempty_properClause (by omega) | |
| rw [properSATProbability_eq_lifetime_tail (by omega) hm] | |
| have h := uniformProbability_mono (p := fun F : Formula n k (mainCap n k) => | |
| Β¬ (m : β) β€ lifetime k (mainCap n k) Finset.univ F) | |
| (q := fun F => fluctuationWindow n k β€ | |
| |lifetime k (mainCap n k) Finset.univ F - (n : β) * center n k|) (fun F hF => by | |
| have hh : lifetime k (mainCap n k) Finset.univ F < m := lt_of_not_ge hF | |
| exact le_trans (by linarith) (neg_le_abs _)) | |
| rw [uniformProbability_not] at h | |
| linarith [concentration_capped hk hn] | |
| end | |
| end FixedClauseThreshold | |
| end OAI | |