import OAI.Probability.GaussianPropeller.OneCell

namespace OAI

open MeasureTheory ProbabilityTheory
open scoped ENNReal
open scoped RealInnerProductSpace
open scoped RealInnerProductSpace
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal RealInnerProductSpace
open Filter
open scoped Topology
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology
open scoped RealInnerProductSpace
open Set Filter
open scoped Topology RealInnerProductSpace
open scoped NNReal
open Set Filter
open scoped Topology RealInnerProductSpace NNReal
open MeasureTheory ProbabilityTheory Set Filter
open scoped Topology RealInnerProductSpace

namespace GaussianPropeller.Mills
open OneCell

lemma tail_pos (x : ℝ) : 0 < tail x := by
  apply (setIntegral_pos_iff_support_of_nonneg_ae
    (ae_of_all _ (fun x => (Real.exp_pos _).le)) density_integrable.integrableOn).mpr
  simp [Function.support, Real.exp_ne_zero]

lemma hasDerivAt_tail (x : ℝ) : HasDerivAt tail (-density x) x := by
  have heq : tail = fun a => tail 0 - ∫ t in (0:ℝ)..a, density t := by
    funext a
    have hi := intervalIntegral.integral_Ioi_sub_Ioi'
      (a := 0) (b := a) density_integrable.integrableOn density_integrable.integrableOn
    change tail 0-tail a = _ at hi
    linarith only [hi]
  rw [heq]
  exact (intervalIntegral.integral_hasDerivAt_right
    (density_integrable.intervalIntegrable)
    (by exact (show StronglyMeasurable density by unfold density; fun_prop).stronglyMeasurableAtFilter) (hasDerivAt_density x).continuousAt).const_sub _

noncomputable def barrier (x : ℝ) : ℝ := (3*x+Real.sqrt (x^2+8))/4
noncomputable def barrier' (x : ℝ) : ℝ := (3+x/Real.sqrt (x^2+8))/4

