import Mathlib
import OAI.Probability.SKBarriers.SpinGlass.FiniteLaw

namespace OAI

section

noncomputable section
open scoped BigOperators
open Classical MeasureTheory Set
namespace SK.Analytic

namespace FiniteLaw

def uniformFin (n : ℕ) (hn : 0 < n) : FiniteLaw (Fin n) where
  weight _ := 1/(n:ℝ)
  nonneg _ := by positivity
  sum_one := by
    simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
    field_simp

theorem uniformFin_prob (n : ℕ) (hn : 0 < n) (E : Fin n → Prop) :
    (uniformFin n hn).prob E=(Finset.univ.filter E).card/(n:ℝ) := by
  simp only [prob,expect,uniformFin,← Finset.mul_sum]
  rw [Finset.sum_boole]
  ring

theorem markov {n : ℕ} (P : FiniteLaw (Fin n)) (f : Fin n → ℝ) (hf : ∀ x, 0 ≤ f x)
    (c : ℝ) (_hc : 0 < c) : c*P.prob (fun x => c < f x) ≤ P.expect f := by
  rw [prob,← expect_const_mul]
  apply expect_mono
  intro x
  split_ifs with h
  · simpa only [mul_one] using h.le
  · simpa only [mul_zero] using hf x
end FiniteLaw

def thresholdGrid (n : ℕ) (a ρ : ℝ) (i : Fin n) : ℝ := a+ρ*(i:ℕ)/(n:ℝ)

theorem thresholdGrid_mem {n : ℕ} (hn : 0 < n) {ρ : ℝ} (hρ : 0 < ρ)
    (a : ℝ) (i : Fin n) : thresholdGrid n a ρ i ∈ Icc a (a+ρ) := by
  have hnR : (0:ℝ)<n := by exact_mod_cast hn
  have hi : (i:ℝ)<n := by exact_mod_cast i.isLt
  unfold thresholdGrid
  constructor
  · have : 0 ≤ ρ*(i:ℕ)/(n:ℝ) := by positivity
    linarith only [this]
  · have : ρ*(i:ℕ)/(n:ℝ) ≤ ρ := (div_le_iff₀ hnR).mpr (by gcongr)
    linarith only [this]

theorem thresholdGrid_count {n : ℕ} (hn : 0 < n) {ρ w : ℝ} (hρ : 0 < ρ) (hw : 0 ≤ w)
    (a x : ℝ) :
    ((Finset.univ.filter (fun i : Fin n => |thresholdGrid n a ρ i-x| ≤ w)).card:ℝ) ≤
      2*w*(n:ℝ)/ρ+1 := by
  let S := Finset.univ.filter (fun i : Fin n => |thresholdGrid n a ρ i-x| ≤ w)
  have hnR : (0:ℝ)<n := by exact_mod_cast hn
  by_cases hs : S.Nonempty
  · let i := S.min' hs
    let j := S.max' hs
    have hi : i∈S := Finset.min'_mem S hs
    have hj : j∈S := Finset.max'_mem S hs
    have hij : i≤j := Finset.min'_le S j hj
    have hcard : S.card ≤ (j:ℕ)+1-(i:ℕ) := by
      rw [← Fin.card_Icc]
      apply Finset.card_le_card
      intro z hz
      exact Finset.mem_Icc.mpr ⟨Finset.min'_le S z hz,Finset.le_max' S z hz⟩
    have hcard' : (S.card:ℝ) ≤ (j:ℝ)-(i:ℝ)+1 := by
      have hnat : (i:ℕ)≤(j:ℕ)+1 := by omega
      have hc : (S.card:ℝ) ≤ (((j:ℕ)+1-(i:ℕ):ℕ):ℝ) := by exact_mod_cast hcard
      rw [Nat.cast_sub hnat,Nat.cast_add,Nat.cast_one] at hc
      linarith only [hc]
    have hdi := abs_le.mp ((Finset.mem_filter.mp hi).2)
    have hdj := abs_le.mp ((Finset.mem_filter.mp hj).2)
    have hgap : ρ*((j:ℝ)-(i:ℝ)) ≤ 2*w*(n:ℝ) := by
      have H : thresholdGrid n a ρ j-thresholdGrid n a ρ i ≤ 2*w := by linarith only [hdi.1,hdj.2]
      have HH : thresholdGrid n a ρ j-thresholdGrid n a ρ i=ρ*((j:ℝ)-(i:ℝ))/(n:ℝ) := by
        unfold thresholdGrid
        ring
      rw [HH,div_le_iff₀ hnR] at H
      exact H
    have hgap' : (j:ℝ)-(i:ℝ) ≤ 2*w*(n:ℝ)/ρ := (le_div_iff₀ hρ).mpr (by nlinarith only [hgap])
    exact hcard'.trans (by linarith only [hgap'])
  · have he : S=∅ := Finset.not_nonempty_iff_eq_empty.mp hs
    change (S.card:ℝ)≤_
    rw [he,Finset.card_empty,Nat.cast_zero]
    positivity

