import Mathlib
import OAI.Analysis.HardSphere.Fourier.CharacterDerivativeFactor
import OAI.Analysis.HardSphere.Geometry.KilledObservable
import OAI.Analysis.HardSphere.Bridges.Moment8

namespace OAI

noncomputable section
open MeasureTheory Filter Set
open scoped ENNReal Topology BigOperators
open scoped BigOperators ComplexConjugate
open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators
open MeasureTheory ProbabilityTheory Real Complex
open scoped ENNReal ComplexConjugate
open ProbabilityTheory
namespace HardSphere
open Wiener

lemma staysAllowed_of_neg (N : ℕ) (L : Length) {a : ℝ} (ha : a<0) :
    staysAllowed N L a=Set.univ := by
  ext ω
  simp only [staysAllowed,Set.mem_ofPred_eq,Set.mem_univ,iff_true]
  rw [allowed_of_neg N L ha]
  exact Set.subset_univ _

lemma killedObservable_of_neg (N : ℕ) (L : Length) {a : ℝ} (ha : a<0)
    (g : Configuration N L → ℂ) (ω : ConfigurationPath N L) :
    killedObservable N L a g ω=g (ω 1) := by
  simp only [killedObservable,staysAllowed_of_neg N L ha,Set.indicator_univ]

lemma killedTransition_of_neg (N : ℕ) (L : Length) {a : ℝ} (ha : a<0) (t : ℝ) :
    killedTransition N L a t=freeTransition N L t := by
  apply ContinuousLinearMap.ext
  intro g
  apply ext_inner_left ℂ
  intro f
  rw [killedTransition_pairing,freeTransition_pairing]
  simp only [killedPathLaw,staysAllowed_of_neg N L ha,Measure.restrict_univ]

lemma freeTrajectory_dist_le (N : ℕ) (L : Length) (t : ℝ)
    {w : CoordinatePaths N} {B : ℝ} (hB : 0≤B)
    (hw : ∀ p, ‖w p‖≤B) (X : Configuration N L) (s u : Time) :
    dist (freeTrajectory N L t w X s) (freeTrajectory N L t w X u) ≤
      2*Real.sqrt (2*t)*B := by
  have hC : 0≤2*Real.sqrt (2*t)*B := by positivity
  apply (dist_pi_le_iff hC).mpr
  intro i
  apply (dist_pi_le_iff hC).mpr
  intro j
  change dist (X i j+((Real.sqrt (2*t)*w (i,j) s : ℝ):AddCircle L.val))
    (X i j+((Real.sqrt (2*t)*w (i,j) u : ℝ):AddCircle L.val))≤_
  rw [dist_add_left,dist_eq_norm,← QuotientAddGroup.mk_sub]
  calc
    _ ≤ ‖Real.sqrt (2*t)*w (i,j) s-Real.sqrt (2*t)*w (i,j) u‖ :=
      QuotientAddGroup.norm_mk_le_norm
    _ = Real.sqrt (2*t)*‖w (i,j) s-w (i,j) u‖ := by
      rw [← mul_sub,norm_mul,Real.norm_eq_abs,abs_of_nonneg (Real.sqrt_nonneg _)]
    _ ≤ Real.sqrt (2*t)*(B+B) := by
      apply mul_le_mul_of_nonneg_left _ (Real.sqrt_nonneg _)
      exact (norm_sub_le _ _).trans (add_le_add
        ((w (i,j)).norm_coe_le_norm s |>.trans (hw (i,j)))
        ((w (i,j)).norm_coe_le_norm u |>.trans (hw (i,j))))
    _ = _ := by ring

lemma killedObservable_eq_of_small_path (N : ℕ) (L : Length) (a t : ℝ)
    (g : Configuration N L → ℂ) {δ B : ℝ} (hB : 0≤B)
    (hδ : Metric.cthickening δ (tsupport g) ⊆ allowed N L a)
    (ht : 2*Real.sqrt (2*t)*B≤δ)
    {w : CoordinatePaths N} (hw : ∀ p, ‖w p‖≤B) (X : Configuration N L) :
    killedObservable N L a g (freeTrajectory N L t w X)=g (freeTrajectory N L t w X 1) := by
  by_cases hg : g (freeTrajectory N L t w X 1)=0
  · simp only [killedObservable]
    by_cases he : freeTrajectory N L t w X∈staysAllowed N L a
    · simp only [Set.indicator_of_mem he]
    · simp only [Set.indicator_of_notMem he,hg]
  · have hs : freeTrajectory N L t w X 1∈tsupport g := subset_closure hg
    have he : freeTrajectory N L t w X∈staysAllowed N L a := by
      rintro _ ⟨s,rfl⟩
      apply hδ
      exact Metric.mem_cthickening_of_dist_le _ _ _ _ hs
        ((freeTrajectory_dist_le N L t hB hw X s 1).trans ht)
    simp only [killedObservable,Set.indicator_of_mem he]

