import Mathlib
import OAI.Computability.MinUncut.Estimates.ExpectResampleRow

namespace OAI

section
noncomputable section
open scoped BigOperators
namespace MinUncut.BoxGaussian
open MeasureTheory ProbabilityTheory GaussianHermite
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def singletonEmbed (x : ι) : Unit → ι := fun _ => x
omit [Fintype ι] [DecidableEq ι] in
lemma singletonEmbed_injective (x : ι) : Function.Injective (singletonEmbed x) := by
  intro a b _
  exact Subsingleton.elim a b

omit [Fintype ι] in
lemma update_join_singleton (x : ι) (C : Unit → ℝ) (D : Outside (singletonEmbed x) → ℝ) (t : ℝ) :
    Function.update (join (singletonEmbed x) (singletonEmbed_injective x) C D) x t =
      join (singletonEmbed x) (singletonEmbed_injective x) (fun _ => t) D := by
  funext y
  by_cases hy : y=x
  · subst y
    simpa only [Function.update_self, singletonEmbed] using
      (join_at (singletonEmbed x) (singletonEmbed_injective x) (fun _ => t) D Unit.unit).symm
  · rw [Function.update_of_ne hy]
    have hout : y∉Set.range (singletonEmbed x) := by
      rintro ⟨a,ha⟩
      exact hy ha.symm
    rw [join_other _ _ _ _ ⟨y,hout⟩,join_other _ _ _ _ ⟨y,hout⟩]

lemma integral_singleton (v : ℝ → ℝ) :
    (∫ C : Unit → ℝ, v (C Unit.unit) ∂γpi Unit) = ∫ t, v t ∂γ := by
  exact (measurePreserving_funUnique γ Unit).integral_comp
    (MeasurableEquiv.funUnique Unit ℝ).measurableEmbedding v

lemma centered_resample_memLp (x : ι) (u : (ι → ℝ) → ℝ) (hu : Measurable u)
    {A : ℝ} (hA : 0≤A) :
    MemLp (fun C => Slice.centeredClip γ A (fun t => u (Function.update C x t)) (C x)) 2 (γpi ι) := by
  have hupdate : Measurable (fun p : (ι → ℝ) × ℝ => Function.update p.1 x p.2) := by
    apply Measurable.of_eval
    intro y
    by_cases hy : y=x
    · subst y
      simpa only [Function.update_self, singletonEmbed] using measurable_snd
    · simp only [Function.update_of_ne hy]
      exact (measurable_pi_apply y).comp measurable_fst
  have hm : Measurable (fun p : (ι → ℝ) × ℝ => Slice.clip A (u (Function.update p.1 x p.2))) :=
    (measurable_const.max ((hu.comp hupdate).min measurable_const))
  have hmean : Measurable (fun C => ∫ t, Slice.clip A (u (Function.update C x t)) ∂γ) :=
    hm.stronglyMeasurable.integral_prod_right.measurable
  have hd : Measurable (fun C => Slice.centeredClip γ A (fun t => u (Function.update C x t)) (C x)) := by
    unfold Slice.centeredClip
    simp only [Function.update_eq_self]
    exact (measurable_const.max (hu.min measurable_const)).sub hmean
  apply MemLp.of_bound hd.aestronglyMeasurable (2*A)
  filter_upwards [] with C
  rw [Real.norm_eq_abs]
  unfold Slice.centeredClip
  exact (abs_sub _ _).trans (by
    have hc := Slice.clip_abs_le hA (u (Function.update C x (C x)))
    have hm : |∫ t, Slice.clip A (u (Function.update C x t)) ∂γ|≤A := by
      refine (abs_integral_le_integral_abs).trans ?_
      exact (integral_mono_of_nonneg (ae_of_all _ (fun _ => abs_nonneg _))
        (integrable_const A) (ae_of_all _ (fun t => Slice.clip_abs_le hA _))).trans_eq
          (by simp)
    linarith)