theorem thresholdGrid_window {n : ℕ} (hn : 0 < n) {ρ w : ℝ} (hρ : 0 < ρ) (hw : 0 ≤ w)
    (a x : ℝ) :
    (FiniteLaw.uniformFin n hn).prob (fun i => |thresholdGrid n a ρ i-x| ≤ w) ≤ 2*w/ρ+1/(n:ℝ) := by
  rw [FiniteLaw.uniformFin_prob]
  have h := div_le_div_of_nonneg_right (thresholdGrid_count hn hρ hw a x) (by positivity : (0:ℝ)≤n)
  refine h.trans_eq ?_
  have hnR : (n:ℝ)≠0 := by exact_mod_cast hn.ne'
  field_simp

theorem thresholdGrid_mass_expect {n : ℕ} (hn : 0 < n) (μ : ProbabilityMeasure ℝ)
    {ρ h : ℝ} (hρ : 0 < ρ) (hh : 0 ≤ h) (a : ℝ) :
    (FiniteLaw.uniformFin n hn).expect (fun i => (μ:Measure ℝ).real
      (Icc (thresholdGrid n a ρ i-h) (thresholdGrid n a ρ i+h))) ≤ 2*h/ρ+1/(n:ℝ) := by
  let f (i : Fin n) := (Icc (thresholdGrid n a ρ i-h) (thresholdGrid n a ρ i+h)).indicator (fun _ : ℝ => (1:ℝ))
  have hi (i : Fin n) : Integrable (f i) (μ:Measure ℝ) :=
    (integrable_const 1).indicator measurableSet_Icc
  have he : (FiniteLaw.uniformFin n hn).expect (fun i => (μ:Measure ℝ).real
      (Icc (thresholdGrid n a ρ i-h) (thresholdGrid n a ρ i+h))) =
      ∫ x, (1/(n:ℝ))*∑ i, f i x ∂(μ:Measure ℝ) := by
    unfold FiniteLaw.expect FiniteLaw.uniformFin
    rw [integral_const_mul,integral_finsetSum _ (fun i _ => hi i),Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro i _
    dsimp only [f]
    rw [integral_indicator_const (1:ℝ) measurableSet_Icc]
    simp only [smul_eq_mul,mul_one]
  rw [he]
  have hb (x : ℝ) : (1/(n:ℝ))*∑ i, f i x ≤ 2*h/ρ+1/(n:ℝ) := by
    have H := thresholdGrid_window hn hρ hh a x
    change (1/(n:ℝ))*(∑ i, f i x)≤_
    convert H using 1
    unfold FiniteLaw.prob FiniteLaw.expect FiniteLaw.uniformFin
    rw [← Finset.mul_sum]
    congr 1
    apply Finset.sum_congr rfl
    intro i _
    have he : x∈Icc (thresholdGrid n a ρ i-h) (thresholdGrid n a ρ i+h) ↔ |thresholdGrid n a ρ i-x|≤h := by
      rw [Set.mem_Icc,abs_le]
      constructor <;> intro H <;> constructor <;> linarith only [H.1,H.2]
    simp only [f,Set.indicator_apply,he]
  exact (integral_mono_of_nonneg (ae_of_all _ (fun x => by
      apply mul_nonneg (by positivity)
      exact Finset.sum_nonneg (fun i _ => Set.indicator_nonneg (fun _ _ => zero_le_one) x)))
    (integrable_const _) (ae_of_all _ hb)).trans_eq (by simp)

end SK.Analytic

end
end

end OAI