math / data /lean /OAI /Probability /RandomSAT /Replacement.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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