import Mathlib
import OAI.Probability.SKGap.Model

namespace OAI

section
noncomputable section
open MeasureTheory ProbabilityTheory InformationTheory Real Set Filter
open scoped NNReal ENNReal Topology
noncomputable section
open Real Set
noncomputable section
open MeasureTheory ProbabilityTheory Real Set Filter
open scoped Topology NNReal ENNReal BoundedContinuousFunction
open MeasureTheory ProbabilityTheory Filter Set Topology Real
open scoped NNReal ENNReal BoundedContinuousFunction
noncomputable section
open Set Filter Topology
noncomputable section
open MeasureTheory ProbabilityTheory Filter Set Topology Real
open scoped NNReal ENNReal BoundedContinuousFunction
namespace SKGap

variable {ι : Type*} [Fintype ι]

def normalLogConst (d s : ℝ) : ℝ := -log (sqrt (2*Real.pi*s))-d^2/(2*s)

def normalLogDensity (d s x : ℝ) : ℝ := normalLogConst d s+d/s*x-x^2/(2*s)

lemma exp_normalLogDensity (d : ℝ) {s : ℝ} (hs : 0 < s) (x : ℝ) :
    exp (normalLogDensity d s x) = gaussianPDFReal d s.toNNReal x := by
  have hsp : 0 < sqrt (2*Real.pi*s) := sqrt_pos.mpr (by positivity)
  have he : normalLogDensity d s x = -log (sqrt (2*Real.pi*s)) - (x-d)^2/(2*s) := by
    unfold normalLogDensity normalLogConst
    field_simp
    ring
  rw [he, sub_eq_add_neg, exp_add, exp_neg, exp_log hsp]
  simp only [gaussianPDFReal, Real.coe_toNNReal s hs.le]
  congr 1
  congr 1
  ring

lemma continuousOn_normalLogConst : ContinuousOn (fun p : ℝ×ℝ => normalLogConst p.1 p.2)
    {p | 0 < p.2} := by
  unfold normalLogConst
  apply ContinuousOn.sub
  · apply ContinuousOn.neg
    apply ContinuousOn.log
    · fun_prop
    · intro p hp
      have hp' : 0 < p.2 := hp
      exact (sqrt_pos.mpr (by positivity : 0 < 2*Real.pi*p.2)).ne'
  · exact (continuous_fst.pow 2).continuousOn.div (continuous_const.mul continuous_snd).continuousOn
      (fun p hp => mul_ne_zero (by norm_num) (ne_of_gt hp))