omit [DecidableEq ι] in
lemma integral_split_le {κ : Type*} [Fintype κ] (μ : Measure ℝ) [SigmaFinite μ]
    (e : κ → ι) (he : Function.Injective e) (u v : (ι → ℝ) → ℝ)
    (hu : Integrable u (Measure.pi (fun _ : ι => μ)))
    (hv : Integrable v (Measure.pi (fun _ : ι => μ))) {a : ℝ}
    (h : ∀ D : Outside e → ℝ,
      (∫ C : κ → ℝ, u (join e he C D) ∂Measure.pi (fun _ : κ => μ)) ≤
      a*(∫ C : κ → ℝ, v (join e he C D) ∂Measure.pi (fun _ : κ => μ))) :
    (∫ C, u C ∂Measure.pi (fun _ : ι => μ)) ≤ a*(∫ C, v C ∂Measure.pi (fun _ : ι => μ)) := by
  have hup := ((join_preserves μ e he).integrable_comp_emb (joinEquiv e he).measurableEmbedding).mpr hu
  have hvp := ((join_preserves μ e he).integrable_comp_emb (joinEquiv e he).measurableEmbedding).mpr hv
  rw [integral_split μ e he u hu,integral_split μ e he v hv, ← integral_const_mul]
  exact integral_mono hup.integral_prod_right (hvp.integral_prod_right.const_mul a) h

attribute [local irreducible] Finset.univ Fintype.piFinset

lemma centered_resample_loss (x : ι) (u : (ι → ℝ) → ℝ) (hum : Measurable u)
    (hu : MemLp u 2 (γpi ι))
    (hv : ∀ C, MemLp (fun t => u (Function.update C x t)) 2 γ)
    (hz : ∀ C, (∫ t, u (Function.update C x t) ∂γ)=0)
    {A : ℝ} (hA : 0<A) :
    (∫ C, |u C-Slice.centeredClip γ A (fun t => u (Function.update C x t)) (C x)| ∂γpi ι) ≤
      2*(∫ C, (u C)^2 ∂γpi ι)/A := by
  let e := singletonEmbed x
  let he := singletonEmbed_injective x
  let w := fun C => Slice.centeredClip γ A (fun t => u (Function.update C x t)) (C x)
  have hw : MemLp w 2 (γpi ι) := centered_resample_memLp x u hum hA.le
  have hl : Integrable (fun C => |u C-w C|) (γpi ι) := (hu.sub hw).integrable (by norm_num) |>.abs
  have hq : Integrable (fun C => (u C)^2) (γpi ι) := hu.integrable_sq
  have hs D : (∫ C : Unit → ℝ, |u (join e he C D)-w (join e he C D)| ∂γpi Unit) ≤
      2*(∫ C : Unit → ℝ, (u (join e he C D))^2 ∂γpi Unit)/A := by
    let C₀ := join e he (fun _ => 0) D
    let v := fun t => u (Function.update C₀ x t)
    have huC (C : Unit → ℝ) : u (join e he C D)=v (C Unit.unit) := by
      dsimp only [v,C₀,e,he]
      rw [update_join_singleton]

    have hwC (C : Unit → ℝ) : w (join e he C D)=Slice.centeredClip γ A v (C Unit.unit) := by
      dsimp only [w]
      have hh : (fun t => u (Function.update (join e he C D) x t))=v := by
        funext t
        dsimp only [v,C₀,e,he]
        rw [update_join_singleton,update_join_singleton]
      rw [hh]
      congr 1
      exact join_at e he C D Unit.unit
    simp_rw [huC,hwC]
    rw [integral_singleton (fun t => |v t-Slice.centeredClip γ A v t|),
      integral_singleton (fun t => (v t)^2)]
    exact Slice.centeredClip_loss hA (hv C₀) (hz C₀)
  change (∫ C, |u C-w C| ∂γpi ι) ≤ _
  rw [← div_mul_eq_mul_div]
  apply integral_split_le γ e he _ _ hl hq
  intro D
  simpa only [div_mul_eq_mul_div] using hs D
end MinUncut.BoxGaussian

end
end

end OAI