lemma coordinateWiener_tail8 (N : ℕ) {B : ℝ} (hB : 0<B) :
    coordinateWiener N {w | ∃ p, B*normMultiplier<‖w p‖} ≤
      (Fintype.card (Direction N):ℝ≥0∞)*(ENNReal.ofReal B)⁻¹^8 *
        ((1+(1-(2:ℝ≥0∞)*(4/3)⁻¹^8)⁻¹)*moment8) := by
  have he : {w : CoordinatePaths N | ∃ p, B*normMultiplier<‖w p‖} =
      ⋃ p : Direction N, {w | B*normMultiplier<‖w p‖} := by ext w; simp
  rw [he]
  refine (measure_iUnion_fintype_le _ _).trans ?_
  calc
    _ = ∑ _p : Direction N, wiener {w | B*normMultiplier<‖w‖} := by
      apply Finset.sum_congr rfl
      intro p _
      exact (measurePreserving_eval (fun _ : Direction N ↦ wiener) p).measure_preimage
        (measurableSet_lt measurable_const measurable_norm).nullMeasurableSet
    _ ≤ ∑ _p : Direction N, (ENNReal.ofReal B)⁻¹^8 *
        ((1+(1-(2:ℝ≥0∞)*(4/3)⁻¹^8)⁻¹)*moment8) :=
      Finset.sum_le_sum fun _ _ ↦ norm_wiener_tail8 hB
    _ = _ := by simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_assoc]

lemma killedAverage_free_bound (N : ℕ) (L : Length) (a t : ℝ)
    (g : C(Configuration N L,ℂ)) {δ B : ℝ} (hB : 0<B)
    (hδ : Metric.cthickening δ (tsupport g) ⊆ allowed N L a)
    (ht : 2*Real.sqrt (2*t)*(B*normMultiplier)≤δ) (X : Configuration N L) :
    ‖killedAverage N L a t g X-killedAverage N L (-1) t g X‖ ≤
      ‖g‖*(coordinateWiener N).real {w | ∃ p, B*normMultiplier<‖w p‖} := by
  let E : Set (CoordinatePaths N) := {w | ∃ p, B*normMultiplier<‖w p‖}
  have hE : MeasurableSet E := by
    have he : E = ⋃ p : Direction N, {w : CoordinatePaths N | B*normMultiplier<‖w p‖} := by ext w; simp [E]
    rw [he]
    apply MeasurableSet.iUnion
    intro p
    exact measurableSet_lt measurable_const (measurable_pi_apply p |>.norm)
  have hi (b : ℝ) : Integrable (fun w : CoordinatePaths N ↦
      killedObservable N L b g (freeTrajectory N L t w X)) (coordinateWiener N) := by
    apply (integrable_const ‖g‖).mono'
    · exact ((killedObservable_measurable N L b g.continuous.measurable).comp
        ((freeTrajectory_continuous N L t).comp (continuous_id.prodMk continuous_const)).measurable).aestronglyMeasurable
    · exact Eventually.of_forall fun _ ↦ killedObservable_bound N L b (norm_nonneg g) g.norm_coe_le_norm _
  rw [killedAverage,killedAverage,← integral_sub (hi a) (hi (-1))]
  calc
    _ ≤ ∫ w, E.indicator (fun _ ↦ ‖g‖) w ∂coordinateWiener N := by
      apply norm_integral_le_of_norm_le
      · exact (integrable_const ‖g‖).indicator hE
      · filter_upwards [] with w
        rw [killedObservable_of_neg N L (by norm_num : (-1:ℝ)<0)]
        by_cases he : w∈E
        · rw [Set.indicator_of_mem he]
          by_cases ha : freeTrajectory N L t w X∈staysAllowed N L a
          · simp only [killedObservable,Set.indicator_of_mem ha,sub_self,norm_zero]
            exact norm_nonneg g
          · simp only [killedObservable,Set.indicator_of_notMem ha,zero_sub,norm_neg]
            exact g.norm_coe_le_norm _
        · rw [Set.indicator_of_notMem he]
          have hw : ∀ p, ‖w p‖≤B*normMultiplier := by
            intro p
            exact le_of_not_gt fun h ↦ he ⟨p,h⟩
          rw [killedObservable_eq_of_small_path N L a t g
            (mul_nonneg hB.le normMultiplier_pos.le) hδ ht hw X,sub_self,norm_zero]
    _ = _ := by rw [integral_indicator_const _ hE]; simp only [smul_eq_mul,mul_comm]; rfl

