File size: 5,051 Bytes
135052a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 | import OAI.Probability.SATVariance.ShuffleAverages
namespace OAI
noncomputable section
open MeasureTheory ProbabilityTheory
namespace RandomKSAT
open scoped Classical ENNReal
def listSAT {n k : ℕ} (l : List (Clause n k)) : Prop :=
∃ a : Assignment n, ∀ c ∈ l, Satisfies c a
lemma listSAT_nil (n k : ℕ) : listSAT ([] : List (Clause n k)) :=
⟨fun _ => false, by simp⟩
lemma listSAT_sublist {n k : ℕ} {l r : List (Clause n k)} (h : l.Sublist r)
(hr : listSAT r) : listSAT l := by
obtain ⟨a,ha⟩ := hr
exact ⟨a,fun c hc => ha c (h.subset hc)⟩
lemma listSAT_perm {n k : ℕ} {l r : List (Clause n k)} (h : l.Perm r) :
listSAT l ↔ listSAT r := by
constructor <;> rintro ⟨a,ha⟩ <;> refine ⟨a,fun c hc => ?_⟩
· exact ha c (h.mem_iff.mpr hc)
· exact ha c (h.mem_iff.mp hc)
def listStop {n k : ℕ} (l : List (Clause n k)) : ℕ :=
Nat.find (show ∃ m : ℕ, m = l.length+1 ∨ ¬listSAT (l.take m) from ⟨_,Or.inl rfl⟩)
lemma listStop_le {n k : ℕ} (l : List (Clause n k)) : listStop l ≤ l.length+1 :=
Nat.find_min' _ (Or.inl rfl)
lemma lt_listStop_iff {n k m : ℕ} (l : List (Clause n k)) :
m < listStop l ↔ m ≤ l.length ∧ listSAT (l.take m) := by
constructor
· intro hm
refine ⟨by have := listStop_le l; omega, ?_⟩
have hh := Nat.find_min (show ∃ j : ℕ, j = l.length+1 ∨ ¬listSAT (l.take j)
from ⟨_,Or.inl rfl⟩) hm
exact not_not.mp (fun h => hh (Or.inr h))
· rintro ⟨hm,hs⟩
apply (Nat.lt_find_iff _ _).mpr
intro j hj
rintro (he | hn)
· omega
· apply hn
exact listSAT_sublist (List.take_sublist_take_left hj) hs
lemma listStop_pos {n k : ℕ} (l : List (Clause n k)) : 0 < listStop l := by
rw [lt_listStop_iff]
exact ⟨Nat.zero_le _,by simpa using listSAT_nil n k⟩
def Harmless {n k : ℕ} (c : Clause n k) (l : List (Clause n k)) : Prop :=
∀ r, r.Sublist l → (listSAT (c::r) ↔ listSAT r)
lemma harmless_private {n k : ℕ} (c : Clause n k) (l : List (Clause n k))
(v : c.1.1) (hv : ∀ d ∈ l, v.val ∉ d.1.1) : Harmless c l := by
intro r hr
constructor
· exact listSAT_sublist (List.sublist_cons_self _ _)
· rintro ⟨a,ha⟩
refine ⟨Function.update a v.val (c.2 v), ?_⟩
intro d hd
rcases List.mem_cons.mp hd with he | hd
· subst d
exact ⟨v,by simp⟩
· obtain ⟨w,hw⟩ := ha d hd
refine ⟨w,?_⟩
have hne : w.val ≠ v.val := by
intro he
apply hv d (hr.subset hd)
exact he ▸ w.property
simpa only [Function.update_of_ne hne] using hw
lemma take_insertIdx_perm.{u_1} {α : Type u_1} (l : List α) (c : α) (i m : ℕ)
(hi : i ≤ l.length) (him : i < m) :
((l.insertIdx i c).take m).Perm (c::l.take (m-1)) := by
induction l generalizing i m with
| nil =>
have : i = 0 := by simpa using hi
subst i
cases m with
| zero => omega
| succ m => simp
| cons a l ih =>
cases i with
| zero =>
cases m with
| zero => omega
| succ m => simp
| succ i =>
cases m with
| zero => omega
| succ m =>
have hi' : i ≤ l.length := by simpa using hi
have him' : i < m := by omega
have hh := (ih i m hi' him').cons a
have hm : 0 < m := by omega
cases m with
| zero => omega
| succ m =>
simpa only [List.insertIdx_succ_cons, List.take_succ_cons, Nat.add_sub_cancel,
Nat.succ_sub_one] using hh.trans (List.Perm.swap c a _)
lemma listSAT_insert_take {n k : ℕ} (c : Clause n k) (l : List (Clause n k))
(hc : Harmless c l) (i m : ℕ) (hi : i ≤ l.length) :
listSAT ((l.insertIdx i c).take m) ↔
listSAT (l.take (m - if i < m then 1 else 0)) := by
by_cases him : i < m
· rw [ite_eq_left him, listSAT_perm (take_insertIdx_perm l c i m hi him)]
exact hc _ (List.take_sublist _ _)
· rw [ite_eq_right him, Nat.sub_zero, List.take_insertIdx_eq_take_of_le _ _ m i (by omega)]
lemma listStop_insert {n k : ℕ} (c : Clause n k) (l : List (Clause n k))
(hc : Harmless c l) (i : ℕ) (hi : i ≤ l.length) :
listStop (l.insertIdx i c) = listStop l + if i < listStop l then 1 else 0 := by
apply eq_of_forall_lt_iff
intro m
have hl : (l.insertIdx i c).length = l.length+1 := List.length_insertIdx_of_le_length hi c
rw [lt_listStop_iff, hl, listSAT_insert_take c l hc i m hi]
have ht := listStop_le l
by_cases hm : m ≤ l.length+1
· simp only [hm, true_and]
have hr : m - (if i < m then 1 else 0) ≤ l.length := by split_ifs <;> omega
have he := lt_listStop_iff (m := m - (if i < m then 1 else 0)) l
rw [and_iff_right hr] at he
rw [← he]
split_ifs <;> omega
· simp only [hm, false_and]
constructor
· exact False.elim
· intro h
have hb : listStop l + (if i < listStop l then 1 else 0) ≤ l.length+2 := by
have hx : (if i < listStop l then 1 else 0) ≤ (1 : ℕ) := by split_ifs <;> omega
omega
omega
end RandomKSAT
end
end OAI
|