lemma hasDerivAt_barrier (x : ℝ) : HasDerivAt barrier (barrier' x) x := by
  unfold barrier barrier'
  convert (((hasDerivAt_id x).const_mul 3).add
    (((hasDerivAt_pow 2 x).add_const 8).sqrt (by positivity))).div_const 4 using 1 <;>
    first | rfl | (dsimp; ring)

lemma barrier_pos {x : ℝ} (hx : 0 ≤ x) : 0 < barrier x := by
  unfold barrier
  have : 0 < Real.sqrt (x^2+8) := Real.sqrt_pos.mpr (by positivity)
  positivity

lemma barrier_ge_half {x : ℝ} (hx : 0 ≤ x) : 1/2 ≤ barrier x := by
  have hs := Real.sq_sqrt (show 0 ≤ x^2+8 by positivity)
  have hn := Real.sqrt_nonneg (x^2+8)
  unfold barrier
  nlinarith only [hs,hn,hx,sq_nonneg x]

lemma barrier_differential {x : ℝ} (hx : 0 ≤ x) :
    barrier x ^ 2 - x*barrier x - barrier' x ≤ 0 := by
  let s := Real.sqrt (x^2+8)
  have hs : s^2=x^2+8 := Real.sq_sqrt (by positivity)
  have hp : 0 < s := Real.sqrt_pos.mpr (by positivity)
  have hid : (x^2+2)^2*s^2-(x^3+6*x)^2=32 := by rw [hs]; ring
  have hh : x^3+6*x ≤ (x^2+2)*s := by
    have hnon : 0 ≤ x^3+6*x := by positivity
    have hnon' : 0 ≤ (x^2+2)*s := by positivity
    apply (sq_le_sq₀ hnon hnon').mp
    nlinarith only [hid]
  have heq : barrier x^2-x*barrier x-barrier' x =
      (x^3+6*x-(x^2+2)*s)/(8*s) := by
    dsimp [barrier,barrier']
    change ((3*x+s)/4)^2-x*((3*x+s)/4)-(3+x/s)/4 = _
    field_simp [hp.ne']
    have hsm := congrArg (fun t : ℝ => x*t) hs
    have hss := congrArg (fun t : ℝ => s*t) hs
    nlinarith only [hs,hsm,hss]
  rw [heq]
  exact div_nonpos_of_nonpos_of_nonneg (sub_nonpos.mpr hh) (by positivity)

lemma tail_le_barrier {x : ℝ} (hx : 0 ≤ x) : tail x ≤ density x / barrier x := by
  let f : ℝ → ℝ := fun y => density y/barrier y-tail y
  let f' : ℝ → ℝ := fun y => density y*(barrier y^2-y*barrier y-barrier' y)/barrier y^2
  have hd (y : ℝ) (hy : 0 ≤ y) : HasDerivAt f (f' y) y := by
    convert ((hasDerivAt_density y).div (hasDerivAt_barrier y) (barrier_pos hy).ne').sub
      (hasDerivAt_tail y) using 1
    first | rfl | (dsimp [f']; field_simp [(barrier_pos hy).ne']; ring)
  have hm : AntitoneOn f (Ici 0) := antitoneOn_of_hasDerivWithinAt_nonpos (convex_Ici 0)
    (fun y hy => (hd y hy).continuousAt.continuousWithinAt)
    (fun y hy => (hd y (interior_subset hy)).hasDerivWithinAt)
    (fun y hy => div_nonpos_of_nonpos_of_nonneg
      (mul_nonpos_of_nonneg_of_nonpos (Real.exp_pos _).le
        (barrier_differential (interior_subset hy))) (sq_nonneg _))
  have ht : Tendsto (fun y => density y/barrier y) atTop (𝓝 0) := by
    apply squeeze_zero' _ _ (by simpa using tendsto_density.const_mul 2)
    · filter_upwards [eventually_ge_atTop (0:ℝ)] with y hy
      exact div_nonneg (Real.exp_pos _).le (barrier_pos hy).le
    · filter_upwards [eventually_ge_atTop (0:ℝ)] with y hy
      apply (div_le_iff₀ (barrier_pos hy)).mpr
      have hh := mul_le_mul_of_nonneg_left (barrier_ge_half hy) (Real.exp_pos (-y^2/2)).le
      change density y * (1/2) ≤ density y*barrier y at hh
      nlinarith only [hh]
  have ht' : Tendsto f atTop (𝓝 0) := by
    simpa only [sub_zero, f, tail, id_eq] using ht.sub (tendsto_integral_Ioi_zero (f := density) tendsto_id)
  have hnon : 0 ≤ f x := le_of_tendsto ht' (by
    filter_upwards [eventually_ge_atTop x] with y hy
    exact hm hx (hx.trans hy) hy)
  dsimp [f] at hnon
  linarith only [hnon]

noncomputable def lambda (x : ℝ) : ℝ := density x / tail x
noncomputable def G (x : ℝ) : ℝ := lambda x * (lambda x-x)

lemma lambda_ge_barrier {x : ℝ} (hx : 0 ≤ x) : barrier x ≤ lambda x := by
  rw [lambda, le_div_iff₀ (tail_pos x)]
  have hh := (le_div_iff₀ (barrier_pos hx)).mp (tail_le_barrier hx)
  linarith only [hh]

lemma lambda_pos (x : ℝ) : 0 < lambda x := div_pos (Real.exp_pos _) (tail_pos x)

lemma hasDerivAt_lambda (x : ℝ) : HasDerivAt lambda (lambda x*(lambda x-x)) x := by
  convert (hasDerivAt_density x).div (hasDerivAt_tail x) (tail_pos x).ne' using 1 <;>
    first | rfl | (unfold lambda; field_simp [(tail_pos x).ne']; ring)

lemma hasDerivAt_G (x : ℝ) : HasDerivAt G
    (lambda x*((lambda x-x)*(2*lambda x-x)-1)) x := by
  convert (hasDerivAt_lambda x).mul ((hasDerivAt_lambda x).sub (hasDerivAt_id x)) using 1 <;>
    first | rfl | (dsimp; ring)

lemma G_monotone : MonotoneOn G (Ici 0) := by
  apply monotoneOn_of_hasDerivWithinAt_nonneg (convex_Ici 0)
    (fun x _ => (hasDerivAt_G x).continuousAt.continuousWithinAt)
    (fun x _ => (hasDerivAt_G x).hasDerivWithinAt)
  intro x hx
  have hx' : 0 ≤ x := interior_subset hx
  apply mul_nonneg (lambda_pos x).le
  have hl := lambda_ge_barrier hx'
  have hs := Real.sq_sqrt (show 0 ≤ x^2+8 by positivity)
  have hp := Real.sqrt_nonneg (x^2+8)
  have hb : x ≤ Real.sqrt (x^2+8) := by nlinarith only [hs,hp,hx']
  have hprod := mul_nonneg (sub_nonneg.mpr hl)
    (show 0 ≤ 2*lambda x+2*barrier x-3*x by unfold barrier at *; linarith only [hl,hb,hx'])
  unfold barrier at hprod
  nlinarith only [hprod,hs]

lemma G_nonneg {x : ℝ} (hx : 0 ≤ x) : 0 ≤ G x := by
  apply mul_nonneg (lambda_pos x).le
  have hb := lambda_ge_barrier hx
  have hs := Real.sq_sqrt (show (0:ℝ) ≤ x^2+8 by positivity)
  have hp := Real.sqrt_nonneg (x^2+8)
  have hh : x ≤ Real.sqrt (x^2+8) := by nlinarith only [hs,hp,hx]
  dsimp [barrier] at hb
  linarith only [hb,hh]

lemma G_le_one (x : ℝ) : G x ≤ 1 := by
  have hi : Integrable (fun t : ℝ => (t-lambda x)^2*density t) volume := by
    have hh := (sq_density_integrable.sub (mul_density_integrable.const_mul (2*lambda x))).add
      (density_integrable.const_mul (lambda x^2))
    convert! hh using 1
    ext t
    simp only [Pi.add_apply, Pi.sub_apply]
    ring
  have hz : 0 ≤ ∫ t in Ioi x, (t-lambda x)^2*density t := by
    apply integral_nonneg
    intro t
    exact mul_nonneg (sq_nonneg _) (Real.exp_pos _).le
  have heq : (fun t : ℝ => (t-lambda x)^2*density t) =
      fun t => (t^2*density t-2*lambda x*(t*density t))+lambda x^2*density t := by
    funext t
    ring
  rw [heq] at hz
  have h₁ : IntegrableOn (fun t : ℝ => t^2*density t-2*lambda x*(t*density t)) (Ioi x) :=
    (sq_density_integrable.sub (mul_density_integrable.const_mul (2*lambda x))).integrableOn
  have h₂ : IntegrableOn (fun t : ℝ => lambda x^2*density t) (Ioi x) :=
    (density_integrable.const_mul (lambda x^2)).integrableOn
  rw [integral_add h₁ h₂, integral_sub sq_density_integrable.integrableOn
    (show IntegrableOn (fun t : ℝ => 2*lambda x*(t*density t)) (Ioi x) volume from
      (mul_density_integrable.const_mul (2*lambda x)).integrableOn),
    integral_const_mul, integral_const_mul, tail_first_moment, tail_second_moment] at hz
  change 0 ≤ x*density x+tail x-2*lambda x*density x+lambda x^2*tail x at hz
  have he : lambda x*tail x=density x := by
    rw [lambda, div_mul_cancel₀ _ (tail_pos x).ne']
  have ht : tail x*(1-G x) ≥ 0 := by
    dsimp [G]
    nlinarith only [hz,he, congrArg (fun t : ℝ => lambda x*t) he,
      congrArg (fun t : ℝ => x*t) he]
  have h := (mul_nonneg_iff_of_pos_left (tail_pos x)).mp ht
  linarith only [h]

end GaussianPropeller.Mills

end OAI