def pathTailConstant (N : ℕ) : ℝ :=
  ((Fintype.card (Direction N) : ℝ≥0∞) *
    ((1+(1-(2:ℝ≥0∞)*(4/3)⁻¹^8)⁻¹)*moment8)).toReal

lemma pathTailConstant_nonneg (N : ℕ) : 0 ≤ pathTailConstant N := ENNReal.toReal_nonneg

lemma coordinateWiener_tail8_real (N : ℕ) {B : ℝ} (hB : 0<B) :
    (coordinateWiener N).real {w | ∃ p, B*normMultiplier<‖w p‖} ≤
      pathTailConstant N * B⁻¹^8 := by
  have hfin : (Fintype.card (Direction N) : ℝ≥0∞) * (ENNReal.ofReal B)⁻¹^8 *
      ((1+(1-(2:ℝ≥0∞)*(4/3)⁻¹^8)⁻¹)*moment8) ≠ ∞ := by
    apply ENNReal.mul_ne_top _ norm_wiener_tail_constant_finite
    apply ENNReal.mul_ne_top (ENNReal.natCast_ne_top _)
    apply ENNReal.pow_ne_top
    rw [ENNReal.inv_ne_top]
    simpa using hB
  have h := ENNReal.toReal_mono hfin (coordinateWiener_tail8 N hB)
  simpa only [Measure.real,ENNReal.toReal_mul,ENNReal.toReal_pow,ENNReal.toReal_inv,
    ENNReal.toReal_ofReal hB.le, pathTailConstant,mul_assoc,mul_left_comm,mul_comm] using h

lemma killedAverage_free_order4 (N : ℕ) (L : Length) (a : ℝ)
    (g : C(Configuration N L,ℂ)) {δ : ℝ} (hδpos : 0<δ)
    (hδ : Metric.cthickening δ (tsupport g) ⊆ allowed N L a)
    {t : ℝ} (ht : 0<t) (X : Configuration N L) :
    ‖killedAverage N L a t g X-killedAverage N L (-1) t g X‖ ≤
      (‖g‖*pathTailConstant N*(2*normMultiplier/δ)^8*16)*t^4 := by
  let B : ℝ := δ/(2*Real.sqrt (2*t)*normMultiplier)
  have hs : 0<Real.sqrt (2*t) := Real.sqrt_pos.2 (by positivity)
  have hB : 0<B := div_pos hδpos (mul_pos (mul_pos (by norm_num) hs) normMultiplier_pos)
  have hBt : 2*Real.sqrt (2*t)*(B*normMultiplier)≤δ := by
    dsimp [B]
    have hn := normMultiplier_pos.ne'
    field_simp
    exact le_rfl
  calc
    _ ≤ ‖g‖*(coordinateWiener N).real {w | ∃ p, B*normMultiplier<‖w p‖} :=
      killedAverage_free_bound N L a t g hB hδ hBt X
    _ ≤ ‖g‖*(pathTailConstant N*B⁻¹^8) :=
      mul_le_mul_of_nonneg_left (coordinateWiener_tail8_real N hB) (norm_nonneg g)
    _ = _ := by
      have hsq := Real.sq_sqrt (by positivity : 0≤2*t)
      dsimp [B]
      rw [inv_div]
      calc
        _ = ‖g‖ * pathTailConstant N * (2 * normMultiplier / δ)^8 *
            (Real.sqrt (2*t)^2)^4 := by ring
        _ = _ := by rw [hsq]; ring

