| import OAI.Probability.SATVariance.BystanderStops | |
| namespace OAI | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory | |
| namespace RandomKSAT | |
| open scoped Classical ENNReal | |
| def insertKernel.{u_1} {α : Type u_1} (c : α) (f : List α → ℝ) (l : List α) : ℝ := | |
| favg (fun i : Fin (l.length+1) => f (l.insertIdx i c)) | |
| def insertAvg.{u_1} {α : Type u_1} : List α → List α → (List α → ℝ) → ℝ | |
| | [], l, f => f l | |
| | c::b, l, f => insertAvg b l (insertKernel c f) | |
| inductive Inserts.{u_1} {α : Type u_1} : List α → List α → List α → Prop | |
| | nil (l : List α) : Inserts [] l l | |
| | cons (c : α) {b l r : List α} (h : Inserts b l r) (i : ℕ) (hi : i ≤ r.length) : | |
| Inserts (c::b) l (r.insertIdx i c) | |
| lemma inserts_length.{u_1} {α : Type u_1} {b l r : List α} (h : Inserts b l r) : | |
| r.length = b.length+l.length := by | |
| induction h with | |
| | nil => simp | |
| | cons c h i hi ih => rw [List.length_insertIdx_of_le_length hi, ih, List.length_cons]; omega | |
| lemma inserts_perm.{u_1} {α : Type u_1} {b l r : List α} (h : Inserts b l r) : r.Perm (b++l) := by | |
| induction h with | |
| | nil => simp | |
| | cons c h i hi ih => exact (List.perm_insertIdx c _ hi).trans (ih.cons c) | |
| lemma insertAvg_congr.{u_1} {α : Type u_1} (b l : List α) {f g : List α → ℝ} | |
| (h : ∀ r, Inserts b l r → f r = g r) : insertAvg b l f = insertAvg b l g := by | |
| induction b generalizing f g with | |
| | nil => exact h l (Inserts.nil l) | |
| | cons c b ih => | |
| apply ih | |
| intro r hr | |
| unfold insertKernel | |
| congr 1 | |
| funext i | |
| exact h _ (Inserts.cons c hr i (by omega)) | |
| lemma insertAvg_mono.{u_1} {α : Type u_1} (b l : List α) {f g : List α → ℝ} | |
| (h : ∀ r, Inserts b l r → f r ≤ g r) : insertAvg b l f ≤ insertAvg b l g := by | |
| induction b generalizing f g with | |
| | nil => exact h l (Inserts.nil l) | |
| | cons c b ih => | |
| apply ih | |
| intro r hr | |
| exact favg_mono (fun i => h _ (Inserts.cons c hr i (by omega))) | |
| lemma insertAvg_const.{u_1} {α : Type u_1} (b l : List α) (a : ℝ) : | |
| insertAvg b l (fun _ => a) = a := by | |
| induction b with | |
| | nil => rfl | |
| | cons c b ih => | |
| change insertAvg b l (fun r => favg (fun _ : Fin (r.length+1) => a)) = a | |
| simp only [favg_const,ih] | |
| lemma insertAvg_nonneg.{u_1} {α : Type u_1} (b l : List α) {f : List α → ℝ} | |
| (h : ∀ r, Inserts b l r → 0 ≤ f r) : 0 ≤ insertAvg b l f := by | |
| rw [← insertAvg_const b l 0] | |
| exact insertAvg_mono b l h | |
| lemma insertAvg_add.{u_1} {α : Type u_1} (b l : List α) (f g : List α → ℝ) : | |
| insertAvg b l (fun r => f r+g r) = insertAvg b l f+insertAvg b l g := by | |
| induction b generalizing f g with | |
| | nil => rfl | |
| | cons c b ih => | |
| change insertAvg b l (fun r => favg (fun i : Fin (r.length+1) => | |
| f (r.insertIdx i c)+g (r.insertIdx i c))) = _ | |
| simp only [favg_add] | |
| exact ih _ _ | |
| lemma insertAvg_sub.{u_1} {α : Type u_1} (b l : List α) (f g : List α → ℝ) : | |
| insertAvg b l (fun r => f r-g r) = insertAvg b l f-insertAvg b l g := by | |
| induction b generalizing f g with | |
| | nil => rfl | |
| | cons c b ih => | |
| change insertAvg b l (fun r => favg (fun i : Fin (r.length+1) => | |
| f (r.insertIdx i c)-g (r.insertIdx i c))) = _ | |
| simp only [favg_sub] | |
| exact ih _ _ | |
| lemma insertAvg_mul.{u_1} {α : Type u_1} (b l : List α) (a : ℝ) (f : List α → ℝ) : | |
| insertAvg b l (fun r => a*f r) = a*insertAvg b l f := by | |
| induction b generalizing f with | |
| | nil => rfl | |
| | cons c b ih => | |
| change insertAvg b l (fun r => favg (fun i : Fin (r.length+1) => a*f (r.insertIdx i c))) = _ | |
| simp only [favg_mul] | |
| exact ih _ | |
| lemma insertAvg_sq_le.{u_1} {α : Type u_1} (b l : List α) (f : List α → ℝ) : | |
| (insertAvg b l f)^2 ≤ insertAvg b l (fun r => (f r)^2) := by | |
| induction b generalizing f with | |
| | nil => exact le_refl _ | |
| | cons c b ih => | |
| apply (ih (insertKernel c f)).trans | |
| apply insertAvg_mono | |
| intro r _ | |
| exact favg_sq_le _ | |
| lemma shuffleAvg_cons_kernel.{u_1} {α : Type u_1} (l : List α) (c : α) (f : List α → ℝ) : | |
| shuffleAvg (c::l) f = shuffleAvg l (insertKernel c f) := by | |
| rw [shuffleAvg_cons] | |
| apply shuffleAvg_congr | |
| intro r hr | |
| unfold insertKernel | |
| exact favg_equiv (finCongr (congrArg (fun x => x+1) hr.length_eq).symm) | |
| (fun i : Fin (r.length+1) => f (r.insertIdx i c)) | |
| lemma shuffleAvg_append.{u_1} {α : Type u_1} (b l : List α) (f : List α → ℝ) : | |
| shuffleAvg (b++l) f = shuffleAvg l (fun r => insertAvg b r f) := by | |
| induction b generalizing f with | |
| | nil => rfl | |
| | cons c b ih => | |
| rw [List.cons_append, shuffleAvg_cons_kernel, ih] | |
| rfl | |
| def insertVar.{u_1} {α : Type u_1} (b l : List α) (f : List α → ℝ) : ℝ := | |
| insertAvg b l (fun r => (f r)^2) - (insertAvg b l f)^2 | |
| lemma insertVar_nonneg.{u_1} {α : Type u_1} (b l : List α) (f : List α → ℝ) : 0 ≤ insertVar b l f := | |
| sub_nonneg.mpr (insertAvg_sq_le b l f) | |
| lemma insertVar_congr.{u_1} {α : Type u_1} (b l : List α) {f g : List α → ℝ} | |
| (h : ∀ r, Inserts b l r → f r = g r) : insertVar b l f = insertVar b l g := by | |
| unfold insertVar | |
| rw [insertAvg_congr b l h,insertAvg_congr b l (fun r hr => congrArg (fun x : ℝ => x^2) (h r hr))] | |
| lemma insertVar_mul.{u_1} {α : Type u_1} (b l : List α) (a : ℝ) (f : List α → ℝ) : | |
| insertVar b l (fun r => a*f r) = a^2*insertVar b l f := by | |
| have he : (fun r => (a*f r)^2) = (fun r => a^2*(f r)^2) := by funext r; ring | |
| simp only [insertVar,he,insertAvg_mul] | |
| ring | |
| lemma insertVar_cons.{u_1} {α : Type u_1} (b l : List α) (c : α) (f : List α → ℝ) : | |
| insertVar (c::b) l f = insertVar b l (insertKernel c f) + | |
| insertAvg b l (fun r => fvariance (fun i : Fin (r.length+1) => f (r.insertIdx i c))) := by | |
| change insertAvg b l (insertKernel c (fun r => (f r)^2)) - | |
| (insertAvg b l (insertKernel c f))^2 = | |
| (insertAvg b l (fun r => (insertKernel c f r)^2) - | |
| (insertAvg b l (insertKernel c f))^2) + | |
| insertAvg b l (fun r => insertKernel c (fun r => (f r)^2) r - | |
| (insertKernel c f r)^2) | |
| rw [insertAvg_sub] | |
| ring | |
| def Private {n k : ℕ} (c : Clause n k) (l : List (Clause n k)) : Prop := | |
| ∃ v : c.1.1, ∀ d ∈ l, v.val ∉ d.1.1 | |
| def Bystanders {n k : ℕ} : List (Clause n k) → List (Clause n k) → Prop | |
| | [], _ => True | |
| | c::b, l => Private c (b++l) ∧ Bystanders b l | |
| lemma private_perm {n k : ℕ} {c : Clause n k} {l r : List (Clause n k)} | |
| (h : l.Perm r) (hc : Private c l) : Private c r := by | |
| obtain ⟨v,hv⟩ := hc | |
| exact ⟨v,fun d hd => hv d (h.mem_iff.mpr hd)⟩ | |
| lemma private_harmless {n k : ℕ} {c : Clause n k} {l : List (Clause n k)} | |
| (hc : Private c l) : Harmless c l := by | |
| obtain ⟨v,hv⟩ := hc | |
| exact harmless_private c l v hv | |
| lemma inserts_stop_bounds {n k : ℕ} {b l r : List (Clause n k)} (hb : Bystanders b l) | |
| (h : Inserts b l r) : listStop l ≤ listStop r ∧ listStop r ≤ listStop l+b.length := by | |
| induction h with | |
| | nil => simp | |
| | @cons c b l r h i hi ih => | |
| have hh : Harmless c r := private_harmless (private_perm (inserts_perm h).symm hb.1) | |
| rw [listStop_insert c r hh i hi] | |
| have ht := ih hb.2 | |
| simp only [List.length_cons] | |
| split_ifs <;> omega | |
| lemma favg_fin_lt {L t : ℕ} (ht : t ≤ L) : | |
| favg (fun i : Fin L => if i.val < t then (1:ℝ) else 0) = (t:ℝ)/L := by | |
| unfold favg | |
| simp only [Fintype.card_fin] | |
| congr 1 | |
| have he : {i : Fin L // i.val < t} ≃ Fin t := | |
| { toFun := fun i => ⟨i.1.val,i.2⟩ | |
| invFun := fun i => ⟨⟨i.val,i.isLt.trans_le ht⟩,i.isLt⟩ | |
| left_inv := fun _ => rfl | |
| right_inv := fun _ => rfl } | |
| simpa [Fintype.card_subtype] using congrArg (fun x : ℕ => (x:ℝ)) (Fintype.card_congr he) | |
| lemma insertion_moments {L t : ℕ} (hL : 0 < L) (ht : t ≤ L) : | |
| favg (fun i : Fin L => ((t + if i.val < t then 1 else 0 : ℕ):ℝ)) = | |
| (1+1/(L:ℝ))*t ∧ | |
| fvariance (fun i : Fin L => ((t + if i.val < t then 1 else 0 : ℕ):ℝ)) = | |
| (t:ℝ)*((L:ℝ)-t)/(L:ℝ)^2 := by | |
| let : Nonempty (Fin L) := Fin.pos_iff_nonempty.mp hL | |
| have hL0 : (L:ℝ) ≠ 0 := by exact_mod_cast (Nat.ne_of_gt hL) | |
| let f : Fin L → ℝ := fun i => if i.val < t then 1 else 0 | |
| have hf : favg f = (t:ℝ)/L := favg_fin_lt ht | |
| have hf2 : (fun i => f i ^ 2) = f := by funext i; simp only [f]; split_ifs <;> norm_num | |
| have he : (fun i : Fin L => ((t + if i.val < t then 1 else 0 : ℕ):ℝ)) = | |
| fun i => (t:ℝ)+f i := by funext i; simp only [Nat.cast_add,f]; split_ifs <;> norm_num | |
| have he2 : (fun i => ((t:ℝ)+f i)^2) = fun i => (t:ℝ)^2+(2*t)*f i+f i^2 := by | |
| funext i; ring | |
| rw [he] | |
| constructor | |
| · rw [favg_add,favg_const,hf]; ring | |
| · simp only [fvariance, he2, favg_add, favg_const, favg_mul, hf2, hf] | |
| field_simp | |
| ring | |
| lemma insertKernel_stop {n k : ℕ} (c : Clause n k) (r : List (Clause n k)) | |
| (hc : Harmless c r) : | |
| insertKernel c (fun s => (listStop s:ℝ)) r = | |
| (1+1/((r.length:ℝ)+1))*(listStop r:ℝ) := by | |
| unfold insertKernel | |
| have he (i : Fin (r.length+1)) := listStop_insert c r hc i (by omega) | |
| simp only [he] | |
| exact_mod_cast (insertion_moments (Nat.succ_pos _) (listStop_le r)).1 | |
| lemma insertion_variance_stop {n k : ℕ} (c : Clause n k) (r : List (Clause n k)) | |
| (hc : Harmless c r) : | |
| fvariance (fun i : Fin (r.length+1) => (listStop (r.insertIdx i c):ℝ)) = | |
| (listStop r:ℝ)*((r.length:ℝ)+1-listStop r)/((r.length:ℝ)+1)^2 := by | |
| have he (i : Fin (r.length+1)) := listStop_insert c r hc i (by omega) | |
| simp only [he] | |
| exact_mod_cast (insertion_moments (Nat.succ_pos _) (listStop_le r)).2 | |
| lemma insertVar_stop_lower {n k : ℕ} {b l : List (Clause n k)} (hb : Bystanders b l) | |
| {A C D : ℝ} (hC : 0 ≤ C) (hD : 0 < D) | |
| (hAt : A ≤ (listStop l:ℝ)) (hCt : C ≤ (l.length:ℝ)+1-listStop l) | |
| (hlen : (b.length:ℝ)+l.length+1 ≤ D) : | |
| (b.length:ℝ)*(A*C/D^2) ≤ insertVar b l (fun r => (listStop r:ℝ)) := by | |
| induction b with | |
| | nil => simp [insertVar,insertAvg] | |
| | cons c b ih => | |
| have hlen' : (b.length:ℝ)+l.length+1 ≤ D := by | |
| simp only [List.length_cons,Nat.cast_add,Nat.cast_one] at hlen | |
| linarith | |
| have hi := ih hb.2 hlen' | |
| rw [insertVar_cons] | |
| let a : ℝ := 1+1/((b.length:ℝ)+l.length+1) | |
| have ha : 1 ≤ a := by | |
| dsimp [a] | |
| have : (0:ℝ) ≤ 1/((b.length:ℝ)+l.length+1) := by positivity | |
| linarith | |
| have he : insertVar b l (insertKernel c (fun r => (listStop r:ℝ))) = | |
| a^2*insertVar b l (fun r => (listStop r:ℝ)) := by | |
| rw [←insertVar_mul] | |
| apply insertVar_congr | |
| intro r hr | |
| rw [insertKernel_stop c r (private_harmless (private_perm (inserts_perm hr).symm hb.1))] | |
| have hrlen := inserts_length hr | |
| simp only [hrlen,Nat.cast_add] | |
| rfl | |
| rw [he] | |
| have hstep : A*C/D^2 ≤ insertAvg b l (fun r => | |
| fvariance (fun i : Fin (r.length+1) => (listStop (r.insertIdx i c):ℝ))) := by | |
| rw [←insertAvg_const b l (A*C/D^2)] | |
| apply insertAvg_mono | |
| intro r hr | |
| rw [insertion_variance_stop c r | |
| (private_harmless (private_perm (inserts_perm hr).symm hb.1))] | |
| have ht := inserts_stop_bounds hb.2 hr | |
| have hrlen := inserts_length hr | |
| have hr0 : 0 < (r.length:ℝ)+1 := by positivity | |
| have ht0 : 0 ≤ (listStop r:ℝ) := by positivity | |
| have hs : 0 ≤ (r.length:ℝ)+1-listStop r := by | |
| have := listStop_le r | |
| exact sub_nonneg.mpr (by exact_mod_cast this) | |
| have hAr : A ≤ (listStop r:ℝ) := hAt.trans (by exact_mod_cast ht.1) | |
| have hCr : C ≤ (r.length:ℝ)+1-listStop r := by | |
| have ht' : (listStop r:ℝ) ≤ listStop l+b.length := by exact_mod_cast ht.2 | |
| have hrl : (r.length:ℝ) = b.length+l.length := by exact_mod_cast hrlen | |
| linarith | |
| have hrD : (r.length:ℝ)+1 ≤ D := by | |
| rw [hrlen,Nat.cast_add] | |
| exact hlen' | |
| calc | |
| _ ≤ (listStop r:ℝ)*((r.length:ℝ)+1-listStop r)/D^2 := | |
| div_le_div_of_nonneg_right (mul_le_mul hAr hCr hC ht0) (sq_nonneg D) | |
| _ ≤ _ := div_le_div_of_nonneg_left (mul_nonneg ht0 hs) | |
| (sq_pos_of_pos hr0) (by nlinarith) | |
| have hv := insertVar_nonneg b l (fun r => (listStop r:ℝ)) | |
| have ha2 : 1 ≤ a^2 := by nlinarith | |
| have hv' := mul_le_mul_of_nonneg_right ha2 hv | |
| simp only [List.length_cons,Nat.cast_add,Nat.cast_one] | |
| nlinarith | |
| end RandomKSAT | |
| end | |
| end OAI | |