import Mathlib
import OAI.Analysis.HardSphere.Geometry.KilledEigenvector
import OAI.Analysis.HardSphere.Geometry.GroundPositionLaw
import OAI.Analysis.HardSphere.Cutoffs.Regularize

namespace OAI

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

lemma integrable_norm_endpoints (N : ℕ) (L : Length) (a t : ℝ)
    (f g : ScalarL2 N L) (s v : Time) :
    Integrable (fun ω : ConfigurationPath N L ↦ ‖f (ω s)‖*‖g (ω v)‖)
      (killedPathLaw N L a t) := by
  exact (((Lp.memLp f).comp_measurePreserving (freePathLaw_marginal N L t s)).norm.integrable_mul
    ((Lp.memLp g).comp_measurePreserving (freePathLaw_marginal N L t v)).norm).restrict

lemma modulus_killed_pairing (f g : ScalarL2 N L) :
    inner ℂ (modulusScalar f) (killedTransition N L a t (modulusScalar g)) =
      ((∫ ω : ConfigurationPath N L, ‖f (ω 0)‖*‖g (ω 1)‖ ∂killedPathLaw N L a t):ℝ) := by
  rw [killedTransition_pairing,← integral_complex_ofReal]
  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
  rw [hf,hg,Complex.conj_ofReal,Complex.ofReal_mul]

lemma IsGroundVector.integral_norm_endpoints {u : Jet N L} (hu : IsGroundVector N L a u)
    (ht : 0 ≤ t) :
    (∫ ω : ConfigurationPath N L, ‖u.1 (ω 0)‖*‖u.1 (ω 1)‖ ∂killedPathLaw N L a t)=
      Real.exp (-t*energy u) := by
  apply Complex.ofReal_injective
  rw [← modulus_killed_pairing,show modulusScalar u.1=(modulusJet u).1 from rfl,
    hu.modulus.killed_eigenvector ht,inner_smul_right,inner_self_eq_norm_sq_to_K,
    hu.modulus.2.2.1,RCLike.ofReal_one,one_pow,mul_one,hu.energy_modulus]

def groundPathWeight (u : Jet N L) (t : ℝ) (ω : ConfigurationPath N L) : ℝ :=
  Real.exp (t*energy u)*(‖u.1 (ω 0)‖*‖u.1 (ω 1)‖)

def groundPathLaw (N : ℕ) (L : Length) (a t : ℝ) (u : Jet N L) :
    Measure (ConfigurationPath N L) :=
  (killedPathLaw N L a t).withDensity (fun ω ↦ ENNReal.ofReal (groundPathWeight u t ω))

lemma groundPathWeight_measurable (u : Jet N L) (t : ℝ) : Measurable (groundPathWeight u t) := by
  exact measurable_const.mul (((Lp.stronglyMeasurable u.1).measurable.comp
    (continuous_eval_const (0:Time)).measurable).norm.mul
    (((Lp.stronglyMeasurable u.1).measurable.comp (continuous_eval_const (1:Time)).measurable).norm))

lemma groundPathWeight_nonneg (u : Jet N L) (t : ℝ) (ω : ConfigurationPath N L) :
    0 ≤ groundPathWeight u t ω := by
  unfold groundPathWeight
  positivity

lemma groundPathWeight_integrable (u : Jet N L) (a t : ℝ) :
    Integrable (groundPathWeight u t) (killedPathLaw N L a t) :=
  (integrable_norm_endpoints N L a t u.1 u.1 0 1).const_mul _

lemma IsGroundVector.integral_groundPathWeight {u : Jet N L} (hu : IsGroundVector N L a u)
    (ht : 0 ≤ t) : ∫ ω, groundPathWeight u t ω ∂killedPathLaw N L a t=1 := by
  simp only [groundPathWeight,integral_const_mul]
  rw [hu.integral_norm_endpoints ht,← Real.exp_add,
    show t*energy u+ -t*energy u=0 by ring,Real.exp_zero]

