import OAI.Probability.SATVariance.PairEvolution

namespace OAI

noncomputable section

open MeasureTheory ProbabilityTheory

namespace RandomKSAT

open scoped Classical ENNReal

def familyKill.{u_1} {u s : ℕ} {ι : Type u_1} [Fintype ι]
    (S : Finset (Assignment u)) (cs : ι → Clause u s) : ℝ :=
  if ∃ b ∈ S, ∀ i, Satisfies (cs i) b then 0 else 1

lemma familyKill_nonneg.{u_1} {u s : ℕ} {ι : Type u_1} [Fintype ι]
    (S : Finset (Assignment u)) (cs : ι → Clause u s) : 0 ≤ familyKill S cs := by
  unfold familyKill
  split <;> norm_num

lemma familyKill_le_one.{u_1} {u s : ℕ} {ι : Type u_1} [Fintype ι]
    (S : Finset (Assignment u)) (cs : ι → Clause u s) : familyKill S cs ≤ 1 := by
  unfold familyKill
  split <;> norm_num

lemma familyKill_residual.{u_1} {u s : ℕ} {ι : Type u_1} [Fintype ι]
    (S : Finset (Assignment u)) (cs : ι → Clause u s) :
    familyKill S cs = 1-alive u (residual S cs) := by
  have he : (residual S cs).Nonempty ↔ ∃ b ∈ S, ∀ i, Satisfies (cs i) b := by
    simp only [Finset.Nonempty, residual, Finset.mem_filter]
  unfold familyKill alive
  simp only [he]
  split <;> norm_num

lemma familyKill_equiv.{u_1, u_2} {u s : ℕ} {ι : Type u_1} {κ : Type u_2} [Fintype ι] [Fintype κ]
    (S : Finset (Assignment u)) (cs : κ → Clause u s) (e : ι ≃ κ) :
    familyKill S (fun i => cs (e i)) = familyKill S cs := by
  have he : (∃ b ∈ S, ∀ i, Satisfies (cs (e i)) b) ↔ ∃ b ∈ S, ∀ i, Satisfies (cs i) b := by
    constructor
    · rintro ⟨b,hb,hi⟩
      exact ⟨b,hb, fun j => by simpa using hi (e.symm j)⟩
    · rintro ⟨b,hb,hi⟩
      exact ⟨b,hb, fun j => hi (e j)⟩
  simp only [familyKill, he]

lemma familyKill_avg_fin {u s : ℕ} (hsu : s ≤ u) (S : Finset (Assignment u)) (m : ℕ) :
    favg (fun cs : Fin m → Clause u s => familyKill S cs) = blockKill u s S m := by
  let := clause_nonempty u s hsu
  simp_rw [familyKill_residual]
  rw [favg_sub, favg_const, blockKill_iterate hsu, clauseStep_iterate_avg]

lemma familyKill_avg.{u_1} {u s : ℕ} {ι : Type u_1} [Fintype ι] (hsu : s ≤ u)
    (S : Finset (Assignment u)) :
    favg (fun cs : ι → Clause u s => familyKill S cs) = blockKill u s S (Fintype.card ι) := by
  let e := (Fintype.equivFin ι).symm.arrowCongr (Equiv.refl (Clause u s))
  rw [← favg_equiv e]
  have he (cs : Fin (Fintype.card ι) → Clause u s) :
      familyKill S (e cs) = familyKill S cs :=
    familyKill_equiv S cs (Fintype.equivFin ι)
  simp_rw [he]
  exact familyKill_avg_fin hsu S _

lemma blockKill_mono_length {u s : ℕ} (hsu : s ≤ u) (S : Finset (Assignment u)) :
    Monotone (blockKill u s S) := by
  let := streamLaw_probability u s hsu
  intro m d hmd
  unfold blockKill
  apply ENNReal.toReal_mono (measure_ne_top _ _)
  apply measure_mono
  intro ω hm hd
  rcases hd with ⟨b,hb,ht⟩
  exact hm ⟨b,hb,fun i hi => ht i (lt_of_lt_of_le hi hmd)⟩

lemma restricted_familyKill_avg.{u_1} {u s : ℕ} {ι : Type u_1} [Fintype ι] [DecidableEq ι]
    (hsu : s ≤ u) (S : Finset (Assignment u)) (A : Finset ι) :
    favg (fun cs : ι → Clause u s => familyKill S (fun i : A => cs i)) =
      blockKill u s S A.card := by
  let := clause_nonempty u s hsu
  rw [favg_pi_restrict (fun i => i ∈ A) (familyKill S)]
  convert (familyKill_avg (ι := A) hsu S) using 1
  · congr 1
    exact Subsingleton.elim _ _
  · rw [Fintype.card_coe]

