import Mathlib
import OAI.Analysis.HardSphere.Comparison.DensityForcesTwoParticles
import OAI.Analysis.HardSphere.Geometry.GroundPathWeight

namespace OAI

namespace HardSphere
open MeasureTheory Wiener Set Filter
open scoped ComplexConjugate ENNReal Topology BigOperators
noncomputable section
variable {N : ℕ} {L : Length}

def weightedKilledTransition (N : ℕ) (L : Length) (a t : ℝ)
    (h : ConfigurationPath N L → ℂ) (hh : MemLp h ∞ (freePathLaw N L t)) :
    ScalarL2 N L →L[ℂ] ScalarL2 N L :=
  (endpointPull N L t 0).toContinuousLinearMap.adjoint ∘L
    (L2Multiplier.clm h hh ∘L (avoidanceMultiplier N L a t ∘L
      (endpointPull N L t 1).toContinuousLinearMap))

lemma weightedKilledTransition_pairing (N : ℕ) (L : Length) (a t : ℝ)
    (h : ConfigurationPath N L → ℂ) (hh : MemLp h ∞ (freePathLaw N L t))
    (f g : ScalarL2 N L) :
    inner ℂ f (weightedKilledTransition N L a t h hh g) =
      ∫ ω, conj (f (ω 0)) * (h ω*g (ω 1)) ∂killedPathLaw N L a t := by
  rw [weightedKilledTransition,ContinuousLinearMap.comp_apply,
    ContinuousLinearMap.adjoint_inner_right,L2.inner_def]
  change (∫ ω, inner ℂ (endpointPull N L t 0 f ω)
    (L2Multiplier.clm h hh (avoidanceMultiplier N L a t (endpointPull N L t 1 g)) ω)
      ∂freePathLaw N L t)=_
  rw [killedPathLaw,← integral_indicator (staysAllowed_open N L a).measurableSet]
  apply integral_congr_ae
  filter_upwards [endpointPull_ae N L t 0 f,endpointPull_ae N L t 1 g,
    L2Multiplier.coe_clm h hh (avoidanceMultiplier N L a t (endpointPull N L t 1 g)),
    avoidanceMultiplier_ae N L a t (endpointPull N L t 1 g)] with ω hf hg hh' ha
  rw [hh',ha,hf]
  by_cases hω : ω∈staysAllowed N L a
  · simp only [Set.indicator_of_mem hω,hg,RCLike.inner_apply,mul_comm]
  · simp only [Set.indicator_of_notMem hω,mul_zero,inner_zero_right]

def weightedKilledAverage (N : ℕ) (L : Length) (a t : ℝ)
    (h : ConfigurationPath N L → ℂ) (g : Configuration N L → ℂ)
    (X : Configuration N L) : ℂ :=
  ∫ w, h (freeTrajectory N L t w X)*
    killedObservable N L a g (freeTrajectory N L t w X) ∂coordinateWiener N

lemma weightedKilledAverage_measurable (N : ℕ) (L : Length) (a t : ℝ)
    {h : ConfigurationPath N L → ℂ} (hh : Measurable h)
    {g : Configuration N L → ℂ} (hg : Measurable g) :
    Measurable (weightedKilledAverage N L a t h g) := by
  exact (((hh.mul (killedObservable_measurable N L a hg)).comp
    (freeTrajectory_continuous N L t).measurable).stronglyMeasurable.integral_prod_left').measurable

lemma weightedKilledAverage_bound (N : ℕ) (L : Length) (a t : ℝ)
    {h : ConfigurationPath N L → ℂ} {B : ℝ} (hB : 0≤B) (hhB : ∀ ω, ‖h ω‖≤B)
    {g : Configuration N L → ℂ} {C : ℝ} (hC : 0≤C) (hgC : ∀ X, ‖g X‖≤C)
    (X : Configuration N L) : ‖weightedKilledAverage N L a t h g X‖≤B*C := by
  have hb (w : CoordinatePaths N) : ‖h (freeTrajectory N L t w X)*
      killedObservable N L a g (freeTrajectory N L t w X)‖≤B*C := by
    rw [norm_mul]
    exact mul_le_mul (hhB _) (killedObservable_bound N L a hC hgC _) (norm_nonneg _) hB
  simpa only [weightedKilledAverage,measureReal_def,measure_univ,ENNReal.toReal_one,mul_one] using
    norm_integral_le_of_norm_le_const (μ := coordinateWiener N) (Eventually.of_forall hb)

lemma weightedKilledAverage_memLp (N : ℕ) (L : Length) (a t : ℝ)
    {h : ConfigurationPath N L → ℂ} (hh : Measurable h)
    {B : ℝ} (hB : 0≤B) (hhB : ∀ ω, ‖h ω‖≤B)
    {g : Configuration N L → ℂ} (hg : Measurable g)
    {C : ℝ} (hC : 0≤C) (hgC : ∀ X, ‖g X‖≤C) :
    MemLp (weightedKilledAverage N L a t h g) 2 (volume : Measure (Configuration N L)) :=
  MemLp.of_bound (weightedKilledAverage_measurable N L a t hh hg).aestronglyMeasurable (B*C)
    (Eventually.of_forall (weightedKilledAverage_bound N L a t hB hhB hC hgC))

lemma integrable_weightedAverage_pairing (N : ℕ) (L : Length) (a t : ℝ)
    (f : C(Configuration N L,ℂ))
    {h : ConfigurationPath N L → ℂ} (hh : Measurable h)
    {B : ℝ} (hB : 0≤B) (hhB : ∀ ω, ‖h ω‖≤B)
    {g : Configuration N L → ℂ} (hg : Measurable g)
    {C : ℝ} (hC : 0≤C) (hgC : ∀ X, ‖g X‖≤C) :
    Integrable (fun p : CoordinatePaths N × Configuration N L ↦
      conj (f p.2) * (h (freeTrajectory N L t p.1 p.2)*
        killedObservable N L a g (freeTrajectory N L t p.1 p.2)))
      ((coordinateWiener N).prod volume) := by
  refine (integrable_const (‖f‖*(B*C))).mono' ?_ ?_
  · exact (((f.continuous.comp continuous_snd).star.measurable).mul
      ((hh.mul (killedObservable_measurable N L a hg)).comp
        (freeTrajectory_continuous N L t).measurable)).aestronglyMeasurable
  · exact Eventually.of_forall fun p ↦ by
      simp only [norm_mul,RCLike.norm_conj]
      exact mul_le_mul (f.norm_coe_le_norm p.2)
        (mul_le_mul (hhB _) (killedObservable_bound N L a hC hgC _) (norm_nonneg _) hB)
        (mul_nonneg (norm_nonneg _) (norm_nonneg _)) (norm_nonneg _)

lemma weightedKilledTransition_bounded_pairing (N : ℕ) (L : Length) (a t : ℝ)
    (f : C(Configuration N L,ℂ))
    {h : ConfigurationPath N L → ℂ} (hh : Measurable h)
    (hhLp : MemLp h ∞ (freePathLaw N L t))
    {B : ℝ} (hB : 0≤B) (hhB : ∀ ω, ‖h ω‖≤B)
    {g : Configuration N L → ℂ} (hg : Measurable g)
    (hgLp : MemLp g 2 (volume : Measure (Configuration N L)))
    {C : ℝ} (hC : 0≤C) (hgC : ∀ X, ‖g X‖≤C) :
    inner ℂ (ContinuousMap.toLp 2 volume ℂ f)
      (weightedKilledTransition N L a t h hhLp (hgLp.toLp g)) =
      ∫ X, conj (f X) * weightedKilledAverage N L a t h g X := by
  rw [weightedKilledTransition_pairing,killedPathLaw,
    ← integral_indicator (staysAllowed_open N L a).measurableSet]
  have he : (staysAllowed N L a).indicator (fun ω : ConfigurationPath N L ↦
      conj (ContinuousMap.toLp 2 volume ℂ f (ω 0)) * (h ω*hgLp.toLp g (ω 1))) =ᵐ[freePathLaw N L t]
      (fun ω ↦ conj (f (ω 0)) * (h ω*killedObservable N L a g ω)) := by
    filter_upwards [(freePathLaw_marginal N L t 0).quasiMeasurePreserving.ae
        (ContinuousMap.coeFn_toLp (𝕜 := ℂ) (p := 2) volume f),
      (freePathLaw_marginal N L t 1).quasiMeasurePreserving.ae hgLp.coeFn_toLp] with ω hf hg'
    by_cases ha : ω∈staysAllowed N L a
    · simp only [Set.indicator_of_mem ha,killedObservable,hf,hg']
    · simp only [Set.indicator_of_notMem ha,killedObservable,mul_zero]
  rw [integral_congr_ae he,freePathLaw]
  have hm : Measurable (fun ω : ConfigurationPath N L ↦
      conj (f (ω 0)) * (h ω*killedObservable N L a g ω)) := by
    exact (f.continuous.comp (continuous_eval_const (0:Time))).star.measurable.mul
      (hh.mul (killedObservable_measurable N L a hg))
  rw [integral_map (freeTrajectory_continuous N L t).measurable.aemeasurable hm.aestronglyMeasurable]
  have hzero : (fun p : CoordinatePaths N × Configuration N L ↦
      conj (f (freeTrajectory N L t p.1 p.2 0)) *
        (h (freeTrajectory N L t p.1 p.2)*killedObservable N L a g (freeTrajectory N L t p.1 p.2))) =ᵐ[
        (coordinateWiener N).prod volume]
      (fun p ↦ conj (f p.2) * (h (freeTrajectory N L t p.1 p.2)*
        killedObservable N L a g (freeTrajectory N L t p.1 p.2))) := by
    filter_upwards [Measure.quasiMeasurePreserving_fst.ae (freeTrajectory_initial_ae N L t)] with p hp
    rw [hp]
  rw [integral_congr_ae hzero,
    integral_prod_symm _ (integrable_weightedAverage_pairing N L a t f hh hB hhB hg hC hgC)]
  simp_rw [integral_const_mul]
  rfl

lemma weightedKilledTransition_bounded (N : ℕ) (L : Length) (a t : ℝ)
    {h : ConfigurationPath N L → ℂ} (hh : Measurable h)
    (hhLp : MemLp h ∞ (freePathLaw N L t))
    {B : ℝ} (hB : 0≤B) (hhB : ∀ ω, ‖h ω‖≤B)
    {g : Configuration N L → ℂ} (hg : Measurable g)
    (hgLp : MemLp g 2 (volume : Measure (Configuration N L)))
    {C : ℝ} (hC : 0≤C) (hgC : ∀ X, ‖g X‖≤C) :
    weightedKilledTransition N L a t h hhLp (hgLp.toLp g) =
      (weightedKilledAverage_memLp N L a t hh hB hhB hg hC hgC).toLp
        (weightedKilledAverage N L a t h g) := by
  apply ext_inner_left ℂ
  intro f
  have hd := ContinuousMap.toLp_denseRange ℂ (volume : Measure (Configuration N L)) ℂ
    (show (2:ℝ≥0∞) ≠ ∞ by norm_num)
  have hc : IsClosed {f : ScalarL2 N L |
      inner ℂ f (weightedKilledTransition N L a t h hhLp (hgLp.toLp g)) =
        inner ℂ f ((weightedKilledAverage_memLp N L a t hh hB hhB hg hC hgC).toLp
          (weightedKilledAverage N L a t h g))} :=
    isClosed_eq (continuous_id.inner continuous_const) (continuous_id.inner continuous_const)
  apply hc.closure_subset_iff.mpr ?_ (hd f)
  rintro _ ⟨f,rfl⟩
  change inner ℂ _ _ = inner ℂ _ _
  rw [weightedKilledTransition_bounded_pairing N L a t f hh hhLp hB hhB hg hgLp hC hgC,L2.inner_def]
  apply integral_congr_ae
  filter_upwards [ContinuousMap.coeFn_toLp (𝕜 := ℂ) (p := 2) volume f,
    (weightedKilledAverage_memLp N L a t hh hB hhB hg hC hgC).coeFn_toLp] with X hf hX
  rw [RCLike.inner_apply,hf,hX,mul_comm]

end

noncomputable section

lemma weightedKilledAverage_prefix (N : ℕ) (L : Length) (a s t : ℝ) (hs : 0<s) (ht : 0<t)
    {h : ConfigurationPath N L → ℂ} (hh : Measurable h)
    {B : ℝ} (hB : 0≤B) (hhB : ∀ ω, ‖h ω‖≤B)
    {g : Configuration N L → ℂ} (hg : Measurable g) {C : ℝ}
    (hC : 0≤C) (hgC : ∀ X, ‖g X‖≤C) (X : Configuration N L) :
    weightedKilledAverage N L a (s+t) (h ∘ configurationPrefix N L (splitTime s t hs ht)) g X =
      weightedKilledAverage N L a s h (killedAverage N L a t g) X := by
  let F : CoordinatePaths N × CoordinatePaths N → ℂ := fun p ↦
    h (freeTrajectory N L s p.1 X) * splitObservable N L a g
      (freeTrajectory N L s p.1 X,freeTrajectory N L t p.2 (freeTrajectory N L s p.1 X 1))
  have hm : Measurable F :=
    (hh.comp ((freeTrajectory_continuous N L s).comp (continuous_fst.prodMk continuous_const)).measurable).mul
      ((splitObservable_measurable N L a hg).comp (split_fixedTrajectory_measurable N L s t X))
  have hi : Integrable F ((coordinateWiener N).prod (coordinateWiener N)) := by
    refine (integrable_const (B*C)).mono' hm.aestronglyMeasurable ?_
    exact Eventually.of_forall fun p ↦ by
      rw [norm_mul]
      exact mul_le_mul (hhB _) (splitObservable_bound N L a hC hgC _) (norm_nonneg _) hB
  have hsplit := coordinateSplit_preserving N (splitTime s t hs ht)
    (splitTime_pos s t hs ht) (splitTime_lt_one s t hs ht)
  calc
    _ = ∫ w, F (fun p ↦ normalizedPrefix (splitTime s t hs ht) (w p),
          fun p ↦ normalizedSuffix (splitTime s t hs ht) (w p)) ∂coordinateWiener N := by
      apply integral_congr_ae
      exact Eventually.of_forall fun w ↦ by
        dsimp only [weightedKilledAverage,Function.comp_def,F]
        rw [killedObservable_split N L a g (splitTime s t hs ht)
          (splitTime_pos s t hs ht) (splitTime_lt_one s t hs ht),split_fixedTrajectory,
          prefix_freeTrajectory]
    _ = ∫ p, F p ∂(coordinateWiener N).prod (coordinateWiener N) := by
      rw [← hsplit.map_eq,integral_map hsplit.measurable.aemeasurable hm.aestronglyMeasurable]
    _ = ∫ w, ∫ w', F (w,w') ∂coordinateWiener N ∂coordinateWiener N := integral_prod _ hi
    _ = _ := by
      apply integral_congr_ae
      exact Eventually.of_forall fun w ↦ by
        change (∫ w', h (freeTrajectory N L s w X)*splitObservable N L a g
          (freeTrajectory N L s w X,freeTrajectory N L t w' (freeTrajectory N L s w X 1))
            ∂coordinateWiener N) = h (freeTrajectory N L s w X)*
          killedObservable N L a (killedAverage N L a t g) (freeTrajectory N L s w X)
        rw [integral_const_mul]
        congr 1
        by_cases hω : freeTrajectory N L s w X∈staysAllowed N L a
        · simp only [splitObservable,ite_eq_left hω,killedObservable,Set.indicator_of_mem hω]
          rfl
        · simp only [splitObservable,ite_eq_right hω,killedObservable,Set.indicator_of_notMem hω,integral_zero]

lemma weightedKilledTransition_prefix (N : ℕ) (L : Length) (a s t : ℝ) (hs : 0<s) (ht : 0<t)
    {h : ConfigurationPath N L → ℂ} (hh : Measurable h)
    (hhLp : MemLp h ∞ (freePathLaw N L s))
    (hpLp : MemLp (h ∘ configurationPrefix N L (splitTime s t hs ht)) ∞ (freePathLaw N L (s+t)))
    {B : ℝ} (hB : 0≤B) (hhB : ∀ ω, ‖h ω‖≤B) :
    weightedKilledTransition N L a (s+t) (h ∘ configurationPrefix N L (splitTime s t hs ht)) hpLp =
      weightedKilledTransition N L a s h hhLp ∘L killedTransition N L a t := by
  have hd := ContinuousMap.toLp_denseRange ℂ (volume : Measure (Configuration N L)) ℂ
    (show (2:ℝ≥0∞) ≠ ∞ by norm_num)
  apply ContinuousLinearMap.ext
  intro g
  change weightedKilledTransition N L a (s+t) (h ∘ configurationPrefix N L (splitTime s t hs ht)) hpLp g =
    weightedKilledTransition N L a s h hhLp (killedTransition N L a t g)
  have hc : IsClosed {g : ScalarL2 N L |
      weightedKilledTransition N L a (s+t) (h ∘ configurationPrefix N L (splitTime s t hs ht)) hpLp g =
        weightedKilledTransition N L a s h hhLp (killedTransition N L a t g)} :=
    isClosed_eq (ContinuousLinearMap.continuous _) ((ContinuousLinearMap.continuous _).comp
      (ContinuousLinearMap.continuous _))
  apply hc.closure_subset_iff.mpr ?_ (hd g)
  rintro _ ⟨g,rfl⟩
  change weightedKilledTransition N L a (s+t) (h ∘ configurationPrefix N L (splitTime s t hs ht)) hpLp
      (ContinuousMap.toLp 2 volume ℂ g) =
    weightedKilledTransition N L a s h hhLp (killedTransition N L a t (ContinuousMap.toLp 2 volume ℂ g))
  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,weightedKilledTransition_bounded N L a (s+t)
      (hh.comp (configurationPrefix_continuous N L _).measurable) hpLp hB
      (fun ω ↦ hhB _) g.continuous.measurable hgLp (norm_nonneg _) g.norm_coe_le_norm,
    killedTransition_bounded N L a t g.continuous.measurable hgLp (norm_nonneg _) g.norm_coe_le_norm,
    weightedKilledTransition_bounded N L a s hh hhLp hB hhB
      (killedAverage_measurable N L a t g.continuous.measurable)
      (killedAverage_memLp N L a t g.continuous.measurable (norm_nonneg _) g.norm_coe_le_norm)
      (norm_nonneg g) (killedAverage_bound N L a t (norm_nonneg _) g.norm_coe_le_norm)]
  apply MemLp.toLp_congr
  exact Eventually.of_forall (weightedKilledAverage_prefix N L a s t hs ht hh hB hhB
    g.continuous.measurable (norm_nonneg _) g.norm_coe_le_norm)

variable {N : ℕ} {L : Length} {a : ℝ}

lemma weightedKilledTransition_indicator_pairing (t : ℝ) (f g : ScalarL2 N L)
    {S : Set (ConfigurationPath N L)} (hS : MeasurableSet S) :
    inner ℂ (modulusScalar f) (weightedKilledTransition N L a t (S.indicator (fun _ ↦ (1:ℂ)))
      ((memLp_top_const (1:ℂ)).indicator hS) (modulusScalar g)) =
      ((∫ ω : ConfigurationPath N L in S, ‖f (ω 0)‖*‖g (ω 1)‖ ∂killedPathLaw N L a t):ℝ) := by
  rw [weightedKilledTransition_pairing,← integral_complex_ofReal,← integral_indicator hS]
  apply integral_congr_ae
  filter_upwards [((freePathLaw_marginal N L t 0).quasiMeasurePreserving.ae_eq_comp
      (coe_modulusScalar f)).filter_mono (ae_mono Measure.restrict_le_self),
    ((freePathLaw_marginal N L t 1).quasiMeasurePreserving.ae_eq_comp
      (coe_modulusScalar g)).filter_mono (ae_mono Measure.restrict_le_self)] with ω hf hg
  dsimp only [Function.comp_def] at hf hg
  by_cases hω : ω∈S
  · simp only [Set.indicator_of_mem hω,hf,hg,Complex.conj_ofReal,one_mul,Complex.ofReal_mul]
  · simp only [Set.indicator_of_notMem hω,zero_mul,mul_zero]

lemma IsGroundVector.prefix_norm_setIntegral {u : Jet N L} (hu : IsGroundVector N L a u)
    (s t : ℝ) (hs : 0<s) (ht : 0<t)
    {S : Set (ConfigurationPath N L)} (hS : MeasurableSet S) :
    (∫ ω : ConfigurationPath N L in (configurationPrefix N L (splitTime s t hs ht)) ⁻¹' S,
      ‖u.1 (ω 0)‖*‖u.1 (ω 1)‖ ∂killedPathLaw N L a (s+t)) =
      Real.exp (-t*energy u)*(∫ ω : ConfigurationPath N L in S,
        ‖u.1 (ω 0)‖*‖u.1 (ω 1)‖ ∂killedPathLaw N L a s) := by
  let h : ConfigurationPath N L → ℂ := S.indicator (fun _ ↦ 1)
  have hh : Measurable h := measurable_const.indicator hS
  have hhs : MemLp h ∞ (freePathLaw N L s) := (memLp_top_const (1:ℂ)).indicator hS
  have hhp : MemLp (h ∘ configurationPrefix N L (splitTime s t hs ht)) ∞ (freePathLaw N L (s+t)) := by
    exact (memLp_top_const (1:ℂ)).indicator (hS.preimage (configurationPrefix_continuous N L _).measurable)
  have hb (ω : ConfigurationPath N L) : ‖h ω‖≤1 := by
    by_cases hω : ω∈S <;> simp [h,hω]
  have heq : inner ℂ (modulusScalar u.1)
      (weightedKilledTransition N L a (s+t) (h ∘ configurationPrefix N L (splitTime s t hs ht)) hhp
        (modulusScalar u.1)) =
      (Real.exp (-t*energy u):ℂ)*inner ℂ (modulusScalar u.1)
        (weightedKilledTransition N L a s h hhs (modulusScalar u.1)) := by
    rw [weightedKilledTransition_prefix N L a s t hs ht hh hhs hhp zero_le_one hb,
      ContinuousLinearMap.comp_apply]
    have he := hu.modulus.killed_eigenvector ht.le
    change killedTransition N L a t (modulusScalar u.1)=
      (Real.exp (-t*energy (modulusJet u)):ℂ) • modulusScalar u.1 at he
    rw [hu.energy_modulus] at he
    rw [he,map_smul,inner_smul_right]
  have hp : h ∘ configurationPrefix N L (splitTime s t hs ht)=
      ((configurationPrefix N L (splitTime s t hs ht)) ⁻¹' S).indicator (fun _ ↦ (1:ℂ)) := by
    ext ω
    rfl
  apply Complex.ofReal_injective
  rw [Complex.ofReal_mul,← weightedKilledTransition_indicator_pairing (a := a) s u.1 u.1 hS,
    ← weightedKilledTransition_indicator_pairing (a := a) (s+t) u.1 u.1
      (hS.preimage (configurationPrefix_continuous N L _).measurable)]
  simpa only [hp] using heq

lemma IsGroundVector.groundPathLaw_prefix {u : Jet N L} (hu : IsGroundVector N L a u)
    (s t : ℝ) (hs : 0<s) (ht : 0<t) :
    MeasurePreserving (configurationPrefix N L (splitTime s t hs ht))
      (groundPathLaw N L a (s+t) u) (groundPathLaw N L a s u) := by
  refine ⟨(configurationPrefix_continuous N L _).measurable,Measure.ext fun S hS ↦ ?_⟩
  rw [Measure.map_apply (configurationPrefix_continuous N L _).measurable hS,
    groundPathLaw,groundPathLaw,
    withDensity_apply _ (hS.preimage (configurationPrefix_continuous N L _).measurable),
    withDensity_apply _ hS,
    ← ofReal_integral_eq_lintegral_ofReal (groundPathWeight_integrable u a (s+t)).integrableOn
      (Eventually.of_forall (groundPathWeight_nonneg u (s+t))),
    ← ofReal_integral_eq_lintegral_ofReal (groundPathWeight_integrable u a s).integrableOn
      (Eventually.of_forall (groundPathWeight_nonneg u s))]
  congr 1
  simp only [groundPathWeight,integral_const_mul]
  rw [hu.prefix_norm_setIntegral s t hs ht hS,← mul_assoc,← Real.exp_add,
    show (s+t)*energy u+ -t*energy u=s*energy u by ring]

end

noncomputable section
variable {N : ℕ} {L : Length} {a : ℝ}

lemma splitTime_reverse (s t : ℝ) (hs : 0<s) (ht : 0<t) :
    splitTime t s ht hs=reverseTime (splitTime s t hs ht) := by
  apply Subtype.ext
  change t/(t+s)=1-s/(s+t)
  rw [add_comm t s]
  field_simp [ne_of_gt (add_pos hs ht)]
  ring

lemma reverse_prefix_reverse (q : Time) (ω : ConfigurationPath N L) :
    reverseConfigurationPath N L (configurationPrefix N L (reverseTime q)
      (reverseConfigurationPath N L ω))=configurationSuffix N L q ω := by
  apply ContinuousMap.ext
  intro v
  change ω (reverseTime (prefixTime (reverseTime q) (reverseTime v)))=ω (suffixTime q v)
  congr 1
  apply Subtype.ext
  change 1-(1-(q:ℝ))*(1-(v:ℝ))=(q:ℝ)+(1-(q:ℝ))*(v:ℝ)
  ring

lemma IsGroundVector.groundPathLaw_suffix {u : Jet N L} (hu : IsGroundVector N L a u)
    (s t : ℝ) (hs : 0<s) (ht : 0<t) :
    MeasurePreserving (configurationSuffix N L (splitTime s t hs ht))
      (groundPathLaw N L a (s+t) u) (groundPathLaw N L a t u) := by
  have hp : MeasurePreserving (configurationPrefix N L (splitTime t s ht hs))
      (groundPathLaw N L a (s+t) u) (groundPathLaw N L a t u) := by
    simpa only [add_comm t s] using hu.groundPathLaw_prefix t s ht hs
  have h := (groundPathLaw_reversal u a t).comp (hp.comp (groundPathLaw_reversal u a (s+t)))
  simpa only [Function.comp_def,splitTime_reverse s t hs ht,reverse_prefix_reverse] using h

lemma groundPathLaw_absolutelyContinuous (N : ℕ) (L : Length) (a t : ℝ) (u : Jet N L) :
    groundPathLaw N L a t u ≪ freePathLaw N L t :=
  (withDensity_absolutelyContinuous _ _).trans Measure.absolutelyContinuous_restrict

lemma freePathLaw_zero_eval (N : ℕ) (L : Length) (q : Time) :
    ∀ᵐ ω ∂freePathLaw N L 0, ω q=ω 0 := by
  rw [freePathLaw]
  apply (ae_map_iff (freeTrajectory_continuous N L 0).measurable.aemeasurable
    (isClosed_eq (continuous_eval_const q) (continuous_eval_const (0:Time))).measurableSet).mpr
  exact Eventually.of_forall fun p ↦ by
    ext i j
    simp only [freeTrajectory,ContinuousMap.coe_mk,mul_zero,Real.sqrt_zero,zero_mul]

lemma IsGroundVector.groundPathLaw_marginal {u : Jet N L} (hu : IsGroundVector N L a u)
    (T : ℝ) (hT : 0≤T) (q : Time) :
    MeasurePreserving (fun ω : ConfigurationPath N L ↦ ω q)
      (groundPathLaw N L a T u) (groundPositionLaw N L u) := by
  by_cases hzero : T=0
  · subst T
    refine ⟨(continuous_eval_const q).measurable,?_⟩
    rw [Measure.map_congr ((groundPathLaw_absolutelyContinuous N L a 0 u).ae_eq
      (freePathLaw_zero_eval N L q))]
    exact (hu.groundPathLaw_initial le_rfl).map_eq
  have hT' : 0<T := lt_of_le_of_ne hT (Ne.symm hzero)
  by_cases hq0 : q=0
  · subst q
    exact hu.groundPathLaw_initial hT
  by_cases hq1 : q=1
  · subst q
    exact hu.groundPathLaw_terminal hT
  have hq : 0<(q:ℝ) := lt_of_le_of_ne q.property.1 (fun h ↦ hq0 (Subtype.ext h.symm))
  have hq' : (q:ℝ)<1 := lt_of_le_of_ne q.property.2 (fun h ↦ hq1 (Subtype.ext h))
  let s := (q:ℝ)*T
  let t := (1-(q:ℝ))*T
  have hs : 0<s := mul_pos hq hT'
  have ht : 0<t := mul_pos (sub_pos.mpr hq') hT'
  have hsum : s+t=T := by dsimp [s,t]; ring
  have hsplit : splitTime s t hs ht=q := by
    apply Subtype.ext
    change s/(s+t)=(q:ℝ)
    rw [hsum]
    exact mul_div_cancel_right₀ _ hzero
  have hp := (hu.groundPathLaw_terminal hs.le).comp (hu.groundPathLaw_prefix s t hs ht)
  simpa only [Function.comp_def,configurationPrefix,ContinuousMap.comp_apply,prefixTime_one,hsplit,hsum] using hp

lemma IsGroundVector.groundPathLaw_middle {u : Jet N L} (hu : IsGroundVector N L a u)
    (r s t : ℝ) (hr : 0<r) (hs : 0<s) (ht : 0<t) :
    MeasurePreserving
      (configurationSuffix N L (splitTime r s hr hs) ∘
        configurationPrefix N L (splitTime (r+s) t (add_pos hr hs) ht))
      (groundPathLaw N L a ((r+s)+t) u) (groundPathLaw N L a s u) :=
  (hu.groundPathLaw_suffix r s hr hs).comp (hu.groundPathLaw_prefix (r+s) t (add_pos hr hs) ht)

end
end HardSphere

namespace HardSphere
open MeasureTheory Wiener Set Filter
open scoped Topology
noncomputable section

lemma IsGroundVector.groundPathLaw_close_event {n : ℕ} (L : Length) {r : ℝ}
    {g : Jet n L} (hg : IsGroundVector n L r g) (T : ℝ) (hT : 0≤T) (q : Time)
    {S : Type*} (v : S → Torus L) (A : Finset S) (s h : ℝ) :
    groundPathLaw n L r T g {ω | ∀ a∈A, h≤((pairCloseLabels L s (v a) (ω q)).card:ℝ)} =
      groundPositionLaw n L g {X | ∀ a∈A, h≤((pairCloseLabels L s (v a) X).card:ℝ)} := by
  have hS : MeasurableSet {X : Configuration n L | ∀ a∈A, h≤((pairCloseLabels L s (v a) X).card:ℝ)} := by
    simpa only [Set.ofPred_forall] using Finset.measurableSet_biInter A (fun a _ ↦
      measurableSet_le (show Measurable (fun _ : Configuration n L ↦ h) from measurable_const)
        (pairCloseLabels_measurable L s (v a)))
  exact (hg.groundPathLaw_marginal T hT q).measure_preimage hS.nullMeasurableSet

theorem spatial_stationary_close_tail : ∃ Q : ℕ, 0<Q ∧ ∀ θ : ℝ, 0<θ →
    ∃ b Gθ : ℝ, 0<b ∧ b≤1/4 ∧ 0<Gθ ∧
      Tendsto (fun D : ℝ ↦ ((Gθ/b^2)*D^(-(4/3):ℝ))^(1/(Q:ℝ))) atTop (𝓝 0) ∧
    ∀ αmax : ℝ, ∃ D₀ : ℝ, 1≤D₀ ∧
    ∀ (n K : ℕ) (L : Length) (_hL : L.val=(K:ℝ)) (D α : ℝ),
      100≤L.val → D=(n:ℝ)/L.val^3 → D₀≤D → 1≤α → α≤αmax →
    ∀ (g : Jet n L), IsGroundVector n L (α/D) g →
    ∀ (T : ℝ), 0≤T → ∀ (q : Time) (A : Finset (CubeCell K)),
      groundPathLaw n L (α/D) T g {ω | ∀ v∈A,
        θ*D≤((pairCloseLabels L (spatialCloseScale D b) (unitCenter L v) (ω q)).card:ℝ)}≤
        ENNReal.ofReal (((((Gθ/b^2)*D^(-(4/3):ℝ))^(1/(Q:ℝ)))^A.card)) := by
  obtain ⟨Q,hQ,htail⟩ := spatial_full_and_bath_close_tail
  refine ⟨Q,hQ,?_⟩
  intro θ hθ
  obtain ⟨b,Gθ,hb,hb1,hGθ,hlim,hfin⟩ := htail θ hθ
  refine ⟨b,Gθ,hb,hb1,hGθ,hlim,?_⟩
  intro αmax
  obtain ⟨D₀,hD₀,hDfin⟩ := hfin αmax
  refine ⟨D₀,hD₀,?_⟩
  intro n K L hL D α hL100 hDeq hD hα hαmax g hg T hT q A
  rw [hg.groundPathLaw_close_event L T hT q (unitCenter L) A]
  exact (hDfin n K L hL D α hL100 hDeq hD hα hαmax g hg A).1

end
end HardSphere

end OAI