import Mathlib
import OAI.Analysis.HardSphere.Bridges.BridgeAssemble

namespace OAI

section

section
noncomputable section
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal NNReal Topology BigOperators
namespace HardSphere.Bridge
open Wiener GaussianPacking

lemma midpointPoint_continuous (t : ℝ) (y z : Point) : Continuous (midpointPoint t y z) := by
  unfold midpointPoint
  fun_prop

def midpointLaw (t : ℝ) (y z : Point) : Measure Point := midpointNoise.map (midpointPoint t y z)
instance midpointLaw_probability (t : ℝ) (y z : Point) : IsProbabilityMeasure (midpointLaw t y z) := by
  unfold midpointLaw
  infer_instance

lemma trial_product (μ : Measure Point) [SFinite μ] (t : ℝ) (y z : Point) :
    (μ.compProd (trialKernel t y z)).map Prod.snd=
      (μ.prod (law.prod law)).map (fun p ↦ trialPath t y z p.1 p.2) := by
  ext B hB
  rw [Measure.map_apply measurable_snd hB,Measure.compProd_apply (hB.preimage measurable_snd),
    Measure.map_apply (trialPath_continuous t y z).measurable hB,
    Measure.prod_apply (hB.preimage (trialPath_continuous t y z).measurable)]
  apply lintegral_congr
  intro u
  change (trialKernel t y z u) B = (law.prod law) ((fun p ↦ trialPath t y z u p) ⁻¹' B)
  rw [trialKernel_apply]
  have hm : Continuous (trialPath t y z u) := (trialPath_continuous t y z).comp (continuous_const.prodMk continuous_id)
  exact Measure.map_apply hm.measurable hB

lemma full_bridge_midpoint {t : ℝ} (ht : 0≤t) (y z : Point) :
    ((midpointLaw t y z).compProd (trialKernel t y z)).map Prod.snd=
      law.map (leg (2*t) y z) := by
  rw [trial_product]
  have hpin : MeasurePreserving pinned law law := ⟨pinned_continuous.measurable,pinned_law⟩
  have hn := ((MeasurePreserving.id midpointNoise).prod hpin).prod (reverseNoise_preserving.comp hpin)
  have ha := assembleNoise_preserving.comp hn
  have hl := congrArg (fun μ : Measure Noise ↦ μ.map (leg (2*t) y z)) ha.map_eq
  rw [Measure.map_map (leg_continuous (2*t) y z).measurable ha.measurable] at hl
  have hm : MeasurePreserving (midpointPoint t y z) midpointNoise (midpointLaw t y z) :=
    ⟨(midpointPoint_continuous t y z).measurable,rfl⟩
  have hp := hm.prod (MeasurePreserving.id (law.prod law))
  have he := congrArg (fun μ : Measure (Point×(Noise×Noise)) ↦ μ.map (fun p ↦ trialPath t y z p.1 p.2)) hp.map_eq
  rw [Measure.map_map (trialPath_continuous t y z).measurable hp.measurable] at he
  rw [←he,← Measure.prodAssoc_prod (μ := midpointNoise) (ν := law) (τ := law),
    Measure.map_map ((trialPath_continuous t y z).measurable.comp hp.measurable) MeasurableEquiv.prodAssoc.measurable]
  convert hl using 1
  congr 1
  funext p
  exact trial_assemble t ht y z p.1.1 p.1.2 p.2

lemma midpointLaw_gaussian {t : ℝ} (ht : 0≤t) (y z : Point) :
    midpointLaw t y z=Measure.pi (fun j : Fin 3 ↦ gaussianReal ((y j+z j)/2) (Real.toNNReal t)) := by
  unfold midpointLaw midpointNoise midpointPoint
  rw [Measure.pi_map_pi (fun _ ↦ (by fun_prop : Measurable (fun v : ℝ ↦ (_ : ℝ)+Real.sqrt (4*t)*v)).aemeasurable)]
  congr 1
  funext j
  have h : HasLaw id (gaussianReal 0 (Real.toNNReal (1/4:ℝ))) (gaussianReal 0 (Real.toNNReal (1/4:ℝ))) := ⟨measurable_id.aemeasurable,Measure.map_id⟩
  have he := (gaussianReal_const_add (gaussianReal_const_mul h (Real.sqrt (4*t))) ((y j+z j)/2)).map_eq
  simp only [mul_zero,zero_add] at he
  change _ = _ at he
  change (Measure.map (fun v ↦ (y j+z j)/2+Real.sqrt (4*t)*v) _) = _
  simp only [id_eq] at he
  rw [he]
  apply congrArg (gaussianReal ((y j+z j)/2))
  apply NNReal.coe_injective
  simp only [NNReal.coe_mul,NNReal.coe_mk,Real.coe_toNNReal _ ht,
    Real.coe_toNNReal _ (show 0≤(1/4:ℝ) by norm_num),Real.sq_sqrt (show 0≤4*t by positivity)]
  ring

end HardSphere.Bridge

end
end

section
noncomputable section
open MeasureTheory ProbabilityTheory Set
open scoped ENNReal NNReal Topology BigOperators
namespace HardSphere.GaussianPacking

def densityLower (b C : ℝ) : ℝ := (Real.sqrt (b/Real.pi))^3*Real.exp (-b*(3*C^2))
lemma densityLower_pos {b : ℝ} (hb : 0<b) (C : ℝ) : 0<densityLower b C := by
  unfold densityLower
  exact mul_pos (pow_pos (Real.sqrt_pos.mpr (div_pos hb Real.pi_pos)) _) (Real.exp_pos _)

lemma density_lower {b C : ℝ} (hb : 0≤b) (hC : 0≤C) (x : Point) (hx : ‖x‖≤C) :
    densityLower b C≤density b x := by
  have hs : square x≤3*C^2 := by
    unfold square
    calc
      _ ≤ ∑_j : Fin 3,C^2 := Finset.sum_le_sum (fun j _ ↦ by
        have h := (norm_le_pi_norm x j).trans hx
        simpa only [Real.norm_eq_abs,sq_abs] using (sq_le_sq₀ (norm_nonneg (x j)) hC).mpr h)
      _ = _ := by simp
  unfold density densityLower kernel
  exact mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr (by nlinarith)) (by positivity)

lemma gaussian_dominates_local {v : ℝ≥0} (hv : v≠0) (q : Point) {C : ℝ} (hC : 0≤C)
    {B : Set Point} (hB : MeasurableSet B) (hbound : ∀x∈B,‖x-q‖≤C) :
    ENNReal.ofReal (densityLower ((2*(v:ℝ))⁻¹) C) • (volume.restrict B) ≤
      Measure.pi (fun j : Fin 3 ↦ gaussianReal (q j) v) := by
  rw [gaussian_pi_eq q hv]
  apply Measure.le_iff.mpr
  intro A hA
  rw [Measure.smul_apply,smul_eq_mul,Measure.restrict_apply hA,
    withDensity_apply _ hA]
  calc
    _ = ∫⁻x in A∩B,ENNReal.ofReal (densityLower ((2*(v:ℝ))⁻¹) C) := by simp [lintegral_const]
    _ ≤ ∫⁻x in A∩B,ENNReal.ofReal (density ((2*(v:ℝ))⁻¹) (x-q)) := by
      apply setLIntegral_mono' (hA.inter hB)
      intro x hx
      exact ENNReal.ofReal_le_ofReal (density_lower (by positivity) hC (x-q) (hbound x hx.2))
    _ ≤ _ := lintegral_mono_set inter_subset_left

end HardSphere.GaussianPacking

end
end

end

end OAI