lemma IsGroundVector.groundPathLaw_probability {u : Jet N L} (hu : IsGroundVector N L a u)
    (ht : 0 ≤ t) : IsProbabilityMeasure (groundPathLaw N L a t u) := by
  constructor
  rw [groundPathLaw,withDensity_apply _ MeasurableSet.univ,setLIntegral_univ,
    ← ofReal_integral_eq_lintegral_ofReal (groundPathWeight_integrable u a t)
      (Eventually.of_forall (groundPathWeight_nonneg u t)),hu.integral_groundPathWeight ht,
    ENNReal.ofReal_one]

end
end HardSphere

namespace HardSphere
open MeasureTheory Wiener Set Filter
open scoped ComplexConjugate
noncomputable section
variable {N : ℕ} {L : Length} {a t : ℝ}

lemma IsGroundVector.integral_complex_endpoints {u : Jet N L} (hu : IsGroundVector N L a u)
    (ht : 0 ≤ t) :
    (∫ ω : ConfigurationPath N L, conj (u.1 (ω 0))*u.1 (ω 1) ∂killedPathLaw N L a t)=
      (Real.exp (-t*energy u):ℂ) := by
  rw [← killedTransition_pairing,hu.killed_eigenvector ht,inner_smul_right,
    inner_self_eq_norm_sq_to_K,hu.2.2.1,RCLike.ofReal_one,one_pow,mul_one]

lemma IsGroundVector.ae_killed_endpoints_phase {u : Jet N L} (hu : IsGroundVector N L a u)
    (ht : 0 ≤ t) :
    ∀ᵐ ω ∂killedPathLaw N L a t,
      conj (u.1 (ω 0))*u.1 (ω 1)=(‖u.1 (ω 0)‖*‖u.1 (ω 1)‖:ℝ) := by
  let z : ConfigurationPath N L → ℂ := fun ω ↦ conj (u.1 (ω 0))*u.1 (ω 1)
  let M : ConfigurationPath N L → ℝ := fun ω ↦ ‖u.1 (ω 0)‖*‖u.1 (ω 1)‖
  have hiz : Integrable z (killedPathLaw N L a t) := integrable_killed_endpoints N L a t u.1 u.1 0 1
  have hiM : Integrable M (killedPathLaw N L a t) := integrable_norm_endpoints N L a t u.1 u.1 0 1
  have hn (ω : ConfigurationPath N L) : ‖z ω‖=M ω := by
    simp only [z,M,norm_mul,RCLike.norm_conj]
  have hnn : ∀ᵐ ω ∂killedPathLaw N L a t, 0 ≤ M ω-(z ω).re :=
    Eventually.of_forall fun ω ↦ sub_nonneg.mpr ((Complex.re_le_norm _).trans_eq (hn ω))
  have hr : (∫ ω, (z ω).re ∂killedPathLaw N L a t)=Real.exp (-t*energy u) := by
    calc
      _ = (∫ ω, z ω ∂killedPathLaw N L a t).re := Complex.reCLM.integral_comp_comm hiz
      _ = _ := congrArg Complex.re (hu.integral_complex_endpoints ht)
  have hire : Integrable (fun ω ↦ (z ω).re) (killedPathLaw N L a t) :=
    Complex.reCLM.integrable_comp hiz
  have hh : ∫ ω, (M ω-(z ω).re) ∂killedPathLaw N L a t=0 := by
    rw [integral_sub hiM hire,hr,hu.integral_norm_endpoints ht,sub_self]
  have hae := (integral_eq_zero_iff_of_nonneg_ae hnn (hiM.sub hire)).mp hh
  filter_upwards [hae] with ω hω
  have he : (z ω).re=M ω := (sub_eq_zero.mp hω).symm
  have him : (z ω).im=0 := Complex.abs_re_eq_norm.mp (by
    rw [he,abs_of_nonneg (by dsimp only [M]; positivity),hn])
  change z ω=(M ω:ℂ)
  apply Complex.ext
  · exact he
  · exact him

end
end HardSphere

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

