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