def testIndices {u k M : ℕ} (a : Assignment k) (env : Fin M → RootData u k)
    (m : ℕ) (j : Fin k) : Finset (Fin M) :=
  Finset.univ.filter fun i => i.val < m ∧ TestAt a (env i) j

lemma forcedPrefix_familyKill {u k M : ℕ} (a : Assignment k) (env : Fin M → RootData u k)
    (o : Fin M → Clause u k) (ys : Fin k → Fin M → Clause u (k-1)) (m : ℕ)
    (hforced : ∀ x ∈ pairPrefix Finset.univ
      (fun i => refreshData a (env i) (o i, fun j => ys j i)) m, x.1 = a)
    (j : Fin k) (hj : Available a env j) :
    familyKill (fibrePrefix a env o m) (fun i : testIndices a env m j => ys j i) = 1 := by
  unfold familyKill
  rw [ite_eq_right]
  rintro ⟨b,hb,ht⟩
  apply forcedPrefix_testKills a env o ys m hforced j hj
  refine ⟨b,hb,fun i hi hit => ?_⟩
  exact ht ⟨i, by simp [testIndices, hi, hit]⟩

lemma prod_filter_indicator.{u_1} {ι : Type u_1} [Fintype ι] [DecidableEq ι] (A : Finset ι) (q : ℝ) :
    (∏ j : ι, if j ∈ A then q else 1) = q^A.card := by
  classical
  rw [← Finset.prod_filter]
  simp

lemma forcedPrefix_probability {u k M d : ℕ} (hku : k ≤ u) (a : Assignment k)
    (env : Fin M → RootData u k) (o : Fin M → Clause u k) (m : ℕ)
    (J : Finset (Fin k)) (hJ : ∀ j ∈ J, Available a env j)
    (hd : ∀ j, (testIndices a env m j).card ≤ d) :
    favg (fun ys : Fin k → Fin M → Clause u (k-1) =>
      forcedReward a (pairPrefix Finset.univ
        (fun i => refreshData a (env i) (o i, fun j => ys j i)) m)) ≤
          alive u (fibrePrefix a env o m) * blockKill u (k-1) (fibrePrefix a env o m) d ^ J.card := by
  let := clause_nonempty u (k-1) (by omega)
  let S := fibrePrefix a env o m
  let q := blockKill u (k-1) S d
  let F (j : Fin k) (w : Fin M → Clause u (k-1)) : ℝ :=
    if j ∈ J then familyKill S (fun i : testIndices a env m j => w i) else 1
  have hF : ∀ j w, 0 ≤ F j w := by
    intro j w
    dsimp only [F]
    split
    · exact familyKill_nonneg _ _
    · norm_num
  have hp (ys : Fin k → Fin M → Clause u (k-1)) :
      forcedReward a (pairPrefix Finset.univ
        (fun i => refreshData a (env i) (o i, fun j => ys j i)) m) ≤
          alive u S * ∏ j, F j (ys j) := by
    unfold forcedReward
    split_ifs with h
    · have hprod : (∏ j, F j (ys j)) = 1 := by
        apply Finset.prod_eq_one
        intro j _
        dsimp only [F]
        split_ifs with hj
        · exact forcedPrefix_familyKill a env o ys m h.2 j (hJ j hj)
        · rfl
      rw [hprod, mul_one]
      have hh := forcedReward_le_alive a (pairPrefix Finset.univ
        (fun i => refreshData a (env i) (o i, fun j => ys j i)) m)
      rw [fibre_pairPrefix_refresh] at hh
      simpa only [forcedReward, ite_eq_left h] using hh
    · exact mul_nonneg (alive_nonneg _ _) (Finset.prod_nonneg fun j _ => hF j _)
  have havg (j : Fin k) : favg (F j) ≤ if j ∈ J then q else 1 := by
    by_cases hj : j ∈ J
    · simp only [F, ite_eq_left hj]
      rw [restricted_familyKill_avg (by omega)]
      exact blockKill_mono_length (by omega) S (hd j)
    · simp only [F, ite_eq_right hj, favg_const, le_refl]
  calc
    _ ≤ favg (fun ys : Fin k → Fin M → Clause u (k-1) => alive u S * ∏ j, F j (ys j)) :=
      favg_mono hp
    _ = alive u S * ∏ j, favg (F j) := by rw [favg_mul, favg_pi_product]
    _ ≤ alive u S * ∏ j : Fin k, if j ∈ J then q else 1 := by
      apply mul_le_mul_of_nonneg_left _ (alive_nonneg _ _)
      exact Finset.prod_le_prod₀ (fun j _ => favg_nonneg (hF j)) (fun j _ => havg j)
    _ = _ := by rw [prod_filter_indicator]

end RandomKSAT

end

end OAI