import OAI.Probability.SATComputability.VariableDeletion
import OAI.Probability.DilutedSpin.FiniteLaw

namespace OAI

namespace FixedClauseThreshold.Computability

open Finset
open DilutedSpinGlass
open scoped BigOperators

def allowedDeletions (n r : ℕ) : Finset (Finset (Fin n)) :=
  univ.filter (fun D => D.card ≤ r)

theorem allowedDeletions_nonempty (n r : ℕ) : (allowedDeletions n r).Nonempty :=
  ⟨∅, by simp [allowedDeletions]⟩

noncomputable def bestDeletionTime {n : ℕ} (t : Finset (Fin n) → ℝ) (r : ℕ) : ℝ :=
  (allowedDeletions n r).sup' (allowedDeletions_nonempty n r) t

noncomputable def freeDeletionTime {n : ℕ} (t : Finset (Fin n) → ℝ)
    (r : ℕ) (v : Fin n) : ℝ :=
  (allowedDeletions n r).sup' (allowedDeletions_nonempty n r) (fun D => t (insert v D))

theorem bestDeletionTime_mono {n : ℕ} (t : Finset (Fin n) → ℝ) :
    Monotone (bestDeletionTime t) := by
  intro r s hrs
  apply Finset.sup'_le
  intro D hD
  apply Finset.le_sup'
  simp only [allowedDeletions, Finset.mem_filter, Finset.mem_univ, true_and] at hD ⊢
  exact hD.trans hrs

theorem bestDeletionTime_le_free {n : ℕ} {t : Finset (Fin n) → ℝ}
    (ht : Monotone t) (r : ℕ) (v : Fin n) :
    bestDeletionTime t r ≤ freeDeletionTime t r v := by
  apply Finset.sup'_le
  intro D hD
  apply (ht (Finset.subset_insert v D)).trans
  exact Finset.le_sup' (fun E => t (insert v E)) hD

theorem freeDeletionTime_le_next {n : ℕ} (t : Finset (Fin n) → ℝ)
    (r : ℕ) (v : Fin n) :
    freeDeletionTime t r v ≤ bestDeletionTime t (r+1) := by
  apply Finset.sup'_le
  intro D hD
  apply Finset.le_sup'
  simp only [allowedDeletions, Finset.mem_filter, Finset.mem_univ, true_and] at hD ⊢
  exact (Finset.card_insert_le _ _).trans (Nat.add_le_add_right hD 1)

theorem freeDeletionTime_eq_at_max {n r : ℕ} (t : Finset (Fin n) → ℝ)
    (hr : 1 ≤ r) {D : Finset (Fin n)} (hD : D.card = r)
    (hmax : bestDeletionTime t r = t D) {v : Fin n} (hv : v ∈ D) :
    freeDeletionTime t (r-1) v = bestDeletionTime t r := by
  apply le_antisymm
  · simpa only [Nat.sub_add_cancel hr] using freeDeletionTime_le_next t (r-1) v
  · rw [hmax]
    have he : D.erase v ∈ allowedDeletions n (r-1) := by
      simp only [allowedDeletions, Finset.mem_filter, Finset.mem_univ, true_and,
        Finset.card_erase_of_mem hv, hD, le_refl]
    have h := Finset.le_sup' (fun E => t (insert v E)) he
    simpa only [freeDeletionTime, Finset.insert_erase hv] using h

