import Mathlib
import OAI.Analysis.HardSphere.Geometry.SmoothSpatialCountMgf
import OAI.Analysis.HardSphere.PathBounds.SingleVisitDefect
import OAI.Analysis.HardSphere.Orbitals.SelectedDeletion

namespace OAI

section

section
noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology BigOperators
namespace HardSphere
open Wiener
lemma spatial_count_mgf_enn : ∃ C αstar : ℝ, 0 < C ∧ 0 < αstar ∧
    ∀ (n K : ℕ) (L : Length), L.val=(K:ℝ) → ∀ (r D : ℝ),
      D=(n:ℝ)/L.val^3 → 1≤D → αstar≤D*r → 0<r → 1≤L.val →
      (n:ℝ)*(2*Real.pi*r)^3≤L.val^3/2 →
    ∀ (g : Jet n L), IsGroundVector n L r g →
    ∀ (A : Finset (Torus L)) (z : ℝ), 0≤z → z≤1 →
      (∫⁻ X, ENNReal.ofReal (Real.exp (z*weightedSiteCount L A X)) ∂groundPositionLaw n L g)≤
        ENNReal.ofReal (Real.exp (C*z*D*(A.card:ℝ))) := by
  obtain ⟨C,αstar,hC,hα,h⟩ := spatial_count_mgf
  refine ⟨C,αstar,hC,hα,?_⟩
  intro n K L hL r D hDeq hD hαr hr hsize hs g hg A z hz hz1
  let := groundPositionLaw_probability g hg.2.2.1
  have hi := bounded_mgf_integrable (groundPositionLaw n L g)
    (weightedSiteCount_continuous L A).measurable
    (fun X ↦ (abs_of_nonneg (weightedSiteCount_nonneg L A X)).trans_le (weightedSiteCount_le L A X)) z
  rw [←ofReal_integral_eq_lintegral_ofReal hi (Eventually.of_forall (fun X ↦ (Real.exp_pos _).le))]
  apply ENNReal.ofReal_le_ofReal
  have hp : 0<∫ X,Real.exp (z*weightedSiteCount L A X) ∂groundPositionLaw n L g := ProbabilityTheory.mgf_pos hi
  calc
    _ = Real.exp (Real.log (∫ X,Real.exp (z*weightedSiteCount L A X) ∂groundPositionLaw n L g)) := (Real.exp_log hp).symm
    _ ≤ _ := Real.exp_le_exp.mpr (h n K L hL r D hDeq hD hαr hr hsize hs g hg A z hz hz1)

namespace FreeVisits
open HardSphere.BathSlice HardSphere.Lattice HardSphere.CellOrbital
attribute [local irreducible] freeTrajectory pathVisitedSites torusDistance