lemma normalLogDensity_sub_le (d' s' d s x : ℝ) :
    normalLogDensity d' s' x-normalLogDensity d s x ≤
      |normalLogConst d' s'-normalLogConst d s| + |d'/s'-d/s| *|x| +
        |1/(2*s')-1/(2*s)| *x^2 := by
  have hx := le_abs_self ((d'/s'-d/s)*x)
  rw [abs_mul] at hx
  have hq := neg_le_abs (1/(2*s')-1/(2*s))
  have hm := mul_le_mul_of_nonneg_right hq (sq_nonneg x)
  have hc := le_abs_self (normalLogConst d' s'-normalLogConst d s)
  have he : normalLogDensity d' s' x-normalLogDensity d s x =
      (normalLogConst d' s'-normalLogConst d s)+(d'/s'-d/s)*x -
        (1/(2*s')-1/(2*s))*x^2 := by
    unfold normalLogDensity
    ring
  rw [he]
  linarith

lemma normalLogDensity_sum_sub_le {y : ι → ℝ} {R : ℝ}
    (hy : ∑ i, (y i)^2 ≤ (Fintype.card ι : ℝ)*R) (d' s' d s : ℝ) :
    (∑ i, normalLogDensity d' s' (y i))-(∑ i, normalLogDensity d s (y i)) ≤
      (Fintype.card ι : ℝ) * (|normalLogConst d' s'-normalLogConst d s| +
        |d'/s'-d/s| *(1+R)+|1/(2*s')-1/(2*s)| *R) := by
  have hl : ∑ i, |y i| ≤ (Fintype.card ι : ℝ)*(1+R) := by
    calc
      _ ≤ ∑ i, (1+(y i)^2) := Finset.sum_le_sum (fun i _ => by
        nlinarith [sq_abs (y i), sq_nonneg (|y i|-1)])
      _ = (Fintype.card ι : ℝ) + ∑ i, (y i)^2 := by simp [Finset.sum_add_distrib]
      _ ≤ _ := by nlinarith
  have hh := Finset.sum_le_sum (s := Finset.univ) (fun i _ => normalLogDensity_sub_le d' s' d s (y i))
  simp only [Finset.sum_sub_distrib, Finset.sum_add_distrib, Finset.sum_const, Finset.card_univ,
    nsmul_eq_mul, ← Finset.mul_sum] at hh
  have h1 := mul_le_mul_of_nonneg_left hl (abs_nonneg (d'/s'-d/s))
  have h2 := mul_le_mul_of_nonneg_left hy (abs_nonneg (1/(2*s')-1/(2*s)))
  calc
    _ ≤ _ := hh
    _ ≤ _ := by nlinarith

def productNormal (d s : ℝ) (y : ι → ℝ) : ℝ := ∏ i, gaussianPDFReal d s.toNNReal (y i)

lemma productNormal_eq_exp (d : ℝ) {s : ℝ} (hs : 0 < s) (y : ι → ℝ) :
    productNormal d s y = exp (∑ i, normalLogDensity d s (y i)) := by
  rw [exp_sum]
  unfold productNormal
  apply Finset.prod_congr rfl
  intro i hi
  exact (exp_normalLogDensity d hs (y i)).symm

lemma productNormal_nonneg (d s : ℝ) (y : ι → ℝ) : 0 ≤ productNormal d s y :=
  Finset.prod_nonneg (fun i _ => gaussianPDFReal_nonneg d s.toNNReal (y i))

lemma integrable_tiltedNormal (f : ℝ →ᵇ ℝ) (d : ℝ) (s : ℝ≥0) :
    Integrable (fun x => exp (f x)*gaussianPDFReal d s x) := by
  have h := (integrable_gaussianPDFReal d s).bdd_mul
    (continuous_exp.comp f.continuous).aestronglyMeasurable
    (c := exp ‖f‖) (ae_of_all _ (fun x => by
      dsimp only [Function.comp_def]
      rw [Real.norm_eq_abs, abs_of_pos (exp_pos _)]
      exact exp_le_exp.mpr ((le_abs_self _).trans (f.norm_coe_le_norm x))))
  exact h

lemma integral_tiltedNormal (f : ℝ →ᵇ ℝ) (d : ℝ) {s : ℝ≥0} (hs : s ≠ 0) :
    (∫ x, exp (f x)*gaussianPDFReal d s x) = ∫ x, exp (f x) ∂gaussianReal d s := by
  rw [integral_gaussianReal_eq_integral_smul hs]
  simp only [smul_eq_mul, mul_comm]

lemma tiltedNormal_mass_pos (f : ℝ →ᵇ ℝ) (d : ℝ) (s : ℝ≥0) :
    0 < ∫ x, exp (f x) ∂gaussianReal d s := by
  have hi : Integrable (fun x => exp (f x)) (gaussianReal d s) := Integrable.of_bound
    (by fun_prop) (exp ‖f‖) (ae_of_all _ (fun x => by
      rw [Real.norm_eq_abs, abs_of_pos (exp_pos _)]
      exact exp_le_exp.mpr ((le_abs_self _).trans (f.norm_coe_le_norm x))))
  exact integral_pos_iff_support_of_nonneg (fun _ => (exp_pos _).le) hi |>.mpr
    (by simp [Function.support, (exp_pos _).ne'])

lemma product_tiltedNormal_integral (f : ℝ →ᵇ ℝ) (d : ℝ) {s : ℝ} (hs : 0 < s) :
    (∫ y : ι → ℝ, exp (∑ i, f (y i))*productNormal d s y) =
      exp ((Fintype.card ι : ℝ)*log (∫ x, exp (f x) ∂gaussianReal d s.toNNReal)) := by
  have hs' : s.toNNReal ≠ 0 := ne_of_gt (Real.toNNReal_pos.mpr hs)
  have he (y : ι → ℝ) : exp (∑ i, f (y i))*productNormal d s y =
      ∏ i, (exp (f (y i))*gaussianPDFReal d s.toNNReal (y i)) := by
    rw [exp_sum, productNormal, Finset.prod_mul_distrib]
  simp_rw [he]
  rw [integral_fintype_prod_volume_eq_pow (fun x : ℝ => exp (f x)*gaussianPDFReal d s.toNNReal x), integral_tiltedNormal f d hs',
    exp_nat_mul, exp_log (tiltedNormal_mass_pos f d s.toNNReal)]

lemma product_tiltedNormal_integrable (f : ℝ →ᵇ ℝ) (d s : ℝ) :
    Integrable (fun y : ι → ℝ => exp (∑ i, f (y i))*productNormal d s y) := by
  have h := Integrable.fintype_prod (fun _ : ι => integrable_tiltedNormal f d s.toNNReal)
  simpa only [exp_sum, productNormal, Finset.prod_mul_distrib, volume_pi] using h

end SKGap

namespace SKGap

def normalDensityError (R d s d₀ s₀ : ℝ) : ℝ :=
  |normalLogConst d s-normalLogConst d₀ s₀| + |d/s-d₀/s₀| * (1+R) +
    |1/(2*s)-1/(2*s₀)| * R

lemma normalDensityError_self (R d s : ℝ) : normalDensityError R d s d s = 0 := by
  simp [normalDensityError]

lemma continuous_normalDensityError {X : Type*} [TopologicalSpace X]
    {d s : X → ℝ} (hd : Continuous d) (hs : Continuous s) (hspos : ∀ x, 0 < s x)
    (R d₀ s₀ : ℝ) : Continuous (fun x => normalDensityError R (d x) (s x) d₀ s₀) := by
  have hlog : Continuous (fun x => normalLogConst (d x) (s x)) :=
    continuousOn_normalLogConst.comp_continuous (hd.prodMk hs) (fun x => hspos x)
  have hdiv := hd.div hs (fun x => (hspos x).ne')
  have hinv : Continuous (fun x => (1 : ℝ)/(2*s x)) := continuous_const.div (continuous_const.mul hs) (fun x => mul_ne_zero (by norm_num) (hspos x).ne')
  exact ((hlog.sub continuous_const).abs.add ((hdiv.sub continuous_const).abs.mul continuous_const)).add
    ((hinv.sub continuous_const).abs.mul continuous_const)

theorem finite_gaussian_test_cover {X : Type*} [TopologicalSpace X] {K : Set X}
    (hK : IsCompact K) {P : X → ProbabilityMeasure ℝ} {d s ψ : X → ℝ}
    (hP : ContinuousOn P K) (hd : ContinuousOn d K) (hs : ContinuousOn s K)
    (hψ : ContinuousOn ψ K) (hpos : ∀ x ∈ K, 0 < s x) (R r : ℝ)
    (hW : ∀ x ∈ K, ∃ f : ℝ →ᵇ ℝ, ψ x-(∫ y, f y ∂P x)+
      log (∫ y, exp (f y) ∂gaussianReal (d x) (s x).toNNReal) < r) :
    ∃ (C : Finset K) (f : K → ℝ →ᵇ ℝ), ∀ z ∈ K, ∃ x ∈ C,
      ψ z-(∫ y, f x y ∂P z)+normalDensityError R (d z) (s z) (d x) (s x)+
      log (∫ y, exp (f x y) ∂gaussianReal (d x) (s x).toNNReal) < r := by
  classical
  let : CompactSpace K := isCompact_iff_compactSpace.mp hK
  choose f hf using (fun x : K => hW x.1 x.2)
  let U (x : K) : Set K := {z | ψ z-(∫ y, f x y ∂P z)+
    normalDensityError R (d z) (s z) (d x) (s x)+
      log (∫ y, exp (f x y) ∂gaussianReal (d x) (s x).toNNReal) < r}
  have hU (x : K) : IsOpen (U x) := by
    apply isOpen_lt _ continuous_const
    have hint : Continuous (fun z : K => ∫ y, f x y ∂P z) :=
      (ProbabilityMeasure.continuous_integral_boundedContinuousFunction (f x)).comp hP.domRestrict
    exact ((hψ.domRestrict.sub hint).add
      (continuous_normalDensityError hd.domRestrict hs.domRestrict
        (fun z : K => hpos z.1 z.2) R (d x) (s x))).add continuous_const
  have hcov : (univ : Set K) ⊆ ⋃ x : K, U x := by
    intro z _
    refine mem_iUnion.mpr ⟨z, ?_⟩
    change ψ z-(∫ y, f z y ∂P z)+normalDensityError R (d z) (s z) (d z) (s z)+
      log (∫ y, exp (f z y) ∂gaussianReal (d z) (s z).toNNReal) < r
    simpa only [normalDensityError_self, add_zero] using hf z
  obtain ⟨C,hC⟩ := isCompact_univ.elim_finite_subcover U hU hcov
  refine ⟨C,f,?_⟩
  intro z hz
  have hh := hC (mem_univ (⟨z,hz⟩ : K))
  obtain ⟨x,hx⟩ := mem_iUnion.mp hh
  obtain ⟨hxC,hxU⟩ := mem_iUnion.mp hx
  exact ⟨x,hxC,hxU⟩

end SKGap
noncomputable section
open MeasureTheory ProbabilityTheory Filter Set Topology Real
open scoped NNReal ENNReal BoundedContinuousFunction

end
end
end
end
end
end
end

end OAI