theorem deletion_increment_rpow {n r : ℕ} {t : Finset (Fin n) → ℝ}
    (ht : Monotone t) (hr : 1 ≤ r) {p : ℝ} (hp : 0 < p) :
    (r : ℝ) * (bestDeletionTime t r - bestDeletionTime t (r-1))^p ≤
      ∑ v : Fin n, (freeDeletionTime t (r-1) v - bestDeletionTime t (r-1))^p := by
  obtain ⟨D, hD, hmax⟩ := Finset.exists_mem_eq_sup'
    (allowedDeletions_nonempty n r) t
  change bestDeletionTime t r = t D at hmax
  have hcard : D.card ≤ r := by simpa only [allowedDeletions, Finset.mem_filter,
    Finset.mem_univ, true_and] using hD
  have hnonneg (v : Fin n) :
      0 ≤ freeDeletionTime t (r-1) v - bestDeletionTime t (r-1) :=
    sub_nonneg.mpr (bestDeletionTime_le_free ht (r-1) v)
  by_cases hsmall : D.card < r
  · have he : D ∈ allowedDeletions n (r-1) := by
      simp only [allowedDeletions, Finset.mem_filter, Finset.mem_univ, true_and]
      omega
    have hle : bestDeletionTime t r ≤ bestDeletionTime t (r-1) := by
      rw [hmax]
      exact Finset.le_sup' t he
    have heq := le_antisymm hle (bestDeletionTime_mono t (Nat.sub_le r 1))
    rw [heq, sub_self, Real.zero_rpow hp.ne', mul_zero]
    exact Finset.sum_nonneg (fun v _ => Real.rpow_nonneg (hnonneg v) _)
  · have hcard' : D.card = r := by omega
    calc
      _ = ∑ v ∈ D, (bestDeletionTime t r - bestDeletionTime t (r-1))^p := by
        simp only [Finset.sum_const, nsmul_eq_mul, hcard']
      _ = ∑ v ∈ D, (freeDeletionTime t (r-1) v - bestDeletionTime t (r-1))^p := by
        apply Finset.sum_congr rfl
        intro v hv
        rw [freeDeletionTime_eq_at_max t hr hcard' hmax hv]
      _ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ D)
        (fun v _ _ => Real.rpow_nonneg (hnonneg v) _)

theorem mean_deletion_increment {Ω : Type*} [Fintype Ω] (P : FiniteLaw Ω)
    {n r : ℕ} (t : Ω → Finset (Fin n) → ℝ) (ht : ∀ ω, Monotone (t ω))
    (hr : 1 ≤ r) {p C : ℝ} (hp : 1 ≤ p)
    (hmoment : ∀ v : Fin n, P.expect (fun ω =>
      (freeDeletionTime (t ω) (r-1) v - bestDeletionTime (t ω) (r-1))^p) ≤ C) :
    P.expect (fun ω => bestDeletionTime (t ω) r - bestDeletionTime (t ω) (r-1)) ≤
      ((n : ℝ) * C / r) ^ (1/p) := by
  let delta := fun ω => bestDeletionTime (t ω) r - bestDeletionTime (t ω) (r-1)
  have hd (ω : Ω) : 0 ≤ delta ω :=
    sub_nonneg.mpr (bestDeletionTime_mono (t ω) (Nat.sub_le r 1))
  have hpow : (r : ℝ) * P.expect (fun ω => (delta ω)^p) ≤ n*C := by
    have hi := P.expect_mono (fun ω => deletion_increment_rpow (ht ω) hr
      (show 0 < p by linarith))
    rw [FiniteLaw.expect_mul_left, FiniteLaw.expect_fintype_sum] at hi
    apply hi.trans
    have hs := Finset.sum_le_sum (fun v (_ : v ∈ (Finset.univ : Finset (Fin n))) =>
      hmoment v)
    simpa only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] using hs
  have hr0 : (0 : ℝ) < r := by exact_mod_cast (Nat.zero_lt_of_lt hr)
  have hi : P.expect (fun ω => (delta ω)^p) ≤ (n : ℝ)*C/r :=
    (le_div_iff₀ hr0).mpr (by simpa only [mul_comm] using hpow)
  have hm := Real.arith_mean_le_rpow_mean Finset.univ P.weight delta
    (fun ω _ => P.nonneg ω) P.total (fun ω _ => hd ω) hp
  change P.expect delta ≤ _ at hm
  apply hm.trans
  exact Real.rpow_le_rpow (P.expect_nonneg (fun ω => Real.rpow_nonneg (hd ω) p)) hi
    (by positivity)

end FixedClauseThreshold.Computability

end OAI