def defectiveTotalVisits {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
    (D : Set (ConfigurationPath 1 L)) (ω : ConfigurationPath n L) : ℕ := by
  classical
  exact ∑ i, if onePathAt i ω∈D then (pathVisitedSites L (siteCenter L) A i ω).card else 0

lemma pathVisitedSites_onePathAt {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
    (i : Fin n) (ω : ConfigurationPath n L) :
    pathVisitedSites L (siteCenter L) A 0 (onePathAt i ω)=pathVisitedSites L (siteCenter L) A i ω := by
  simp only [pathVisitedSites,pathVisitsBall,onePathAt,oneConfiguration,ContinuousMap.coe_mk]
  rfl

lemma exp_defectiveTotalVisits {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
    (D : Set (ConfigurationPath 1 L)) {η : ℝ} (hη : 0≤η) (ω : ConfigurationPath n L) :
    ENNReal.ofReal (Real.exp (η*(defectiveTotalVisits L A D ω : ℝ)))=
      ∏ i, (1+singleVisitDefect L A η D (onePathAt i ω)) := by
  classical
  simp only [defectiveTotalVisits,Nat.cast_sum,Finset.mul_sum,Real.exp_sum,
    ENNReal.ofReal_prod_of_nonneg (fun _ _ ↦ (Real.exp_pos _).le)]
  apply Finset.prod_congr rfl
  intro i _
  rw [singleVisitDefect,pathVisitedSites_onePathAt]
  have hx : 0≤η*(if onePathAt i ω∈D then ((pathVisitedSites L (siteCenter L) A i ω).card:ℝ) else 0) := by positivity
  have he : 0≤Real.exp (η*(if onePathAt i ω∈D then ((pathVisitedSites L (siteCenter L) A i ω).card:ℝ) else 0))-1 := sub_nonneg.mpr (Real.one_le_exp_iff.mpr hx)
  simp only [Nat.cast_ite,Nat.cast_zero]
  rw [←ENNReal.ofReal_one,←ENNReal.ofReal_add zero_le_one he]
  congr 1
  ring

lemma product_one_add_exp_le {n : ℕ} (L : Length) (A : Finset (Torus L))
    (hA : A.Nonempty) {z : ℝ} (hz : 0≤z) (X : Configuration n L) :
    (∏ i, (1+ENNReal.ofReal (z*Real.exp (-spatialSiteDistance L A (X i)))))≤
      ENNReal.ofReal (Real.exp (z*weightedSiteCount L A X)) := by
  classical
  simp only [weightedSiteCount,ite_eq_left hA,Finset.mul_sum,Real.exp_sum,
    ENNReal.ofReal_prod_of_nonneg (fun _ _ ↦ (Real.exp_pos _).le)]
  apply Finset.prod_le_prod
  intro i _
  rw [←ENNReal.ofReal_one,←ENNReal.ofReal_add zero_le_one (by positivity)]
  apply ENNReal.ofReal_le_ofReal
  linarith [Real.add_one_le_exp (z*Real.exp (-spatialSiteDistance L A (X i)))]

theorem interacting_visit_mgf {η₀ : ℝ} (hη₀ : 0≤η₀) :
    ∃ Cdel Cfree Csp αstar : ℝ,
      0<Cdel ∧ 0<Cfree ∧ 0<Csp ∧ 0<αstar ∧
    ∀ (n K : ℕ) [NeZero K] (L : Length), L.val=(K:ℝ) → ∀ r D : ℝ,
      D=(n:ℝ)/L.val^3 → 1≤D → αstar≤D*r → 0<r →
      (n:ℝ)*(2*Real.pi*r)^3≤L.val^3/2 →
    ∀ (g : Jet n L), IsGroundVector n L r g →
    ∀ (A : Finset (DiscreteTorus K)) {t η ε : ℝ},
      0<t → t≤2 → 0≤η → η≤η₀ → 0≤ε →
    ∀ E : Set (ConfigurationPath 1 L), MeasurableSet E →
      (∀ω,reverseConfigurationPath 1 L ω∈E ↔ ω∈E) →
      (∀ y : Torus L, coordinateWiener 1 {w | freeTrajectory 1 L t w (oneConfiguration y)∈E}≤ENNReal.ofReal ε) →
      Real.exp (t*Cdel*D*r)*(Cfree*η*ε^(1/3:ℝ))≤1 →
      (∫⁻ ω, ENNReal.ofReal (Real.exp (η*(defectiveTotalVisits L A E ω:ℝ)))
        ∂groundPathLaw n L r t g) ≤
        ENNReal.ofReal (Real.exp (Csp*(Real.exp (t*Cdel*D*r)*(Cfree*η*ε^(1/3:ℝ)))*D*(A.card:ℝ))) := by
  classical
  obtain ⟨Cdel,hCdel,hdel⟩ := ground_product_one_add
  obtain ⟨Cfree,hCfree,hfree⟩ := free_single_defect_bound hη₀
  obtain ⟨Csp,αstar,hCsp,hα,hsp⟩ := spatial_count_mgf_enn
  refine ⟨Cdel,Cfree,Csp,αstar,hCdel,hCfree,hCsp,hα,?_⟩
  intro n K inst L hL r D hDeq hD hαr hr hs g hg A t η ε ht ht2 hη hη0 hε E hE hrev hprob hz1
  let z := Real.exp (t*Cdel*D*r)*(Cfree*η*ε^(1/3:ℝ))
  have hz : 0≤z := by positivity
  have hsize : 1≤L.val := by rw [hL]; exact_mod_cast (NeZero.pos K)
  let := hg.groundPathLaw_probability ht.le
  by_cases hA : A.Nonempty
  · let B := A.image (siteCenter L)
    have hB : B.Nonempty := hA.image _
    have hDexp : t*Cdel*(n:ℝ)*r/L.val^3=t*Cdel*D*r := by rw [hDeq]; ring
    calc
      _ = ∫⁻ ω,∏i,(1+singleVisitDefect L A η E (onePathAt i ω)) ∂groundPathLaw n L r t g :=
        lintegral_congr (exp_defectiveTotalVisits L A E hη)
      _ ≤ ∫⁻ X,∏i,(1+ENNReal.ofReal (Real.exp (t*Cdel*(n:ℝ)*r/L.val^3))*
          oneFreeExpectation t (singleVisitDefect L A η E) (X i)) ∂groundPositionLaw n L g :=
        hdel n L r t hr ht hs g hg _ (singleVisitDefect_measurable L A η hE) (singleVisitDefect_reverse L A η hrev)
      _ ≤ ∫⁻ X,ENNReal.ofReal (Real.exp (z*weightedSiteCount L B X)) ∂groundPositionLaw n L g := by
        apply lintegral_mono
        intro X
        apply le_trans _ (product_one_add_exp_le L B hB hz X)
        apply Finset.prod_le_prod
        intro i _
        gcongr
        have H := hfree L hL A ht ht2 hη hη0 hε E hE hprob (X i)
        calc
          _ ≤ ENNReal.ofReal (Real.exp (t*Cdel*(n:ℝ)*r/L.val^3))*
              ENNReal.ofReal (Cfree*η*ε^(1/3:ℝ)*Real.exp (-spatialSiteDistance L B (X i))) := by gcongr
          _ = _ := by rw [←ENNReal.ofReal_mul (Real.exp_nonneg _),hDexp]; congr 1; dsimp [z]; ring
      _ ≤ ENNReal.ofReal (Real.exp (Csp*z*D*(B.card:ℝ))) :=
        hsp n K L hL r D hDeq hD hαr hr hsize hs g hg B z hz hz1
      _ ≤ _ := by
        apply ENNReal.ofReal_le_ofReal
        apply Real.exp_le_exp.mpr
        have hc : (B.card:ℝ)≤(A.card:ℝ) := by exact_mod_cast Finset.card_image_le
        exact mul_le_mul_of_nonneg_left hc (by positivity)
  · have he : A=∅ := Finset.not_nonempty_iff_eq_empty.mp hA
    subst A
    simp [defectiveTotalVisits,pathVisitedSites]

end FreeVisits
end HardSphere

end
end

section
noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology BigOperators
namespace HardSphere
open Wiener BathSlice _root_.OAI.HardSphere.Lattice CellOrbital

lemma torusDistance_add (L : Length) (x y c : Torus L) :
    torusDistance L (x+c) (y+c)=torusDistance L x y := by
  unfold torusDistance
  congr 1
  apply Finset.sum_congr rfl
  intro j _
  simp only [Pi.add_apply,dist_add_right]

def shiftPath {n : ℕ} {L : Length} (c : Torus L) (ω : ConfigurationPath n L) : ConfigurationPath n L :=
  ⟨fun s i ↦ ω s i+c,by fun_prop⟩

lemma shiftPath_continuous {n : ℕ} {L : Length} (c : Torus L) : Continuous (shiftPath (n:=n) c) := by
  apply ContinuousMap.continuous_of_continuous_uncurry
  change Continuous (fun p : ConfigurationPath n L×Time ↦ fun i ↦ p.1 p.2 i+c)
  fun_prop

@[simp] lemma shiftPath_neg {n : ℕ} {L : Length} (c : Torus L) (ω : ConfigurationPath n L) :
    shiftPath c (shiftPath (-c) ω)=ω := by
  ext s i j
  simp [shiftPath]

@[simp] lemma shiftPath_reverse {n : ℕ} {L : Length} (c : Torus L) (ω : ConfigurationPath n L) :
    shiftPath c (reverseConfigurationPath n L ω)=reverseConfigurationPath n L (shiftPath c ω) := rfl

lemma shiftPath_free {n : ℕ} {L : Length} (c : Torus L) (t : ℝ) (w : CoordinatePaths n) (X : Configuration n L) :
    shiftPath c (freeTrajectory n L t w X)=freeTrajectory n L t w (fun i ↦ X i+c) := by
  ext s i j
  simp only [shiftPath,ContinuousMap.coe_mk,freeTrajectory,Pi.add_apply]
  abel

lemma spatialSiteDistance_add (L : Length) (A : Finset (Torus L)) (x c : Torus L) :
    spatialSiteDistance L (A.image (fun v ↦ v+c)) (x+c)=spatialSiteDistance L A x := by
  classical
  by_cases hA : A.Nonempty
  · obtain ⟨y,hy,he⟩ := spatialSiteDistance_attained L A hA x
    obtain ⟨z,hz,hf⟩ := spatialSiteDistance_attained L (A.image (fun v ↦ v+c)) (hA.image _) (x+c)
    obtain ⟨w,hw,rfl⟩ := Finset.mem_image.mp hz
    apply le_antisymm
    · rw [he]
      have h := spatialSiteDistance_le L (A.image (fun v ↦ v+c)) (x+c) (y+c) (Finset.mem_image.mpr ⟨y,hy,rfl⟩)
      simpa only [torusDistance_add] using h
    · rw [hf,torusDistance_add]
      exact spatialSiteDistance_le L A x w hw
  · have := Finset.not_nonempty_iff_eq_empty.mp hA
    subst A
    simp [spatialSiteDistance]

namespace ShiftVisits
open FreeVisits
attribute [local instance] Classical.propDecidable

def center {K : ℕ} (L : Length) (c : Torus L) (v : DiscreteTorus K) : Torus L := siteCenter L v+c

def singleDefect {K : ℕ} (L : Length) (c : Torus L) (A : Finset (DiscreteTorus K))
    (η : ℝ) (D : Set (ConfigurationPath 1 L)) (ω : ConfigurationPath 1 L) : ℝ≥0∞ :=
  ENNReal.ofReal (Real.exp (η*(if ω∈D then ((pathVisitedSites L (center L c) A 0 ω).card:ℝ) else 0))-1)

lemma shifted_visits {n K : ℕ} (L : Length) (c : Torus L) (A : Finset (DiscreteTorus K))
    (i : Fin n) (ω : ConfigurationPath n L) :
    pathVisitedSites L (siteCenter L) A i (shiftPath (-c) ω)=pathVisitedSites L (center L c) A i ω := by
  apply Finset.filter_congr
  intro v _
  unfold pathVisitsBall
  apply exists_congr
  intro s
  change (torusDistance L (ω s i+-c) (siteCenter L v)≤12) ↔ _
  have hd := torusDistance_add L (ω s i+-c) (siteCenter L v) c
  simp only [neg_add_cancel_right] at hd
  rw [←hd]
  rfl

lemma singleDefect_eq (L : Length) {K : ℕ} (c : Torus L) (A : Finset (DiscreteTorus K))
    (η : ℝ) (D : Set (ConfigurationPath 1 L)) (ω : ConfigurationPath 1 L) :
    singleDefect L c A η D ω=singleVisitDefect L A η ((shiftPath c)⁻¹' D) (shiftPath (-c) ω) := by
  simp only [singleDefect,singleVisitDefect,Set.mem_preimage,shiftPath_neg,shifted_visits]

lemma singleDefect_measurable (L : Length) {K : ℕ} (c : Torus L) (A : Finset (DiscreteTorus K))
    (η : ℝ) {D : Set (ConfigurationPath 1 L)} (hD : MeasurableSet D) :
    Measurable (singleDefect L c A η D) := by
  have he : singleDefect L c A η D=(singleVisitDefect L A η ((shiftPath c)⁻¹' D)) ∘ shiftPath (-c) :=
    funext (singleDefect_eq L c A η D)
  rw [he]
  exact (singleVisitDefect_measurable L A η (hD.preimage (shiftPath_continuous c).measurable)).comp
    (shiftPath_continuous (-c)).measurable

lemma singleDefect_reverse (L : Length) {K : ℕ} (c : Torus L) (A : Finset (DiscreteTorus K))
    (η : ℝ) {D : Set (ConfigurationPath 1 L)}
    (hD : ∀ω,reverseConfigurationPath 1 L ω∈D ↔ ω∈D) (ω : ConfigurationPath 1 L) :
    singleDefect L c A η D (reverseConfigurationPath 1 L ω)=singleDefect L c A η D ω := by
  simp only [singleDefect,hD,pathVisitedSites_reverse]

lemma free_single_defect_bound {η₀ : ℝ} (hη₀ : 0≤η₀) : ∃ C : ℝ,0<C ∧
    ∀ {K : ℕ} [NeZero K] (L : Length),L.val=(K:ℝ) → ∀ (c : Torus L) (A : Finset (DiscreteTorus K)),
    ∀ {t η ε : ℝ},0<t → t≤2 → 0≤η → η≤η₀ → 0≤ε →
    ∀ D : Set (ConfigurationPath 1 L),MeasurableSet D →
      (∀ y : Torus L,coordinateWiener 1 {w | freeTrajectory 1 L t w (oneConfiguration y)∈D}≤ENNReal.ofReal ε) →
    ∀ y : Torus L,oneFreeExpectation t (singleDefect L c A η D) y ≤
      ENNReal.ofReal (C*η*ε^(1/3:ℝ)*Real.exp (-spatialSiteDistance L (A.image (center L c)) y)) := by
  obtain ⟨C,hC,h⟩ := FreeVisits.free_single_defect_bound hη₀
  refine ⟨C,hC,?_⟩
  intro K _ L hL c A t η ε ht ht2 hη hη0 hε D hD hprob y
  let E := (shiftPath c)⁻¹' D
  have hE : MeasurableSet E := hD.preimage (shiftPath_continuous c).measurable
  have hp (z : Torus L) : coordinateWiener 1 {w | freeTrajectory 1 L t w (oneConfiguration z)∈E}≤ENNReal.ofReal ε := by
    have hh := hprob (z+c)
    change coordinateWiener 1 {w | freeTrajectory 1 L t w (fun _ ↦ z+c)∈D}≤ENNReal.ofReal ε at hh
    simpa only [E,mem_preimage,shiftPath_free,oneConfiguration] using hh
  have hh := h L hL A ht ht2 hη hη0 hε E hE hp (y+-c)
  have hf : oneFreeExpectation t (singleDefect L c A η D) y=
      oneFreeExpectation t (singleVisitDefect L A η E) (y+-c) := by
    apply lintegral_congr
    intro w
    rw [singleDefect_eq,shiftPath_free]
    rfl
  rw [hf]
  have hd : spatialSiteDistance L (A.image (center L c)) y=spatialSiteDistance L (A.image (siteCenter L)) (y+-c) := by
    have hh := spatialSiteDistance_add L (A.image (siteCenter L)) (y+-c) c
    change spatialSiteDistance L (A.image (fun v ↦ siteCenter L v+c)) y = _
    simpa only [Finset.image_image,Function.comp_def,neg_add_cancel_right] using hh
  rw [hd]
  exact hh

end ShiftVisits
end HardSphere

end
end

end

end OAI