lemma measurePreserving_weighted_invariant {α : Type*} [MeasurableSpace α]
    {μ : Measure α} {R : α → α} (hR : MeasurePreserving R μ μ)
    (w : α → ℝ≥0∞) (hw : Measurable w) (hi : ∀ x, w (R x)=w x) :
    MeasurePreserving R (μ.withDensity w) (μ.withDensity w) := by
  refine ⟨hR.measurable,Measure.ext fun S hS ↦ ?_⟩
  rw [Measure.map_apply hR.measurable hS,withDensity_apply _ (hS.preimage hR.measurable),
    withDensity_apply _ hS,← lintegral_indicator (hS.preimage hR.measurable),
    ← lintegral_indicator hS]
  calc
    _ = ∫⁻ x, (S.indicator w) (R x) ∂μ := by
      apply lintegral_congr
      intro x
      by_cases hx : R x∈S
      · simp only [Set.indicator_of_mem hx,Set.indicator_of_mem (show x∈R ⁻¹' S from hx),hi]
      · simp only [Set.indicator_of_notMem hx,Set.indicator_of_notMem (show x∉R ⁻¹' S from hx)]
    _ = _ := hR.lintegral_comp (hw.indicator hS)

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

lemma groundPathLaw_reversal (u : Jet N L) (a t : ℝ) :
    MeasurePreserving (reverseConfigurationPath N L) (groundPathLaw N L a t u)
      (groundPathLaw N L a t u) := by
  apply measurePreserving_weighted_invariant (reverse_killedPath_preserving N L a t)
    _ (groundPathWeight_measurable u t).ennreal_ofReal
  intro ω
  congr 1
  simp only [groundPathWeight,reverseConfigurationPath_apply,reverseTime_zero,reverseTime_one]
  ring

lemma modulus_indicator_pairing (f g : ScalarL2 N L) {S : Set (Configuration N L)}
    (hS : MeasurableSet S) :
    inner ℂ (((Lp.memLp (modulusScalar f)).indicator hS).toLp (S.indicator (modulusScalar f)))
      (killedTransition N L a t (modulusScalar g)) =
      ((∫ ω : ConfigurationPath N L in (fun ω ↦ ω 0) ⁻¹' S,
        ‖f (ω 0)‖*‖g (ω 1)‖ ∂killedPathLaw N L a t):ℝ) := by
  rw [killedTransition_pairing,← integral_complex_ofReal,
    ← integral_indicator (hS.preimage (continuous_eval_const (0:Time)).measurable)]
  apply integral_congr_ae
  have h₁ := ((freePathLaw_marginal N L t 0).quasiMeasurePreserving.ae_eq_comp
    ((Lp.memLp (modulusScalar f)).indicator hS).coeFn_toLp).filter_mono (ae_mono (Measure.restrict_le_self (s := staysAllowed N L a)))
  have h₂ := ((freePathLaw_marginal N L t 0).quasiMeasurePreserving.ae_eq_comp
    (coe_modulusScalar f)).filter_mono (ae_mono (Measure.restrict_le_self (s := staysAllowed N L a)))
  have h₃ := ((freePathLaw_marginal N L t 1).quasiMeasurePreserving.ae_eq_comp
    (coe_modulusScalar g)).filter_mono (ae_mono (Measure.restrict_le_self (s := staysAllowed N L a)))
  filter_upwards [h₁,h₂,h₃] with ω h₁ h₂ h₃
  dsimp only [Function.comp_def] at h₁ h₂ h₃
  rw [h₁]
  by_cases hx : ω 0∈S
  · simp only [Set.indicator_of_mem hx,Set.indicator_of_mem (show ω∈(fun ω : ConfigurationPath N L ↦ ω 0) ⁻¹' S from hx),
      h₂,h₃,Complex.conj_ofReal,Complex.ofReal_mul]
  · simp only [Set.indicator_of_notMem hx,Set.indicator_of_notMem (show ω∉(fun ω : ConfigurationPath N L ↦ ω 0) ⁻¹' S from hx),
      map_zero,zero_mul]

lemma modulus_indicator_inner (f : ScalarL2 N L) {S : Set (Configuration N L)}
    (hS : MeasurableSet S) :
    inner ℂ (((Lp.memLp (modulusScalar f)).indicator hS).toLp (S.indicator (modulusScalar f)))
      (modulusScalar f) = ((∫ X in S, ‖f X‖^2):ℝ) := by
  rw [L2.inner_def,← integral_complex_ofReal,← integral_indicator hS]
  apply integral_congr_ae
  filter_upwards [((Lp.memLp (modulusScalar f)).indicator hS).coeFn_toLp,
    coe_modulusScalar f] with X h₁ h₂
  rw [h₁]
  by_cases hx : X∈S
  · simp only [Set.indicator_of_mem hx,h₂,RCLike.inner_apply,Complex.conj_ofReal,
      pow_two,Complex.ofReal_mul]
  · simp only [Set.indicator_of_notMem hx,inner_zero_left]

lemma IsGroundVector.endpoint_norm_setIntegral {u : Jet N L} (hu : IsGroundVector N L a u)
    (ht : 0 ≤ t) {S : Set (Configuration N L)} (hS : MeasurableSet S) :
    (∫ ω : ConfigurationPath N L in (fun ω ↦ ω 0) ⁻¹' S,
      ‖u.1 (ω 0)‖*‖u.1 (ω 1)‖ ∂killedPathLaw N L a t)=
      Real.exp (-t*energy u)*(∫ X in S, ‖u.1 X‖^2) := by
  apply Complex.ofReal_injective
  rw [← modulus_indicator_pairing u.1 u.1 hS,
    show modulusScalar u.1=(modulusJet u).1 from rfl,hu.modulus.killed_eigenvector ht,
    inner_smul_right,hu.energy_modulus]
  change _ * inner ℂ (((Lp.memLp (modulusScalar u.1)).indicator hS).toLp (S.indicator (modulusScalar u.1)))
      (modulusScalar u.1) = _
  rw [modulus_indicator_inner u.1 hS,Complex.ofReal_mul]

lemma IsGroundVector.groundPathLaw_initial {u : Jet N L} (hu : IsGroundVector N L a u)
    (ht : 0 ≤ t) :
    MeasurePreserving (fun ω : ConfigurationPath N L ↦ ω 0) (groundPathLaw N L a t u)
      (groundPositionLaw N L u) := by
  refine ⟨(continuous_eval_const (0:Time)).measurable,Measure.ext fun S hS ↦ ?_⟩
  rw [Measure.map_apply (continuous_eval_const (0:Time)).measurable hS,
    groundPathLaw,groundPositionLaw,
    withDensity_apply _ (hS.preimage (continuous_eval_const (0:Time)).measurable),
    withDensity_apply _ hS,
    ← ofReal_integral_eq_lintegral_ofReal (groundPathWeight_integrable u a t).integrableOn
      (Eventually.of_forall (groundPathWeight_nonneg u t)),
    ← ofReal_integral_eq_lintegral_ofReal
      ((Lp.memLp u.1).integrable_norm_pow (by norm_num : (2:ℕ)≠0)).integrableOn
      (Eventually.of_forall fun X ↦ sq_nonneg ‖u.1 X‖)]
  congr 1
  simp only [groundPathWeight,integral_const_mul]
  rw [hu.endpoint_norm_setIntegral ht hS,← mul_assoc,← Real.exp_add,
    show t*energy u+ -t*energy u=0 by ring,Real.exp_zero,one_mul]

lemma IsGroundVector.groundPathLaw_terminal {u : Jet N L} (hu : IsGroundVector N L a u)
    (ht : 0 ≤ t) :
    MeasurePreserving (fun ω : ConfigurationPath N L ↦ ω 1) (groundPathLaw N L a t u)
      (groundPositionLaw N L u) := by
  simpa only [Function.comp_def,reverseConfigurationPath_apply,reverseTime_zero] using
    (hu.groundPathLaw_initial ht).comp (groundPathLaw_reversal u a t)

end
end HardSphere

end
end
end

end OAI