lemma killedTransition_continuous_ae_core (N : ℕ) (L : Length) (a t : ℝ)
    (g : C(Configuration N L,ℂ)) :
    killedTransition N L a t (ContinuousMap.toLp 2 volume ℂ g) =ᵐ[volume]
      killedAverage N L a t g := by
  have hgLp : MemLp (fun X ↦ g X) 2 (volume : Measure (Configuration N L)) :=
    MemLp.of_bound g.continuous.measurable.aestronglyMeasurable ‖g‖
      (Eventually.of_forall g.norm_coe_le_norm)
  have hge : ContinuousMap.toLp 2 volume ℂ g = hgLp.toLp g := by
    apply Lp.ext
    exact (ContinuousMap.coeFn_toLp (𝕜 := ℂ) (p := 2) volume g).trans hgLp.coeFn_toLp.symm
  rw [hge,killedTransition_bounded N L a t g.continuous.measurable
    hgLp (norm_nonneg g) g.norm_coe_le_norm]
  exact MemLp.coeFn_toLp _

lemma killedTransition_free_order4 (N : ℕ) (L : Length) (a : ℝ)
    (g : C(Configuration N L,ℂ)) (hg : tsupport g⊆allowed N L a) :
    ∃ C : ℝ, 0≤C ∧ ∀ t : ℝ, 0<t →
      ‖killedTransition N L a t (ContinuousMap.toLp 2 volume ℂ g)-
        freeTransition N L t (ContinuousMap.toLp 2 volume ℂ g)‖ ≤ C*t^4 := by
  obtain ⟨δ,hδpos,hδ⟩ := (isClosed_tsupport g).isCompact.exists_cthickening_subset_open
    (isOpen_allowed N L a) hg
  let C0 : ℝ := ‖g‖*pathTailConstant N*(2*normMultiplier/δ)^8*16
  have hC0 : 0≤C0 := by
    have hp := pathTailConstant_nonneg N
    dsimp [C0]
    positivity
  let M : ℝ := (measureUnivNNReal (volume : Measure (Configuration N L)) : ℝ) ^ (2:ℝ≥0∞).toReal⁻¹
  have hM : 0≤M := Real.rpow_nonneg (NNReal.coe_nonneg _) _
  refine ⟨M*C0,mul_nonneg hM hC0,?_⟩
  intro t ht
  rw [← killedTransition_of_neg N L (by norm_num : (-1:ℝ)<0)]
  have hb : ∀ᵐ X ∂(volume : Measure (Configuration N L)),
      ‖(killedTransition N L a t (ContinuousMap.toLp 2 volume ℂ g)-
        killedTransition N L (-1) t (ContinuousMap.toLp 2 volume ℂ g)) X‖≤C0*t^4 := by
    filter_upwards [Lp.coeFn_sub (killedTransition N L a t (ContinuousMap.toLp 2 volume ℂ g))
      (killedTransition N L (-1) t (ContinuousMap.toLp 2 volume ℂ g)),
      killedTransition_continuous_ae_core N L a t g,killedTransition_continuous_ae_core N L (-1) t g] with X hsub ha hb
    rw [hsub,Pi.sub_apply,ha,hb]
    exact killedAverage_free_order4 N L a g hδpos hδ ht X
  exact (Lp.norm_le_of_ae_bound (mul_nonneg hC0 (by positivity)) hb).trans_eq (by dsimp [M]; ring)

lemma killedTransition_free_firstOrder (N : ℕ) (L : Length) (a : ℝ)
    (g : C(Configuration N L,ℂ)) (hg : tsupport g⊆allowed N L a) :
    Tendsto (fun t : ℝ ↦ (t⁻¹:ℝ) •
      (killedTransition N L a t (ContinuousMap.toLp 2 volume ℂ g)-
        freeTransition N L t (ContinuousMap.toLp 2 volume ℂ g)))
      (𝓝[>] 0) (𝓝 0) := by
  obtain ⟨C,hC,hb⟩ := killedTransition_free_order4 N L a g hg
  rw [tendsto_zero_iff_norm_tendsto_zero]
  apply squeeze_zero' (g := fun t : ℝ ↦ C*t^3) (Eventually.of_forall fun t ↦ norm_nonneg _) ?_ ?_
  · filter_upwards [self_mem_nhdsWithin] with t ht
    have ht' : 0<t := ht
    rw [norm_smul,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr ht')]
    calc
      _ ≤ t⁻¹*(C*t^4) := mul_le_mul_of_nonneg_left (hb t ht') (by positivity)
      _ = C*t^3 := by field_simp
  · have h := (tendsto_const_nhds (x := C)).mul
      ((tendsto_id : Tendsto (fun t : ℝ ↦ t) (𝓝 0) (𝓝 0)).pow 3)
    simpa using h.mono_left nhdsWithin_le_nhds

end HardSphere

end

end OAI