Add lean source and binary files (part 19)

lean/OAI/Analysis/HardSphere/Kernels/TrialObserved.lean

@@ -0,0 +1,57 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Kernels.TrialKernel
+import OAI.Analysis.HardSphere.Bridges.GaussianMixture
+import OAI.Analysis.HardSphere.Conditioning.RouteObservation
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set
+open scoped ENNReal
+namespace HardSphere.Comparison
+open Bridge Wiener GaussianPacking
+
+lemma trialKernel_midpoint (t : ℝ) (y z u : Point) :
+    ∀ᵐ ω ∂trialKernel t y z u,ω midpointTime=u := by
+  rw [trialKernel_apply]
+  apply (ae_map_iff ((trialPath_continuous t y z).measurable.comp
+    (measurable_const.prodMk measurable_id)).aemeasurable (measurableSet_eq_fun ((continuous_eval_const midpointTime).measurable : Measurable (fun ω : C(Time,Point) ↦ ω midpointTime)) measurable_const)).mpr
+  exact ae_of_all _ (fun β ↦ trial_midpoint t y z u β)
+
+lemma paired_trial_midpoint (μ : Measure Point) [SFinite μ] (t : ℝ) (y z y' z' : Point)
+    (S T : Set C(Time,Point)) (hS : MeasurableSet S) (hT : MeasurableSet T) :
+    ∀ᵐ p ∂pairedFactor μ (trialKernel t y z) (trialKernel t y' z') S T hS hT,
+      p.2.1 midpointTime=p.1 ∧ p.2.2 midpointTime=p.1 := by
+  apply pairedFactor_midpoint μ (trialKernel t y z) (trialKernel t y' z')
+    (fun ω ↦ ω midpointTime) (fun ω ↦ ω midpointTime) id
+    (continuous_eval_const midpointTime).measurable (continuous_eval_const midpointTime).measurable measurable_id
+  · exact ae_of_all _ (trialKernel_midpoint t y z)
+  · exact ae_of_all _ (trialKernel_midpoint t y' z')
+
+lemma route_observed_trial_eq {W : Type*} [MeasurableSpace W] (d : ℕ)
+    (τ : Fin (d+2) → Measure (Point×(C(Time,Point)×C(Time,Point))))
+    [∀k,IsProbabilityMeasure (τ k)] (ξ : Measure W) [SFinite ξ]
+    (hτ : ∀k,∀ᵐ p ∂τ k,p.2.1 midpointTime=p.1 ∧ p.2.2 midpointTime=p.1)
+    (C : Set ((Fin (d+2) → Point×(C(Time,Point)×C(Time,Point)))×W)) :
+    ((((Measure.pi τ).prod ξ) C)⁻¹ • ((Measure.pi τ).prod ξ).restrict C).map
+      (observeFirst d (fun ω ↦ ω midpointTime)) =
+    ((((Measure.pi τ).prod ξ) C)⁻¹ • ((Measure.pi τ).prod ξ).restrict C).map
+      (observeSecond d (fun ω ↦ ω midpointTime)) := by
+  apply conditioned_observed_measures_eq
+  apply (Measure.ae_prod_iff_ae_ae (by measurability)).mpr
+  have h : ∀k,∀ᵐ v ∂Measure.pi τ,(v k).2.1 midpointTime=(v k).1 ∧ (v k).2.2 midpointTime=(v k).1 :=
+    fun k ↦ (measurePreserving_eval τ k).quasiMeasurePreserving.ae (hτ k)
+  filter_upwards [ae_all_iff.mpr h] with v hv
+  exact ae_of_all _ (fun _ ↦ hv)
+
+end HardSphere.Comparison
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Main.lean

@@ -0,0 +1,50 @@
+import Mathlib
+import OAI.Analysis.HardSphere.FormDomain.AeSelfGradientSquare
+import OAI.Analysis.HardSphere.FormDomain.AeGradientPhase
+import OAI.Analysis.HardSphere.Conditioning.LintegralReferenceMeasure
+import OAI.Analysis.HardSphere.Bridges.AccessibleAuxiliary
+import OAI.Analysis.HardSphere.PathBounds.RegularVisitors
+import OAI.Analysis.HardSphere.Collisions.InsertionProducer
+import OAI.Analysis.HardSphere.Kernels.KernelPi
+import OAI.Analysis.HardSphere.Kernels.ParametricTrial
+import OAI.Analysis.HardSphere.PathBounds.UniformVisitMGF
+import OAI.Analysis.HardSphere.Density.GroundProjection
+
+namespace OAI
+
+section
+
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal BigOperators Topology
+namespace HardSphere
+
+theorem condensation_all_ground_states :
+    ∃ε₀ c₀ : ℝ,0<ε₀ ∧ 0<c₀ ∧
+    ∀(a ρ : ℝ) (ha : 0<a),0<ρ → ρ*a^3<ε₀ →
+    ∀(N : ℕ→ℕ) (L : ℕ→Length) (hN : ∀k,0<N k),
+      Tendsto N atTop atTop → Tendsto (fun k ↦ (L k).val) atTop atTop →
+      Tendsto (fun k ↦ (N k:ℝ)/(L k).val^3) atTop (𝓝 ρ) →
+      (∀Ψ : (k : ℕ)→Jet (N k) (L k),
+        (∀k,IsGroundVector (N k) (L k) a (Ψ k)) →
+        c₀≤liminf (fun k ↦ occupation (hN k) (Ψ k).1) atTop) ∧
+      (∀T : (k : ℕ)→Density.Operator (ScalarL2 (N k) (L k)),
+        (∀k,GroundSupported a (T k)) →
+        c₀≤liminf (fun k ↦ mixedOccupation (hN k) (T k)) atTop) ∧
+      (∀hG : ∀k,groundSpace (N k) (L k) a≠⊥,
+        c₀≤liminf (fun k ↦ mixedOccupation (hN k)
+          (normalizedGroundProjection (N k) (L k) a ha (hG k))) atTop) := by
+  obtain ⟨ε,c,hε,hc,h⟩ := condensation_with_mixed
+  refine ⟨ε,c,hε,hc,?_⟩
+  intro a ρ ha hρ hd N L hN hNtop hLtop hdensity
+  obtain ⟨hp,hm⟩ := h a ρ ha hρ hd N L hN hNtop hLtop hdensity
+  refine ⟨hp,hm,?_⟩
+  intro hG
+  exact hm (fun k ↦ normalizedGroundProjection (N k) (L k) a ha (hG k))
+    (fun k ↦ normalizedGroundProjection_supported (N k) (L k) a ha (hG k))
+
+end HardSphere
+end
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Model.lean

@@ -0,0 +1,59 @@
+import OAI.Analysis.HardSphere.CondensationDefinitions
+
+namespace OAI
+
+section
+
+section
+
+noncomputable section
+open MeasureTheory Filter Set
+open scoped ENNReal Topology BigOperators
+
+namespace HardSphere
+
+abbrev HilbertJet (N : ℕ) (L : Length) :=
+  PiLp 2 (fun _ : Option (Direction N) ↦ ScalarL2 N L)
+
+def Condensation : Prop :=
+  ∃ ε₀ c₀ : ℝ, 0 < ε₀ ∧ 0 < c₀ ∧
+    ∀ (a ρ : ℝ), 0 < a → 0 < ρ → ρ * a ^ 3 < ε₀ →
+    ∀ (N : ℕ → ℕ) (L : ℕ → Length) (hN : ∀ k, 0 < N k),
+      Tendsto N atTop atTop →
+      Tendsto (fun k ↦ (L k).val) atTop atTop →
+      Tendsto (fun k ↦ (N k : ℝ) / (L k).val ^ 3) atTop (𝓝 ρ) →
+      ∀ (Ψ : (k : ℕ) → Jet (N k) (L k)),
+        (∀ k, IsGroundVector (N k) (L k) a (Ψ k)) →
+        c₀ ≤ Filter.liminf (fun k ↦ occupation (hN k) (Ψ k).1) atTop
+
+lemma scalarL2_norm_exponent : Fact (1 ≤ (2 : ℝ≥0∞)) := inferInstance
+
+attribute [local instance] scalarL2_norm_exponent
+
+abbrev scalarL2_normedAddCommGroup (N : ℕ) (L : Length) :
+    NormedAddCommGroup (ScalarL2 N L) := inferInstance
+
+attribute [local instance] scalarL2_normedAddCommGroup
+
+abbrev scalarL2_addCommMonoid (N : ℕ) (L : Length) : AddCommMonoid (ScalarL2 N L) :=
+  (scalarL2_normedAddCommGroup N L).toAddCommMonoid
+
+abbrev scalarL2_innerProductSpace (N : ℕ) (L : Length) :
+    InnerProductSpace ℂ (ScalarL2 N L) := inferInstance
+
+attribute [local instance] scalarL2_innerProductSpace
+
+abbrev scalarL2_module (N : ℕ) (L : Length) : Module ℂ (ScalarL2 N L) :=
+  (scalarL2_innerProductSpace N L).toNormedSpace.toModule
+
+attribute [local instance] scalarL2_module
+
+lemma scalarL2_completeSpace (N : ℕ) (L : Length) : CompleteSpace (ScalarL2 N L) :=
+  inferInstance
+
+end HardSphere
+end
+end
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/CompactFormCutoff.lean

@@ -0,0 +1,162 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.HeatScalar
+
+namespace OAI
+
+noncomputable section
+open Set MeasureTheory Filter ContinuousLinearMap
+open scoped Topology ComplexOrder
+namespace HardSphere.CompactForm
+
+def cutoff (δ x : ℝ) : ℝ := Real.smoothTransition (((2 : ℕ) : ℝ)*x/δ-1)
+lemma cutoff_smooth (δ : ℝ) : ContDiff ℝ (⊤ : ℕ∞) (cutoff δ) := by
+  exact Real.smoothTransition.contDiff.comp ((contDiff_const.mul contDiff_id).div_const δ |>.sub contDiff_const)
+lemma cutoff_nonneg (δ x : ℝ) : 0≤cutoff δ x := Real.smoothTransition.nonneg _
+lemma cutoff_le_one (δ x : ℝ) : cutoff δ x≤1 := Real.smoothTransition.le_one _
+lemma cutoff_zero {δ x : ℝ} (hδ : 0<δ) (hx : x≤δ/2) : cutoff δ x=0 := by
+  apply Real.smoothTransition.zero_of_nonpos
+  have hh : 2*x/δ≤1 := (div_le_one hδ).mpr (by linarith)
+  linarith
+lemma cutoff_one {δ x : ℝ} (hδ : 0<δ) (hx : δ≤x) : cutoff δ x=1 := by
+  apply Real.smoothTransition.one_of_one_le
+  have hh : 2≤2*x/δ := (le_div_iff₀ hδ).mpr (by linarith)
+  linarith
+lemma cutoff_error {δ x : ℝ} (hδ : 0<δ) (hx : 0≤x) :
+    ‖(1-cutoff δ x)^2*x‖≤δ := by
+  have hq := cutoff_nonneg δ x
+  have hq' := cutoff_le_one δ x
+  rw [Real.norm_eq_abs,abs_of_nonneg (mul_nonneg (sq_nonneg _) hx)]
+  by_cases hh : δ≤x
+  · rw [cutoff_one hδ hh]; simpa using hδ.le
+  · have hx' : x≤δ := (lt_of_not_ge hh).le
+    have hs : (1-cutoff δ x)^2≤1 := by nlinarith
+    exact (mul_le_mul_of_nonneg_right hs hx).trans (by simpa using hx')
+
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+omit [CompleteSpace H] in
+lemma finite_range_compact (F : H →L[ℂ] H) (W : Submodule ℂ H)
+    [FiniteDimensional ℂ W] (hW : ∀x,F x∈W) : IsCompactOperator F := by
+  have hh := isCompactOperator_of_locallyCompactSpace_dom (F.codRestrict W hW)
+  exact hh.clm_comp W.subtypeL
+
+lemma cutoff_compact {ι : Type*} (T : H →L[ℂ] H) (hT : IsSelfAdjoint T)
+    (v : ι→H) (r : ι→ℝ)
+    (hdense : (Submodule.span ℂ (range v)).topologicalClosure=⊤)
+    (heigen : ∀i,T (v i)=r i • v i)
+    (hfinite : ∀ε : ℝ,0<ε → {i | ε≤r i}.Finite)
+    {δ : ℝ} (hδ : 0<δ) :
+    IsCompactOperator (cfc (p:=IsSelfAdjoint) (cutoff δ) T : H →L[ℂ] H) := by
+  let S : Set ι := {i | δ/2≤r i}
+  have hS : S.Finite := hfinite _ (by positivity)
+  let W : Submodule ℂ H := Submodule.span ℂ (v '' S)
+  have : FiniteDimensional ℂ W := FiniteDimensional.span_of_finite ℂ (hS.image v)
+  apply finite_range_compact _ W
+  have hgen : Submodule.span ℂ (range v) ≤
+      W.comap (cfc (p:=IsSelfAdjoint) (cutoff δ) T).toLinearMap := by
+    apply Submodule.span_le.mpr
+    rintro _ ⟨i,rfl⟩
+    change cfc (p:=IsSelfAdjoint) (cutoff δ) T (v i)∈W
+    rw [cfc_eigen_apply T hT _ (cutoff_smooth δ).continuous _
+      ((cutoff_smooth δ).differentiable (by norm_num)).differentiableAt _ (heigen i)]
+    by_cases hi : i∈S
+    · exact W.smul_mem _ (Submodule.subset_span ⟨i,hi,rfl⟩)
+    · have hr : r i≤δ/2 := (lt_of_not_ge hi).le
+      rw [cutoff_zero hδ hr,zero_smul]
+      exact W.zero_mem
+  have hclosed : IsClosed (W.comap (cfc (p:=IsSelfAdjoint) (cutoff δ) T).toLinearMap : Set H) :=
+    W.closed_of_finiteDimensional.preimage (cfc (p:=IsSelfAdjoint) (cutoff δ) T).continuous
+  have hh := (Submodule.span ℂ (range v)).topologicalClosure_minimal hgen hclosed
+  rw [hdense] at hh
+  intro x
+  exact hh (Submodule.mem_top : x∈(⊤ : Submodule ℂ H))
+
+end HardSphere.CompactForm
+
+namespace HardSphere.CompactForm
+variable {G H : Type*} [NormedAddCommGroup G] [InnerProductSpace ℂ G] [CompleteSpace G]
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+lemma cutoff_embedding_error (J : G →L[ℂ] H) (T : H →L[ℂ] H)
+    (hJT : J ∘L J.adjoint=T) (hT : T.IsPositive) (hTn : ‖T‖≤1)
+    {δ : ℝ} (hδ : 0<δ) :
+    ‖((1-cfc (p:=IsSelfAdjoint) (cutoff δ) T) : H →L[ℂ] H) ∘L J‖^2≤δ := by
+  let q : ℝ→ℝ := fun x ↦ 1-cutoff δ x
+  have hq : Continuous q := continuous_const.sub (cutoff_smooth δ).continuous
+  let Q : H →L[ℂ] H := cfc (p:=IsSelfAdjoint) q T
+  have hQ : Q=1-cfc (p:=IsSelfAdjoint) (cutoff δ) T := by
+    dsimp only [Q,q]
+    rw [cfc_sub _ _ T continuousOn_const (cutoff_smooth δ).continuous.continuousOn,
+      cfc_const 1 T hT.isSelfAdjoint,map_one]
+  have hQadj : Q.adjoint=Q := cfc_predicate q T
+  let E : G →L[ℂ] H := Q ∘L J
+  have hEE : E ∘L E.adjoint=Q*T*Q := by
+    change (Q ∘L J) ∘L (Q ∘L J).adjoint=Q*T*Q
+    rw [adjoint_comp,hQadj]
+    calc
+      _ = Q ∘L ((J ∘L J.adjoint) ∘L Q) := by simp only [comp_assoc]
+      _ = Q*T*Q := by rw [hJT]; rfl
+  have hcalc : Q*T*Q=cfc (p:=IsSelfAdjoint) (fun x : ℝ ↦ (1-cutoff δ x)^2*x) T := by
+    have hf : (fun x : ℝ ↦ (1-cutoff δ x)^2*x)=(fun x ↦ (q x*x)*q x) := by
+      funext x; dsimp only [q]; ring
+    rw [hf]
+    symm
+    calc
+      _ = cfc (p:=IsSelfAdjoint) (fun x : ℝ ↦ q x*x) T * cfc q T :=
+        cfc_mul (fun x : ℝ ↦ q x*x) q T (hq.mul continuous_id).continuousOn hq.continuousOn
+      _ = (cfc q T * cfc (p:=IsSelfAdjoint) id T) * cfc q T := by
+        congr 1
+        exact cfc_mul q id T hq.continuousOn continuous_id.continuousOn
+      _ = Q*T*Q := by
+        change cfc q T * cfc (p:=IsSelfAdjoint) (fun x : ℝ ↦ x) T * cfc q T = _
+        rw [cfc_id' ℝ T hT.isSelfAdjoint]
+  have hb : ‖E ∘L E.adjoint‖≤δ := by
+    rw [hEE,hcalc]
+    apply norm_cfc_le hδ.le
+    intro spectralValue hmem
+    have hnonneg := spectrum_nonneg_of_nonneg
+      (ContinuousLinearMap.nonneg_iff_isPositive.mpr hT) hmem
+    by_cases hlarge : 1 ≤ δ
+    · have hbound : spectralValue ≤ 1 := (le_abs_self _).trans
+        ((spectrum.norm_le_norm_mul_of_mem hmem).trans
+          ((mul_le_of_le_one_right (norm_nonneg T) norm_id_le).trans hTn))
+      have hcutoff : (1-cutoff δ spectralValue)^2 ≤ 1 := by
+        nlinarith [cutoff_nonneg δ spectralValue, cutoff_le_one δ spectralValue]
+      rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg (sq_nonneg _) hnonneg)]
+      exact (mul_le_of_le_one_left hnonneg hcutoff).trans (hbound.trans hlarge)
+    · exact cutoff_error hδ hnonneg
+  have hn := norm_adjoint_comp_self E.adjoint
+  rw [adjoint_adjoint,LinearIsometryEquiv.norm_map] at hn
+  rw [hn] at hb
+  change ‖Q ∘L J‖*‖Q ∘L J‖≤δ at hb
+  rw [hQ] at hb
+  simpa only [sq] using hb
+
+lemma compact_embedding {ι : Type*} (J : G →L[ℂ] H) (T : H →L[ℂ] H)
+    (hJT : J ∘L J.adjoint=T) (hT : T.IsPositive) (hTn : ‖T‖≤1)
+    (v : ι→H) (r : ι→ℝ)
+    (hdense : (Submodule.span ℂ (range v)).topologicalClosure=⊤)
+    (heigen : ∀i,T (v i)=r i • v i)
+    (hfinite : ∀ε : ℝ,0<ε → {i | ε≤r i}.Finite) : IsCompactOperator J := by
+  have hclosed : IsClosed {F : G →L[ℂ] H | IsCompactOperator F} := isClosed_setOfPred_isCompactOperator
+  apply hclosed.closure_subset
+  rw [Metric.mem_closure_iff]
+  intro ε hε
+  let δ : ℝ := ε^2/4
+  have hδ : 0<δ := by dsimp only [δ]; positivity
+  let F : H →L[ℂ] H := cfc (p:=IsSelfAdjoint) (cutoff δ) T
+  have hF : IsCompactOperator F := cutoff_compact T hT.isSelfAdjoint v r hdense heigen hfinite hδ
+  refine ⟨F ∘L J,hF.comp_clm J,?_⟩
+  rw [dist_eq_norm]
+  have heq : J-F ∘L J=(1-F) ∘L J := by ext x; simp
+  rw [heq]
+  have hh := cutoff_embedding_error J T hJT hT hTn hδ
+  change ‖(1-F) ∘L J‖^2≤δ at hh
+  have hn := norm_nonneg ((1-F) ∘L J)
+  dsimp only [δ] at hh
+  nlinarith
+
+end HardSphere.CompactForm
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/FormResolventNormEnergy.lean

@@ -0,0 +1,99 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Operators.KilledTransitionFormHeat
+import OAI.Analysis.HardSphere.Collisions.IteratedInsertion
+
+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 ContinuousLinearMap
+
+lemma formResolvent_norm_le_of_energy {N : ℕ} {L : Length} {a b : ℝ}
+    (hb : 0≤b) (henergy : ∀ u : Jet N L, u∈dirichletDomain N L a → b*‖u.1‖^2≤energy u) :
+    ‖formResolvent N L a‖≤(1+b)⁻¹ := by
+  have hp : 0<1+b := by linarith
+  apply opNorm_le_bound _ (inv_nonneg.mpr hp.le)
+  intro f
+  let g := (scalarEmbedding N L a).adjoint f
+  let u := hilbertJetEquiv N L (g : HilbertJet N L)
+  have hu : u∈dirichletDomain N L a := g.property
+  have he := henergy u hu
+  have hn : ‖g‖^2=‖u.1‖^2+energy u := hilbertJet_norm_sq (g : HilbertJet N L)
+  have hinner : ‖g‖^2=(inner ℂ f u.1).re := by
+    rw [norm_sq_eq_re_inner (𝕜 := ℂ)]
+    exact congrArg Complex.re (adjoint_inner_left (scalarEmbedding N L a) g f)
+  have hbound : (1+b)*‖u.1‖^2≤‖f‖*‖u.1‖ := by
+    have hi := re_inner_le_norm (𝕜 := ℂ) f u.1
+    change (inner ℂ f u.1).re≤‖f‖*‖u.1‖ at hi
+    nlinarith
+  change ‖u.1‖≤(1+b)⁻¹*‖f‖
+  by_cases hz : ‖u.1‖=0
+  · rw [hz]; positivity
+  · have hupos : 0<‖u.1‖ := lt_of_le_of_ne (norm_nonneg _) (Ne.symm hz)
+    rw [← div_eq_inv_mul,le_div_iff₀ hp]
+    nlinarith
+
+local instance scalarOperatorRealAlgebraCoercive (N : ℕ) (L : Length) :
+    Algebra ℝ (ScalarL2 N L →L[ℂ] ScalarL2 N L) := Algebra.restrictScalars ℝ ℂ _
+
+lemma formHeat_norm_le_of_energy {N : ℕ} {L : Length} {a b t : ℝ} (ht : 0<t)
+    (henergy : ∀ u : Jet N L, u∈dirichletDomain N L a → b*‖u.1‖^2≤energy u) :
+    ‖formHeat N L a t‖≤Real.exp (-t*b) := by
+  cases subsingleton_or_nontrivial (ScalarL2 N L) with
+  | inl h =>
+    let := h
+    rw [show formHeat N L a t=0 from Subsingleton.elim _ _,norm_zero]
+    exact (Real.exp_pos _).le
+  | inr h =>
+   let := h
+   by_cases hb : 0≤b
+   · have hp : 0<1+b := by linarith
+     have hR := formResolvent_norm_le_of_energy hb henergy
+     unfold formHeat
+     apply norm_cfc_le (Real.exp_pos _).le
+     intro x hx
+     have hx0 : 0≤x := spectrum_nonneg_of_nonneg
+        (ContinuousLinearMap.nonneg_iff_isPositive.mpr (formResolvent_isPositive N L a)) hx
+     have hxb : x≤(1+b)⁻¹ := (Real.le_norm_self x).trans ((spectrum.norm_le_norm_of_mem hx).trans hR)
+     rw [Real.norm_eq_abs,abs_of_nonneg (heatScalar_nonneg t x)]
+     rcases eq_or_lt_of_le hx0 with rfl | hx0
+     · rw [heatScalar_zero]; exact (Real.exp_pos _).le
+     · rw [heatScalar_of_pos ht hx0]
+       apply Real.exp_le_exp.mpr
+       have hxinv : 1+b≤x⁻¹ := by
+        simpa only [inv_inv] using (inv_le_inv₀ (inv_pos.mpr hp) hx0).mpr hxb
+       have hg := mul_le_mul_of_nonneg_left hxinv ht.le
+       rw [div_eq_mul_inv]
+       linarith
+   · have hnorm : ‖formHeat N L a t‖≤1 := by
+       rw [formHeat,← regularHeat_pos (formResolvent N L a) ht]
+       exact regularHeat_contract (formResolvent_isPositive N L a) (formResolvent_norm_le_one N L a) t
+     exact hnorm.trans (Real.one_le_exp (mul_nonneg_of_nonpos_of_nonpos (by linarith) (le_of_not_ge hb)))
+lemma killedTransition_norm_le_of_energy {N : ℕ} {L : Length} {a b t : ℝ} (ht : 0<t)
+    (henergy : ∀ u : Jet N L, u∈dirichletDomain N L a → b*‖u.1‖^2≤energy u) :
+    ‖killedTransition N L a t‖≤Real.exp (-t*b) := by
+  rw [killedTransition_eq_formHeat N L a ht]
+  exact formHeat_norm_le_of_energy ht henergy
+
+lemma bath_heat_bound : ∃ C : ℝ, 0<C ∧
+    ∀ (n m : ℕ) (L : Length) (r t : ℝ), 0<r → 0<t →
+    ((n+m:ℕ):ℝ)*(2*Real.pi*r)^3≤L.val^3/2 →
+    ∀ u : Jet (n+m) L, IsGroundVector (n+m) L r u →
+      ‖killedTransition n L r t‖≤
+        Real.exp (-t*(energy u-C*(m:ℝ)*((n+m:ℕ):ℝ)*r/L.val^3)) := by
+  obtain ⟨C,hC,hrem⟩ := ground_energy_removal
+  exact ⟨C,hC,fun n m L r t hr ht hs u hu ↦
+    killedTransition_norm_le_of_energy ht (hrem n m L r hr hs u hu)⟩
+end HardSphere
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/FreeResolventDenseRange.lean

@@ -0,0 +1,60 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Fourier.CharacterDerivativeFactor
+import OAI.Analysis.HardSphere.Geometry.GraphLiftHeatBound
+
+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
+namespace HardSphere
+open ContinuousLinearMap Filter
+open scoped Topology
+
+lemma freeResolvent_denseRange (N : ℕ) (L : Length) (a : ℝ) (ha : a<0) :
+    DenseRange (formResolvent N L a) := by
+  change Dense (Set.range (formResolvent N L a))
+  change Dense ((formResolvent N L a).range : Set (ScalarL2 N L))
+  apply Submodule.dense_iff_topologicalClosure_eq_top.mpr
+  apply top_unique
+  rw [← characterL2_span_dense N L]
+  apply Submodule.topologicalClosure_mono
+  apply Submodule.span_le.mpr
+  rintro _ ⟨k,rfl⟩
+  refine ⟨(1+(fourierEnergy N L k:ℂ)) • characterL2 N L k,?_⟩
+  change formResolvent N L a ((1+(fourierEnergy N L k:ℂ)) • characterL2 N L k)=_
+  rw [map_smul,character_resolvent N L a ha k,smul_smul,mul_inv_cancel₀,one_smul]
+  have hreal : (1:ℝ)+fourierEnergy N L k≠0 := ne_of_gt (by linarith [fourierEnergy_nonneg N L k])
+  exact_mod_cast hreal
+
+lemma free_graph_lift_of_heat_bound (N : ℕ) (L : Length) (a : ℝ) (ha : a<0)
+    (u : ScalarL2 N L) (C : ℝ)
+    (hb : ∀ n : ℕ, (1/((n:ℝ)+1))⁻¹ *
+      (‖u‖^2-(inner ℂ u (freeTransition N L (1/((n:ℝ)+1)) u)).re)≤C) :
+    ∃ v : hilbertDomain N L a, scalarEmbedding N L a v=u ∧ ‖v‖^2≤‖u‖^2+C := by
+  rcases subsingleton_or_nontrivial (ScalarL2 N L) with h | h
+  · have := h
+    refine ⟨0,Subsingleton.elim _ _,?_⟩
+    have hz : u=0 := Subsingleton.elim _ _
+    simpa [hz] using hb 0
+  have := h
+  apply exists_graph_lift_of_heat_bound (scalarEmbedding N L a) (scalarEmbedding_norm_le N L a)
+    (freeResolvent_denseRange N L a ha) u C
+  intro n
+  have ht : 0<1/((n:ℝ)+1) := by positivity
+  simpa only [formHeat,formResolvent] using
+    (show (1/((n:ℝ)+1))⁻¹ * (‖u‖^2-(inner ℂ u
+      (formHeat N L a (1/((n:ℝ)+1)) u)).re)≤C by
+        rw [← freeTransition_eq_formHeat N L a ha ht]
+        exact hb n)
+
+end HardSphere
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/FreeTransition.lean

@@ -0,0 +1,130 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Fourier.ArgumentAdd
+
+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
+namespace HardSphere
+open Wiener ProbabilityTheory
+open scoped ComplexConjugate
+
+lemma wiener_initial_zero : ∀ᵐ w : C(Time,ℝ) ∂wiener, w 0 = 0 := by
+  rw [wiener, ae_map_iff measurable_path.aemeasurable
+    (isClosed_eq (continuous_eval_const (0:Time)) continuous_const).measurableSet]
+  exact Filter.Eventually.of_forall path_at_zero
+
+lemma coordinateWiener_initial_zero (N : ℕ) :
+    ∀ᵐ w ∂coordinateWiener N, ∀ p, w p 0 = 0 := by
+  apply ae_all_iff.mpr
+  intro p
+  exact (measurePreserving_eval (fun _ : Direction N ↦ wiener) p).quasiMeasurePreserving.ae wiener_initial_zero
+
+lemma freeTrajectory_initial_ae (N : ℕ) (L : Length) (t : ℝ) :
+    ∀ᵐ w ∂coordinateWiener N, ∀ X, freeTrajectory N L t w X 0 = X := by
+  filter_upwards [coordinateWiener_initial_zero N] with w hw X
+  ext i j
+  simp only [freeTrajectory, ContinuousMap.coe_mk, hw (i,j), mul_zero,
+    QuotientAddGroup.mk_zero, add_zero]
+
+def freeTransition (N : ℕ) (L : Length) (t : ℝ) : ScalarL2 N L →L[ℂ] ScalarL2 N L :=
+  (endpointPull N L t 0).toContinuousLinearMap.adjoint ∘L
+    (endpointPull N L t 1).toContinuousLinearMap
+
+lemma freeTransition_pairing (N : ℕ) (L : Length) (t : ℝ) (f g : ScalarL2 N L) :
+    inner ℂ f (freeTransition N L t g) =
+      ∫ ω, conj (f (ω 0)) * g (ω 1) ∂freePathLaw N L t := by
+  rw [freeTransition, ContinuousLinearMap.comp_apply, ContinuousLinearMap.adjoint_inner_right,
+    L2.inner_def]
+  apply integral_congr_ae
+  filter_upwards [endpointPull_ae N L t 0 f, endpointPull_ae N L t 1 g] with ω hf hg
+  change inner ℂ ((endpointPull N L t 0) f ω) ((endpointPull N L t 1) g ω) = _
+  rw [hf,hg,RCLike.inner_apply,mul_comm]
+
+lemma freeTransition_continuous_pairing (N : ℕ) (L : Length) (t : ℝ)
+    (f g : C(Configuration N L,ℂ)) :
+    inner ℂ (ContinuousMap.toLp 2 volume ℂ f)
+      (freeTransition N L t (ContinuousMap.toLp 2 volume ℂ g)) =
+      ∫ ω, conj (f (ω 0)) * g (ω 1) ∂freePathLaw N L t := by
+  rw [freeTransition_pairing]
+  apply integral_congr_ae
+  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 (ContinuousMap.coeFn_toLp (𝕜 := ℂ) (p := 2) volume g)] with ω hf hg
+  rw [hf,hg]
+
+lemma integrable_free_character (N : ℕ) (L : Length) (t : ℝ)
+    (f : C(Configuration N L,ℂ)) (k : Direction N → ℤ) :
+    Integrable (fun p : CoordinatePaths N × Configuration N L ↦
+      conj (f p.2) * configurationCharacter N L k (freeTrajectory N L t p.1 p.2 1))
+      ((coordinateWiener N).prod volume) := by
+  have hc : Continuous (fun p : CoordinatePaths N × Configuration N L ↦
+      conj (f p.2) * configurationCharacter N L k (freeTrajectory N L t p.1 p.2 1)) := by
+    exact (f.continuous.comp continuous_snd).star.mul
+      ((configurationCharacter N L k).continuous.comp
+        ((freeTrajectory_continuous N L t).eval continuous_const))
+  refine (integrable_const ‖f‖).mono' hc.aestronglyMeasurable ?_
+  exact Filter.Eventually.of_forall fun p ↦ by
+    rw [norm_mul, RCLike.norm_conj, configurationCharacter_norm, mul_one]
+    exact f.norm_coe_le_norm p.2
+
+lemma freeTransition_character_pairing (N : ℕ) (L : Length) (t : ℝ) (ht : 0 ≤ t)
+    (f : C(Configuration N L,ℂ)) (k : Direction N → ℤ) :
+    inner ℂ (ContinuousMap.toLp 2 volume ℂ f) (freeTransition N L t (characterL2 N L k)) =
+      (Real.exp (-t * fourierEnergy N L k) : ℂ) *
+        inner ℂ (ContinuousMap.toLp 2 volume ℂ f) (characterL2 N L k) := by
+  change inner ℂ _ (freeTransition N L t (ContinuousMap.toLp 2 volume ℂ _)) = _
+  rw [freeTransition_continuous_pairing, freePathLaw]
+  have hc : Continuous (fun ω : ConfigurationPath N L ↦
+      conj (f (ω 0)) * configurationCharacter N L k (ω 1)) := by fun_prop
+  rw [integral_map (freeTrajectory_continuous N L t).measurable.aemeasurable
+    hc.aestronglyMeasurable]
+  have hzero : (fun p : CoordinatePaths N × Configuration N L ↦
+      conj (f (freeTrajectory N L t p.1 p.2 0)) *
+        configurationCharacter N L k (freeTrajectory N L t p.1 p.2 1)) =ᵐ[
+        (coordinateWiener N).prod volume]
+      (fun p ↦ conj (f p.2) * configurationCharacter N L k (freeTrajectory N L t p.1 p.2 1)) := 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_free_character N L t f k)]
+  simp_rw [integral_const_mul, freeTrajectory_character_integral N L k t ht]
+  rw [show (∫ X, conj (f X) * (configurationCharacter N L k X *
+      (Real.exp (-t*fourierEnergy N L k) : ℂ))) =
+      (Real.exp (-t*fourierEnergy N L k) : ℂ) *
+        ∫ X, conj (f X) * configurationCharacter N L k X by
+    rw [← integral_const_mul]; congr 1; ext X; ring]
+  congr 1
+  rw [characterL2, ContinuousMap.inner_toLp]
+  apply integral_congr_ae
+  exact Filter.Eventually.of_forall fun X ↦ mul_comm _ _
+
+lemma freeTransition_character (N : ℕ) (L : Length) (t : ℝ) (ht : 0 ≤ t)
+    (k : Direction N → ℤ) :
+    freeTransition N L t (characterL2 N L k) =
+      (Real.exp (-t * fourierEnergy N L k) : ℂ) • characterL2 N L k := 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 (freeTransition N L t (characterL2 N L k)) =
+        inner ℂ f ((Real.exp (-t * fourierEnergy N L k) : ℂ) • characterL2 N L k)} :=
+    isClosed_eq (continuous_id.inner continuous_const) (continuous_id.inner continuous_const)
+  have hz : ∀ f : C(Configuration N L,ℂ),
+      inner ℂ (ContinuousMap.toLp 2 volume ℂ f) (freeTransition N L t (characterL2 N L k)) =
+        inner ℂ (ContinuousMap.toLp 2 volume ℂ f)
+          ((Real.exp (-t * fourierEnergy N L k) : ℂ) • characterL2 N L k) := by
+    intro f
+    rw [freeTransition_character_pairing N L t ht, inner_smul_right]
+  exact (hc.closure_subset_iff.mpr (Set.range_subset_iff.mpr hz)) (hd f)
+
+end HardSphere
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/KilledTransitionAdd.lean

@@ -0,0 +1,64 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Conditioning.ReverseConfigurationPath
+import OAI.Analysis.HardSphere.Geometry.KilledObservable
+
+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
+namespace HardSphere
+open Wiener
+open scoped ComplexConjugate
+
+theorem killedTransition_add (N : ℕ) (L : Length) (a s t : ℝ) (hs : 0<s) (ht : 0<t) :
+    killedTransition N L a (s+t) = killedTransition N L a s ∘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 killedTransition N L a (s+t) g = killedTransition N L a s (killedTransition N L a t g)
+  have hc : IsClosed {g : ScalarL2 N L | killedTransition N L a (s+t) g =
+      killedTransition N L a s (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 killedTransition N L a (s+t) (ContinuousMap.toLp 2 volume ℂ g) =
+    killedTransition N L a s (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‖
+      (Filter.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 (s+t) 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,
+    killedTransition_bounded N L a s (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 Filter.Eventually.of_forall (killedAverage_add N L a s t hs ht g.continuous.measurable
+    (norm_nonneg _) g.norm_coe_le_norm)
+
+end HardSphere
+
+namespace HardSphere
+lemma killedTransition_nonneg (N : ℕ) (L : Length) (a t : ℝ) (ht : 0<t) :
+    0 ≤ killedTransition N L a t := by
+  have hh : 0<t/2 := by positivity
+  rw [show t=t/2+t/2 by ring,killedTransition_add N L a (t/2) (t/2) hh hh]
+  have ha := killedTransition_selfAdjoint N L a (t/2)
+  have hp := ContinuousLinearMap.isPositive_adjoint_comp_self (killedTransition N L a (t/2))
+  simpa only [show (killedTransition N L a (t/2)).adjoint=killedTransition N L a (t/2) from ha] using ContinuousLinearMap.nonneg_iff_isPositive.mpr hp
+
+end HardSphere
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/KilledTransitionContinuousAe.lean

@@ -0,0 +1,33 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.KilledObservable
+
+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
+namespace HardSphere
+lemma killedTransition_continuous_ae (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 _
+
+end HardSphere
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/KilledTransitionFormHeat.lean

@@ -0,0 +1,34 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Operators.SemigroupLaplaceCommute
+
+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 MeasureTheory Set Filter ContinuousLinearMap
+open scoped Topology
+
+lemma killedTransition_eq_formHeat (N : ℕ) (L : Length) (a : ℝ) {t : ℝ} (ht : 0<t) :
+    killedTransition N L a t=formHeat N L a t := by
+  rcases subsingleton_or_nontrivial (ScalarL2 N L) with h | h
+  · exact Subsingleton.elim _ _
+  exact semigroup_eq_heat (killedTransition N L a) (killedTransition_add_nonneg N L a)
+    (killedTransition_clamped_continuous N L a)
+    (fun t _ ↦ killedTransition_apply_contraction N L a t)
+    (killedTransition_selfAdjoint N L a)
+    (formResolvent N L a) (formResolvent_isPositive N L a)
+    (formResolvent_norm_le_one N L a) (killedLaplace_eq_formResolvent (N := N) (L := L) (a := a)) ht
+
+end HardSphere
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/Regularize.lean

@@ -0,0 +1,92 @@
+import Mathlib
+
+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 HilbertRegularization
+variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+
+def regularize (ε : ℝ) (z : E) : ℂ := (Real.sqrt (‖z‖^2+ε^2)-ε : ℝ)
+
+def differential (ε : ℝ) (z : E) : E →L[ℝ] ℂ :=
+  (Real.sqrt (‖z‖^2+ε^2))⁻¹ • (Complex.ofRealCLM.comp (innerSL ℝ z))
+
+lemma smooth {ε : ℝ} (hε : 0<ε) :
+    ContDiff ℝ ((⊤:ℕ∞):WithTop ℕ∞) (regularize (E := E) ε) := by
+  apply Complex.ofRealCLM.contDiff.comp
+  apply ContDiff.sub _ contDiff_const
+  apply ContDiff.sqrt ((contDiff_norm_sq ℝ).add contDiff_const)
+  intro z
+  positivity
+
+omit [InnerProductSpace ℝ E] in
+lemma zero {ε : ℝ} (hε : 0≤ε) : regularize (E := E) ε 0=0 := by
+  simp [regularize,Real.sqrt_sq hε]
+
+lemma hasFDerivAt {ε : ℝ} (hε : 0<ε) (z : E) :
+    HasFDerivAt (regularize ε) (differential ε z) z := by
+  have hn : ‖z‖^2+ε^2≠0 := by positivity
+  have h := Complex.ofRealCLM.hasFDerivAt.comp z
+    ((((hasStrictFDerivAt_norm_sq z).hasFDerivAt.add_const (ε^2)).sqrt hn).sub_const ε)
+  have hd : differential ε z = Complex.ofRealCLM.comp
+      ((1/(2*Real.sqrt (‖z‖^2+ε^2))) • (2 • innerSL ℝ z)) := by
+    ext w
+    simp [differential,two_smul,div_eq_mul_inv,mul_inv_rev]
+    ring
+  rw [hd]
+  exact h
+
+omit [InnerProductSpace ℝ E] in
+lemma sqroot_ge_norm (ε : ℝ) (z : E) : ‖z‖≤Real.sqrt (‖z‖^2+ε^2) :=
+  (Real.le_sqrt (norm_nonneg _) (by positivity)).mpr (by nlinarith [sq_nonneg ε])
+
+lemma differential_apply_le (ε : ℝ) (z w : E) : ‖differential ε z w‖≤‖w‖ := by
+  by_cases hz : z=0
+  · simp [hz,differential]
+  have hp : 0<Real.sqrt (‖z‖^2+ε^2) :=
+    lt_of_lt_of_le (norm_pos_iff.mpr hz) (sqroot_ge_norm ε z)
+  simp only [differential,smul_apply,ContinuousLinearMap.comp_apply,norm_smul,
+    Complex.ofRealCLM_apply,Complex.norm_real,Real.norm_eq_abs,abs_inv,abs_of_pos hp,innerSL_apply_apply]
+  change _*‖inner ℝ z w‖≤_
+  apply le_trans (mul_le_mul_of_nonneg_left (norm_inner_le_norm (𝕜 := ℝ) z w) (by positivity :
+    0≤(Real.sqrt (‖z‖^2+ε^2))⁻¹))
+  rw [← div_eq_inv_mul,div_le_iff₀ hp]
+  simpa only [mul_comm] using mul_le_mul_of_nonneg_right (sqroot_ge_norm ε z) (norm_nonneg w)
+
+lemma differential_le (ε : ℝ) (z : E) : ‖differential ε z‖≤1 := by
+  apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one
+  intro w
+  simpa only [one_mul] using differential_apply_le ε z w
+
+lemma fderiv_eq {ε : ℝ} (hε : 0<ε) (z : E) :
+    fderiv ℝ (regularize ε) z=differential ε z := (hasFDerivAt hε z).fderiv
+
+lemma lipschitz {ε : ℝ} (hε : 0<ε) : LipschitzWith 1 (regularize (E := E) ε) :=
+  lipschitzWith_of_nnnorm_fderiv_le ((smooth hε).differentiable (by simp))
+    (fun z ↦ by rw [fderiv_eq hε]; exact NNReal.coe_le_coe.mp (differential_le ε z))
+
+lemma norm_le {ε : ℝ} (hε : 0<ε) (z : E) : ‖regularize ε z‖≤‖z‖ := by
+  simpa only [zero hε.le,sub_zero,NNReal.coe_one,one_mul] using
+    (lipschitz hε).norm_sub_le z 0
+
+omit [InnerProductSpace ℝ E] in
+lemma tendsto_regularize (z : E) {e : ℕ → ℝ} (he : Tendsto e atTop (𝓝 0)) :
+    Tendsto (fun n ↦ regularize (e n) z) atTop (𝓝 (‖z‖ : ℂ)) := by
+  have h : Tendsto (fun n ↦ Real.sqrt (‖z‖^2+e n^2)-e n) atTop (𝓝 ‖z‖) := by
+    have h := (((tendsto_const_nhds (x := ‖z‖^2)).add (he.pow 2)).sqrt.sub he)
+    simpa only [zero_pow (by norm_num : 2≠0),add_zero,sub_zero,Real.sqrt_sq (norm_nonneg _)] using h
+  exact Complex.continuous_ofReal.continuousAt.tendsto.comp h
+
+end HilbertRegularization
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/SemigroupLaplaceCommute.lean

@@ -0,0 +1,168 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.KilledEigenvector
+
+namespace OAI
+
+section
+section
+noncomputable section
+open MeasureTheory Filter Set
+open scoped ENNReal Topology BigOperators
+noncomputable section
+open scoped BigOperators ComplexConjugate
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Set
+open scoped ENNReal NNReal Topology BigOperators
+noncomputable section
+open MeasureTheory ProbabilityTheory Real Complex
+open scoped ENNReal ComplexConjugate
+open ProbabilityTheory
+namespace HardSphere
+open MeasureTheory Set Filter ContinuousLinearMap
+open scoped Topology
+noncomputable section
+variable {F : Type*} [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F] [Nontrivial F]
+local instance : Algebra ℝ (F →L[ℂ] F) := Algebra.restrictScalars ℝ ℂ _
+local instance : InnerProductSpace ℝ F := InnerProductSpace.rclikeToReal ℂ F
+
+omit [Nontrivial F] in
+lemma semigroupLaplace_commute (K : ℝ → F→L[ℂ] F)
+    (hadd : ∀ s t, 0 ≤ s → 0 ≤ t → K (s+t)=(K s).comp (K t))
+    (hc : ∀ f, Continuous (fun t : ℝ ↦ K (max 0 t) f))
+    (hnorm : ∀ t, 0 ≤ t → ∀ f, ‖K t f‖≤‖f‖) (f : F) {t : ℝ} (ht : 0 ≤ t) :
+    K t (semigroupLaplace K f)=semigroupLaplace K (K t f) := by
+  rw [semigroupLaplace,← (K t).integral_comp_comm (laplaceIntegrand_integrable K hc hnorm f 0)]
+  apply setIntegral_congr_fun measurableSet_Ioi
+  intro s hs
+  dsimp only [laplaceIntegrand]
+  have hs0 : 0 ≤ s := le_of_lt hs
+  rw [max_eq_right hs0,(K t).map_smul_of_tower]
+  congr 1
+  have he : (K t).comp (K s)=(K s).comp (K t) := by
+    rw [← hadd t s ht hs0,← hadd s t hs0 ht,add_comm]
+  exact congrArg (fun T : F→L[ℂ] F ↦ T f) he
+
+lemma semigroup_eq_regularHeat_range_square (K : ℝ → F→L[ℂ] F)
+    (hadd : ∀ s t, 0 ≤ s → 0 ≤ t → K (s+t)=(K s).comp (K t))
+    (hc : ∀ f, Continuous (fun t : ℝ ↦ K (max 0 t) f))
+    (hnorm : ∀ t, 0 ≤ t → ∀ f, ‖K t f‖≤‖f‖)
+    (R : F→L[ℂ] F) (hRp : R.IsPositive) (hRn : ‖R‖≤1)
+    (hR : ∀ f, semigroupLaplace K f=R f) (f : F) {t : ℝ} (ht : 0 ≤ t) :
+    K t (R (R f))=regularHeat R t (R (R f)) := by
+  have hcomm (s : ℝ) (hs : 0 ≤ s) (g : F) : K s (R g)=R (K s g) := by
+    simpa only [hR] using semigroupLaplace_commute K hadd hc hnorm g hs
+  let w : ℝ → F := fun s ↦ K s (R (R f))-regularHeat R s (R (R f))
+  let v : ℝ → F := fun s ↦ K s (R f)-regularHeat R s (R f)
+  have hwR (s : ℝ) (hs : 0 ≤ s) : w s=R (v s) := by
+    dsimp only [w,v]
+    rw [map_sub,← hcomm s hs]
+    have he := (regularHeat_commute R s).eq
+    have he' := congrArg (fun T : F→L[ℂ] F ↦ T (R f)) he
+    change regularHeat R s (R (R f))=R (regularHeat R s (R f)) at he'
+    rw [he']
+  have hw0 : w 0=0 := by
+    have hz := semigroupLaplace_project K hadd hc hnorm (R f)
+    rw [hR] at hz
+    simp only [w,hz,regularHeat_zero,one_apply_eq_self,sub_self]
+  have hcw : ContinuousOn w (Ici 0) := by
+    have hk : ContinuousOn (fun s : ℝ ↦ K s (R (R f))) (Ici 0) :=
+      (hc (R (R f))).continuousOn.congr (fun s hs ↦ by
+        change K s (R (R f))=K (max 0 s) (R (R f))
+        rw [max_eq_right (show 0 ≤ s from hs)])
+    exact hk.sub (regularHeat_range_continuousOn hRp hRn (R f))
+  have hdw (s : ℝ) (hs : 0 ≤ s) : HasDerivWithinAt w (w s-v s) (Ici s) s := by
+    have hk := (semigroupLaplace_hasDerivWithinAt K hadd hc hnorm (R f) hs).mono
+      (Ici_subset_Ici.mpr hs)
+    simp only [hR] at hk
+    have hh := hk.sub (regularHeat_range_hasDerivWithinAt hRp hRn f hs)
+    convert hh using 1
+    dsimp only [w,v]
+    rw [map_sub]
+    abel
+  let z : ℝ → F := fun s ↦ Real.exp (-s) • w s
+  have hcz : ContinuousOn z (Ici 0) :=
+    (Real.continuous_exp.comp continuous_neg).continuousOn.smul hcw
+  have hdz (s : ℝ) (hs : 0 ≤ s) : HasDerivWithinAt z (-Real.exp (-s) • v s) (Ici s) s := by
+    have hh := (((hasDerivAt_id s).neg.exp).hasDerivWithinAt).smul (hdw s hs)
+    simp only [Pi.neg_apply,id_eq] at hh
+    convert hh using 1
+    module
+  have hnonpos (s : ℝ) (hs : 0 ≤ s) : inner ℝ (z s) (-Real.exp (-s) • v s)≤0 := by
+    have he : z s=R (Real.exp (-s) • v s) := by
+      dsimp only [z]
+      rw [hwR s hs,map_smul_of_tower]
+    rw [he,neg_smul,inner_neg_right]
+    apply neg_nonpos.mpr
+    exact hRp.re_inner_nonneg_left (Real.exp (-s) • v s)
+  have hbound := image_le_of_deriv_right_le_deriv_boundary
+    (f := fun s : ℝ ↦ ‖z s‖^2) (f' := fun s ↦ 2*inner ℝ (z s) (-Real.exp (-s) • v s))
+    (B := fun _ ↦ (0:ℝ)) (B' := fun _ ↦ (0:ℝ))
+    ((continuous_norm.comp_continuousOn hcz).pow 2 |>.mono (Icc_subset_Ici_self : Icc (0:ℝ) t ⊆ Ici 0))
+    (fun s hs ↦ (hdz s hs.1).norm_sq)
+    (by simp [z,hw0]) continuousOn_const (fun s _ ↦ hasDerivWithinAt_const s _ _)
+    (fun s hs ↦ mul_nonpos_of_nonneg_of_nonpos (by norm_num) (hnonpos s hs.1))
+    (x := t) ⟨ht,le_refl _⟩
+  have hz : z t=0 := norm_eq_zero.mp (by nlinarith [norm_nonneg (z t)])
+  have hw : w t=0 := by
+    change Real.exp (-t) • w t=0 at hz
+    exact (smul_eq_zero.mp hz).resolve_left (ne_of_gt (Real.exp_pos _))
+  exact sub_eq_zero.mp hw
+
+omit [Nontrivial F] in
+lemma semigroupLaplace_kernel (K : ℝ → F→L[ℂ] F)
+    (hadd : ∀ s t, 0 ≤ s → 0 ≤ t → K (s+t)=(K s).comp (K t))
+    (hc : ∀ f, Continuous (fun t : ℝ ↦ K (max 0 t) f))
+    (hnorm : ∀ t, 0 ≤ t → ∀ f, ‖K t f‖≤‖f‖) (f : F)
+    (he : semigroupLaplace K f=0) {t : ℝ} (ht : 0 ≤ t) : K t f=0 := by
+  have hh := semigroupLaplace_difference_tendsto K hadd hc hnorm f
+  simp only [he,map_zero,sub_self,smul_zero,sub_zero] at hh
+  have hz : K 0 f=0 := (tendsto_nhds_unique tendsto_const_nhds hh).symm
+  have hp := congrArg (fun T : F→L[ℂ] F ↦ T f) (hadd t 0 ht (le_refl 0))
+  simpa only [add_zero,comp_apply,hz,map_zero] using hp
+
+lemma semigroup_eq_heat (K : ℝ → F→L[ℂ] F)
+    (hadd : ∀ s t, 0 ≤ s → 0 ≤ t → K (s+t)=(K s).comp (K t))
+    (hc : ∀ f, Continuous (fun t : ℝ ↦ K (max 0 t) f))
+    (hnorm : ∀ t, 0 ≤ t → ∀ f, ‖K t f‖≤‖f‖)
+    (hKs : ∀ t, IsSelfAdjoint (K t))
+    (R : F→L[ℂ] F) (hRp : R.IsPositive) (hRn : ‖R‖≤1)
+    (hR : ∀ f, semigroupLaplace K f=R f) {t : ℝ} (ht : 0<t) :
+    K t=cfc (p := IsSelfAdjoint) (heatScalar t) R := by
+  let H := cfc (p := IsSelfAdjoint) (heatScalar t) R
+  let D := K t-H
+  have hDs : ∀ f g, inner ℂ (D f) g=inner ℂ f (D g) :=
+    isSelfAdjoint_iff_isSymmetric.mp ((hKs t).sub (show IsSelfAdjoint H from IsSelfAdjoint.cfc))
+  have hDRR (f : F) : D (R (R f))=0 := by
+    change K t (R (R f))-H (R (R f))=0
+    apply sub_eq_zero.mpr
+    simpa only [regularHeat_pos R ht] using semigroup_eq_regularHeat_range_square K hadd hc hnorm R hRp hRn hR f ht.le
+  have hker (f : F) (hf : R f=0) : D f=0 := by
+    have hK : K t f=0 := semigroupLaplace_kernel K hadd hc hnorm f ((hR f).trans hf) ht.le
+    have hH : H f=0 := by
+      dsimp only [H]
+      rw [cfc_eigen_apply R hRp.isSelfAdjoint (heatScalar t) (heatScalar_smooth t).continuous
+        0 ((heatScalar_smooth t).differentiable (by norm_num)).differentiableAt f (by simpa using hf),
+        heatScalar_zero,zero_smul]
+    simp only [D,sub_apply,hK,hH,sub_self]
+  ext f
+  suffices hDf : D f=0 by exact sub_eq_zero.mp hDf
+  have hRD : R (D f)=0 := by
+    apply (inner_self_eq_zero (𝕜 := ℂ)).mp
+    calc
+      inner ℂ (R (D f)) (R (D f))=inner ℂ (D f) (R (R (D f))) := hRp.inner_left_eq_inner_right _ _
+      _ = inner ℂ f (D (R (R (D f)))) := hDs _ _
+      _ = 0 := by rw [hDRR,inner_zero_right]
+  apply (inner_self_eq_zero (𝕜 := ℂ)).mp
+  rw [hDs,hker (D f) hRD,inner_zero_right]
+
+end
+end HardSphere
+
+end
+end
+end
+end
+end
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/SemigroupLaplaceDerivWithin.lean

@@ -0,0 +1,95 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Comparison.LaplaceIntegrand
+
+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 MeasureTheory Set Filter
+open scoped Topology
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
+
+lemma semigroupLaplace_hasDerivWithinAt (K : ℝ → E→L[ℂ] E)
+    (hadd : ∀ s t, 0 ≤ s → 0 ≤ t → K (s+t)=(K s).comp (K t))
+    (hc : ∀ f, Continuous (fun t : ℝ ↦ K (max 0 t) f))
+    (hnorm : ∀ t, 0 ≤ t → ∀ f, ‖K t f‖≤‖f‖) (f : E) {t : ℝ} (ht : 0 ≤ t) :
+    HasDerivWithinAt (fun s : ℝ ↦ K s (semigroupLaplace K f))
+      (K t (semigroupLaplace K f)-K t f) (Ici 0) t := by
+  have hiC : Continuous (laplaceIntegrand K f) :=
+    (Real.continuous_exp.comp continuous_neg).smul (hc f)
+  have hd := intervalIntegral.integral_hasDerivAt_right
+    (f := laplaceIntegrand K f) (a := 0) (b := t)
+    (hiC.intervalIntegrable 0 t) (hiC.stronglyMeasurableAtFilter volume (𝓝 t)) hiC.continuousAt
+  have hder := (Real.hasDerivAt_exp t).smul
+    ((hasDerivAt_const t (semigroupLaplace K f)).sub hd)
+  have heq : EqOn (fun s : ℝ ↦ Real.exp s •
+      (semigroupLaplace K f-∫ z in (0:ℝ)..s,laplaceIntegrand K f z))
+      (fun s ↦ K s (semigroupLaplace K f)) (Ici 0) :=
+    fun s hs ↦ (semigroupLaplace_shift K hadd hc hnorm f hs).symm
+  have hv : Real.exp t • (0-laplaceIntegrand K f t)+
+      Real.exp t • (semigroupLaplace K f-∫ z in (0:ℝ)..t,laplaceIntegrand K f z)=
+      K t (semigroupLaplace K f)-K t f := by
+    rw [← semigroupLaplace_shift K hadd hc hnorm f ht,zero_sub,smul_neg,
+      laplaceIntegrand,max_eq_right ht,smul_smul,← Real.exp_add,add_neg_cancel,
+      Real.exp_zero,one_smul]
+    abel
+  change HasDerivAt (fun s : ℝ ↦ Real.exp s •
+      (semigroupLaplace K f-∫ z in (0:ℝ)..s,laplaceIntegrand K f z))
+    (Real.exp t • (0-laplaceIntegrand K f t)+
+      Real.exp t • (semigroupLaplace K f-∫ z in (0:ℝ)..t,laplaceIntegrand K f z)) t at hder
+  rw [hv] at hder
+  exact hder.hasDerivWithinAt.congr (fun s hs ↦ (heq hs).symm) (heq ht).symm
+
+lemma semigroupLaplace_eigenvector (K : ℝ → E→L[ℂ] E)
+    (hadd : ∀ s t, 0 ≤ s → 0 ≤ t → K (s+t)=(K s).comp (K t))
+    (hc : ∀ f, Continuous (fun t : ℝ ↦ K (max 0 t) f))
+    (hnorm : ∀ t, 0 ≤ t → ∀ f, ‖K t f‖≤‖f‖) (f : E)
+    {r : ℝ} (hr : 0<r) (he : semigroupLaplace K f=r • f)
+    {t : ℝ} (ht : 0 ≤ t) : K t f=Real.exp ((1-r⁻¹)*t) • f := by
+  have hz : K 0 f=f := by
+    have hh := semigroupLaplace_project K hadd hc hnorm f
+    rw [he,(K 0).map_smul_of_tower] at hh
+    exact (smul_right_injective E (ne_of_gt hr)) hh
+  have hd (s : ℝ) (hs : 0 ≤ s) : HasDerivWithinAt (fun x : ℝ ↦ K x f)
+      ((1-r⁻¹) • K s f) (Ici 0) s := by
+    have h := (semigroupLaplace_hasDerivWithinAt K hadd hc hnorm f hs).const_smul r⁻¹
+    simp only [he,ContinuousLinearMap.map_smul_of_tower] at h
+    change HasDerivWithinAt (fun x : ℝ ↦ r⁻¹ • (r • K x f))
+       (r⁻¹ • (r • K s f-K s f)) (Ici 0) s at h
+    simp only [smul_sub,smul_smul,inv_mul_cancel₀ (ne_of_gt hr),one_smul] at h
+    convert h using 1
+    module
+  let F : ℝ → E := fun x ↦ Real.exp ((r⁻¹-1)*x) • K x f
+  have hFcont : ContinuousOn F (Ici 0) := by
+    have h : ContinuousOn (fun x : ℝ ↦ Real.exp ((r⁻¹-1)*x) • K (max 0 x) f) (Ici 0) :=
+      ((Real.continuous_exp.comp (continuous_const.mul continuous_id)).smul (hc f)).continuousOn
+    exact h.congr (fun s hs ↦ by simp only [F,max_eq_right (show 0 ≤ s from hs)])
+  have hdF (s : ℝ) (hs : 0 ≤ s) : HasDerivWithinAt F 0 (Ici 0) s := by
+    have h := (((hasDerivAt_id s).const_mul (r⁻¹-1)).exp.hasDerivWithinAt).smul (hd s hs)
+    convert h using 1
+    · rfl
+    · module
+  have hconst := constant_of_has_deriv_right_zero
+    (hFcont.mono (Icc_subset_Ici_self : Icc (0:ℝ) t ⊆ Ici 0))
+    (fun s hs ↦ (hdF s hs.1).mono (Ici_subset_Ici.mpr hs.1))
+  have heF : Real.exp ((r⁻¹-1)*t) • K t f=f := by
+    simpa only [F,mul_zero,Real.exp_zero,one_smul,hz] using hconst t ⟨ht,le_refl _⟩
+  calc
+    K t f=Real.exp ((1-r⁻¹)*t) • (Real.exp ((r⁻¹-1)*t) • K t f) := by
+      rw [smul_smul,← Real.exp_add,show (1-r⁻¹)*t+(r⁻¹-1)*t=0 by ring,
+        Real.exp_zero,one_smul]
+    _ = _ := by rw [heF]
+
+end HardSphere
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Operators/Stationary.lean

@@ -0,0 +1,456 @@
+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

lean/OAI/Analysis/HardSphere/Operators/TransitionDerivative.lean

@@ -0,0 +1,46 @@
+import Mathlib
+
+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 PeriodicCutoff
+
+lemma transition_derivative (x : ℝ) :
+    HasDerivAt Real.smoothTransition (deriv Real.smoothTransition x) x :=
+  ((Real.smoothTransition.contDiff (n := 1)).differentiable (by norm_num) x).hasDerivAt
+
+lemma transition_deriv_eq_zero {x : ℝ} (hx : x∉Icc (0:ℝ) 1) :
+    deriv Real.smoothTransition x=0 := by
+  have he : (Real.smoothTransition =ᶠ[𝓝 x] fun _ ↦ (Real.smoothTransition x)) := by
+    rcases not_and_or.mp hx with h | h
+    · have hx : x<0 := lt_of_not_ge h
+      filter_upwards [isOpen_Iio.mem_nhds hx] with y hy
+      rw [Real.smoothTransition.zero_of_nonpos hy.le,Real.smoothTransition.zero_of_nonpos hx.le]
+    · have hx : 1<x := lt_of_not_ge h
+      filter_upwards [isOpen_Ioi.mem_nhds hx] with y hy
+      rw [Real.smoothTransition.one_of_one_le hy.le,Real.smoothTransition.one_of_one_le hx.le]
+  exact ((hasDerivAt_const x (Real.smoothTransition x)).congr_of_eventuallyEq he).deriv
+
+lemma exists_transition_bound : ∃ M : ℝ, 0<M ∧ ∀ x : ℝ, |deriv Real.smoothTransition x|≤M := by
+  obtain ⟨C,hC⟩ := isCompact_Icc.exists_bound_of_continuousOn
+    ((Real.smoothTransition.contDiff (n := 2)).continuous_deriv (by norm_num)).continuousOn
+      (s := Icc (0:ℝ) 1)
+  refine ⟨max C 1,lt_of_lt_of_le zero_lt_one (le_max_right _ _),fun x ↦ ?_⟩
+  by_cases hx : x∈Icc (0:ℝ) 1
+  · exact (hC x hx).trans (le_max_left _ _)
+  · rw [transition_deriv_eq_zero hx,abs_zero]
+    exact (zero_le_one : (0:ℝ)≤1).trans (le_max_right _ _)
+
+end PeriodicCutoff
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/Bump.lean

@@ -0,0 +1,282 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.TorusLiftBox
+import OAI.Analysis.HardSphere.Geometry.HeadLift
+import OAI.Analysis.HardSphere.Cutoffs.Near
+import OAI.Analysis.HardSphere.Operators.Regularize
+
+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.CellOrbital
+open MeasureTheory Set Filter PeriodicCutoff TightCutoff
+open scoped ComplexConjugate
+
+def bump (L : Length) (δ : ℝ) (x y : Torus L) : ℝ :=
+  Real.cos (TightCutoff.angle L.val δ y x)
+
+def centerLift (L : Length) (x : Torus L) : Fin 3 → ℝ :=
+  fun j ↦ (AddCircle.equivIco L.val 0 (x j)).val
+
+lemma centerLift_coe (L : Length) (x : Torus L) :
+    (fun j ↦ (centerLift L x j : AddCircle L.val))=x := by
+  ext j
+  exact AddCircle.coe_equivIco
+
+lemma bump_project (L : Length) (δ : ℝ) (x : Torus L) (R : LiftedConfiguration 1) :
+    bump L δ x (project 1 L R 0)=
+      Real.cos (TightCutoff.angleLift L.val δ (R 0-centerLift L x)) := by
+  unfold bump TightCutoff.angle TightCutoff.angleLift
+  change Real.cos (Real.pi / 2 * Real.smoothTransition
+    ((pairQ L.val (fun j ↦ (R 0 j : AddCircle L.val)) x-(5/4)*δ^2)/((1/4)*δ^2))) = _
+  conv_lhs => rw [← centerLift_coe L x, pairQ_coe]
+
+lemma bump_smooth (L : Length) (δ : ℝ) (x : Torus L) :
+    ContDiff ℝ ((⊤:ℕ∞):WithTop ℕ∞)
+      (fun R : LiftedConfiguration 1 ↦ (bump L δ x (project 1 L R 0) : ℂ)) := by
+  simp_rw [bump_project]
+  exact Complex.ofRealCLM.contDiff.comp ((Real.contDiff_cos.comp
+    (TightCutoff.angleLift_smooth L.val δ)).comp ((contDiff_apply ℝ (Fin 3 → ℝ) 0).sub contDiff_const))
+
+def raw (L : Length) (δ : ℝ) (x : Torus L) : SmoothMultiplier 1 L :=
+  .ofSmooth (fun X ↦ (bump L δ x (X 0) : ℂ)) (bump_smooth L δ x)
+
+lemma bump_continuous (L : Length) (δ : ℝ) (x : Torus L) : Continuous (bump L δ x) := by
+  unfold bump TightCutoff.angle
+  exact Real.continuous_cos.comp (continuous_const.mul (Real.smoothTransition.continuous.comp
+    (((pairQ_continuous L.val).comp (continuous_id.prodMk continuous_const)).sub
+      continuous_const |>.div_const _)))
+
+lemma bump_bounds (L : Length) (δ : ℝ) (x y : Torus L) : 0 ≤ bump L δ x y ∧ bump L δ x y ≤ 1 := by
+  refine ⟨?_,Real.cos_le_one _⟩
+  apply Real.cos_nonneg_of_mem_Icc
+  exact ⟨by linarith [(TightCutoff.angle_bounds L.val δ y x).1,Real.pi_pos],
+    (TightCutoff.angle_bounds L.val δ y x).2⟩
+
+lemma bump_eq_one {L : Length} {δ : ℝ} (hδ : 0<δ) (x : Torus L) {y : Torus L}
+    (hy : y∈box L.val (δ/2) x) : bump L δ x y=1 := by
+  have hd j : dist (y j) (x j) ≤ δ/2 := (Set.mem_univ_pi.mp hy) j
+  have hq := pairQ_le L.val y x
+  have hs : (∑ j : Fin 3, dist (y j) (x j)^2) ≤ 3*(δ/2)^2 := by
+    calc
+      _ ≤ ∑ _j : Fin 3, (δ/2)^2 := Finset.sum_le_sum fun j _ ↦
+        (sq_le_sq₀ dist_nonneg (by positivity)).mpr (hd j)
+      _ = _ := by simp
+  unfold bump
+  rw [TightCutoff.angle_zero L.val hδ (by nlinarith), Real.cos_zero]
+
+lemma bump_eq_zero {L : Length} {δ : ℝ} (hδ : 0<δ) (x : Torus L) {y : Torus L}
+    (hy : y∉TightCutoff.near L.val δ x) : bump L δ x y=0 := by
+  rw [bump,TightCutoff.angle_one_outside L.val hδ hy,Real.cos_pi_div_two]
+
+lemma bump_support {L : Length} {δ : ℝ} (hδ : 0<δ) (x : Torus L) :
+    tsupport (bump L δ x) ⊆ TightCutoff.near L.val δ x := by
+  apply closure_minimal
+  · intro y hy
+    by_contra hn
+    exact hy (bump_eq_zero hδ x hn)
+  · exact isClosed_le ((pairQ_continuous L.val).comp
+      (continuous_id.prodMk continuous_const)) continuous_const
+
+lemma box_volume_eq {L : Length} {b : ℝ} (hb : 0 ≤ b) (hbL : 2*b ≤ L.val) (x : Torus L) :
+    volume.real (box L.val b x)=(2*b)^3 := by
+  have he : volume (box L.val b x)=ENNReal.ofReal (min L.val (2*b))^3 := by
+    rw [volume_pi,box,Measure.pi_pi]
+    simp_rw [AddCircle.volume_closedBall]
+    simp
+  rw [measureReal_def,he,min_eq_right hbL,ENNReal.toReal_pow,
+    ENNReal.toReal_ofReal (by positivity)]
+
+def mass (L : Length) (δ : ℝ) (x : Torus L) : ℝ := ∫ y : Torus L, (bump L δ x y)^2
+
+lemma mass_lower {L : Length} {δ : ℝ} (hδ : 0<δ) (hδL : δ ≤ L.val) (x : Torus L) :
+    δ^3 ≤ mass L δ x := by
+  have hi : Integrable (fun y : Torus L ↦ (bump L δ x y)^2) volume :=
+    ((bump_continuous L δ x).pow 2).integrable_of_hasCompactSupport
+    (HasCompactSupport.of_compactSpace _)
+  calc
+    _ = volume.real (box L.val (δ/2) x) := by rw [box_volume_eq (by positivity) (by linarith)]; ring
+    _ = ∫ y in box L.val (δ/2) x, (bump L δ x y)^2 := by
+      rw [setIntegral_congr_fun (box_measurable _ _ _) (fun y hy ↦ by rw [bump_eq_one hδ x hy])]
+      simp
+    _ ≤ mass L δ x := setIntegral_le_integral hi (Filter.Eventually.of_forall fun _ ↦ sq_nonneg _)
+
+lemma mass_pos {L : Length} {δ : ℝ} (hδ : 0<δ) (hδL : δ ≤ L.val) (x : Torus L) :
+    0 < mass L δ x := lt_of_lt_of_le (by positivity) (mass_lower hδ hδL x)
+
+lemma raw_fderiv (L : Length) (δ : ℝ) (x : Torus L) (R v : LiftedConfiguration 1) :
+    fderiv ℝ (fun R ↦ (raw L δ x).toFun (project 1 L R)) R v =
+      ((-Real.sin (TightCutoff.angleLift L.val δ (R 0-centerLift L x)) *
+        ∑ j : Fin 3, TightCutoff.anglePartial L.val δ (R 0-centerLift L x) j*v 0 j : ℝ) : ℂ) := by
+  have hd : HasDerivAt (fun t : ℝ ↦ R+t • v) v 0 := by
+    simpa using ((hasDerivAt_id (0:ℝ)).smul_const v).const_add R
+  have hf := ((((raw L δ x).smooth).differentiable (by simp)) R).hasFDerivAt.comp_hasDerivAt_of_eq 0 hd (by simp)
+  have ha := TightCutoff.angleLift_derivative L.val δ
+    (fun j t ↦ R 0 j+t*v 0 j-centerLift L x j) (fun j ↦ v 0 j) 0 (fun j ↦ by
+      convert ((((hasDerivAt_id (0:ℝ)).mul_const (v 0 j)).const_add (R 0 j)).sub_const (centerLift L x j)) using 1 <;> first | rfl | simp only [one_mul])
+  have hb := Complex.ofRealCLM.hasFDerivAt.comp_hasDerivAt 0 ha.cos
+  have he : ((fun R ↦ (raw L δ x).toFun (project 1 L R)) ∘ fun t : ℝ ↦ R+t • v) =
+      (fun t : ℝ ↦ (Real.cos (TightCutoff.angleLift L.val δ
+        (fun j ↦ R 0 j+t*v 0 j-centerLift L x j)) : ℂ)) := by
+    funext t
+    exact congrArg Complex.ofReal (bump_project L δ x (R+t • v))
+  rw [he] at hf
+  convert hf.unique hb using 1
+  simp only [zero_mul,add_zero,Complex.ofRealCLM_apply]
+  rfl
+
+lemma raw_partial (L : Length) (δ : ℝ) (x y : Torus L) (j : Fin 3) :
+    coordDerivative 1 L (raw L δ x).toFun (0,j) (fun _ ↦ y)=
+      ((-Real.sin (TightCutoff.angleLift L.val δ (centerLift L y-centerLift L x)) *
+        TightCutoff.anglePartial L.val δ (centerLift L y-centerLift L x) j : ℝ) : ℂ) := by
+  rw [coordDerivative,raw_fderiv]
+  change (Complex.ofReal (-Real.sin _ * ∑ k : Fin 3, _ * (Pi.single j (1:ℝ)) k)) = _
+  simp only [Pi.single_apply,mul_ite,mul_one,mul_zero,Finset.sum_ite_eq',Finset.mem_univ,ite_true]
+  rfl
+
+lemma raw_partial_sq_le {L : Length} {δ M : ℝ} (hδ : 0<δ) (hM : 0 ≤ M)
+    (hb : ∀ t : ℝ, |deriv Real.smoothTransition t| ≤ M) (x y : Torus L) (j : Fin 3) :
+    ‖coordDerivative 1 L (raw L δ x).toFun (0,j) (fun _ ↦ y)‖^2 ≤ 24*Real.pi^2*M^2/δ^2 := by
+  rw [raw_partial,Complex.norm_real,Real.norm_eq_abs,sq_abs,mul_pow,neg_sq]
+  calc
+    _ ≤ 1*(TightCutoff.anglePartial L.val δ (centerLift L y-centerLift L x) j)^2 := by
+      gcongr
+      exact Real.sin_sq_le_one _
+    _ ≤ _ := by simpa using TightCutoff.anglePartial_sq_le L.val hδ hM hb (centerLift L y-centerLift L x) j
+
+lemma raw_partial_zero {L : Length} {δ : ℝ} (hδ : 0<δ) (x y : Torus L) (j : Fin 3)
+    (hy : y∉TightCutoff.near L.val δ x) :
+    coordDerivative 1 L (raw L δ x).toFun (0,j) (fun _ ↦ y)=0 := by
+  have he : qLift L.val (centerLift L y-centerLift L x)=pairQ L.val y x := by
+    rw [← pairQ_coe,centerLift_coe,centerLift_coe]
+  have hn : qLift L.val (centerLift L y-centerLift L x)∉Icc ((5/4)*δ^2) ((3/2)*δ^2) := by
+    rw [he]
+    exact fun h ↦ hy h.2
+  rw [raw_partial,TightCutoff.anglePartial_eq_zero L.val hδ hn,mul_zero,Complex.ofReal_zero]
+
+lemma raw_energy_le {L : Length} {δ M : ℝ} (hδ : 0<δ) (hM : 0 ≤ M)
+    (hb : ∀ t : ℝ, |deriv Real.smoothTransition t| ≤ M) (x : Torus L) :
+    (raw L δ x).orbitalEnergy ≤ 3*(24*Real.pi^2*M^2/δ^2)*(4*δ)^3 := by
+  have hpart (j : Fin 3) :
+      (∫ y : Torus L, ‖coordDerivative 1 L (raw L δ x).toFun (0,j) (fun _ ↦ y)‖^2) ≤
+        (24*Real.pi^2*M^2/δ^2)*(4*δ)^3 := by
+    let f := fun y : Torus L ↦ ‖coordDerivative 1 L (raw L δ x).toFun (0,j) (fun _ ↦ y)‖^2
+    have hf : Continuous f := ((continuous_coordDerivative (raw L δ x).smooth (0,j)).comp
+      (continuous_pi fun _ ↦ continuous_id)).norm.pow 2
+    have hi : Integrable f volume := hf.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)
+    have he : (∫ y, f y) = ∫ y in TightCutoff.near L.val δ x, f y := by
+      symm
+      apply setIntegral_eq_integral_of_forall_compl_eq_zero
+      intro y hy
+      simp [f,raw_partial_zero hδ x y j hy]
+    rw [he]
+    calc
+      _ ≤ ∫ _y in TightCutoff.near L.val δ x, (24*Real.pi^2*M^2/δ^2) :=
+        setIntegral_mono_on hi.integrableOn (integrableOn_const) (TightCutoff.near_measurable _ _ _)
+          (fun y _ ↦ raw_partial_sq_le hδ hM hb x y j)
+      _ = volume.real (TightCutoff.near L.val δ x)*(24*Real.pi^2*M^2/δ^2) := by simp
+      _ ≤ _ := by
+        simpa only [mul_comm] using mul_le_mul_of_nonneg_right (TightCutoff.near_volume_le L.val hδ x)
+          (show 0 ≤ 24*Real.pi^2*M^2/δ^2 by positivity)
+  unfold SmoothMultiplier.orbitalEnergy
+  calc
+    _ ≤ ∑ _j : Fin 3, (24*Real.pi^2*M^2/δ^2)*(4*δ)^3 := Finset.sum_le_sum fun j _ ↦ hpart j
+    _ = _ := by simp; ring
+
+def normalized (L : Length) (δ : ℝ) (x : Torus L) : SmoothMultiplier 1 L :=
+  .ofSmooth (fun X ↦ (((Real.sqrt (mass L δ x))⁻¹ : ℝ) : ℂ)*(raw L δ x).toFun X)
+    (contDiff_const.mul (raw L δ x).smooth)
+
+lemma normalized_real (L : Length) (δ : ℝ) (x : Torus L) (X : Configuration 1 L) :
+    conj ((normalized L δ x).toFun X)=(normalized L δ x).toFun X := by
+  simp [normalized,raw,SmoothMultiplier.ofSmooth]
+
+lemma normalized_norm_sq {L : Length} {δ : ℝ} (hδ : 0<δ) (hδL : δ ≤ L.val) (x y : Torus L) :
+    ‖(normalized L δ x).orbital y‖^2=(mass L δ x)⁻¹*(bump L δ x y)^2 := by
+  change ‖(((Real.sqrt (mass L δ x))⁻¹ : ℝ) : ℂ)*(bump L δ x y : ℂ)‖^2 = _
+  rw [norm_mul,mul_pow,Complex.norm_real,Real.norm_eq_abs,sq_abs,Complex.norm_real,Real.norm_eq_abs,sq_abs,
+    inv_pow,Real.sq_sqrt (mass_pos hδ hδL x).le]
+
+lemma normalized_mass {L : Length} {δ : ℝ} (hδ : 0<δ) (hδL : δ ≤ L.val) (x : Torus L) :
+    (∫ y : Torus L, ‖(normalized L δ x).orbital y‖^2)=1 := by
+  simp_rw [normalized_norm_sq hδ hδL]
+  rw [integral_const_mul]
+  exact inv_mul_cancel₀ (mass_pos hδ hδL x).ne'
+
+lemma normalized_support {L : Length} {δ : ℝ} (hδ : 0<δ) (x : Torus L) :
+    tsupport (normalized L δ x).orbital ⊆ TightCutoff.near L.val δ x := by
+  apply closure_minimal
+  · intro y hy
+    by_contra hn
+    apply hy
+    change (((Real.sqrt (mass L δ x))⁻¹ : ℝ) : ℂ)*(bump L δ x y : ℂ)=0
+    rw [bump_eq_zero hδ x hn,Complex.ofReal_zero,mul_zero]
+  · exact isClosed_le ((pairQ_continuous L.val).comp
+      (continuous_id.prodMk continuous_const)) continuous_const
+
+lemma normalized_bound {L : Length} {δ : ℝ} (hδ : 0<δ) (hδL : δ ≤ L.val) (x : Torus L) :
+    (normalized L δ x).orbitalBound ≤ (δ^3)⁻¹ := by
+  have hs : 0<Real.sqrt (mass L δ x) := Real.sqrt_pos.mpr (mass_pos hδ hδL x)
+  have hb : ‖(⟨(normalized L δ x).orbital,(normalized L δ x).orbital_continuous⟩ : C(Torus L,ℂ))‖ ≤
+      (Real.sqrt (mass L δ x))⁻¹ := by
+    apply (ContinuousMap.norm_le _ (by positivity)).mpr
+    intro y
+    change ‖(((Real.sqrt (mass L δ x))⁻¹ : ℝ) : ℂ)*(bump L δ x y : ℂ)‖ ≤ _
+    rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (inv_pos.mpr hs),
+      Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (bump_bounds L δ x y).1]
+    exact mul_le_of_le_one_right (by positivity) (bump_bounds L δ x y).2
+  calc
+    _ ≤ ((Real.sqrt (mass L δ x))⁻¹)^2 := (sq_le_sq₀ (norm_nonneg _) (by positivity)).mpr hb
+    _ = (mass L δ x)⁻¹ := by rw [inv_pow,Real.sq_sqrt (mass_pos hδ hδL x).le]
+    _ ≤ _ := inv_anti₀ (by positivity) (mass_lower hδ hδL x)
+
+lemma normalized_partial (L : Length) (δ : ℝ) (x y : Torus L) (j : Fin 3) :
+    coordDerivative 1 L (normalized L δ x).toFun (0,j) (fun _ ↦ y)=
+      (((Real.sqrt (mass L δ x))⁻¹ : ℝ) : ℂ)*coordDerivative 1 L (raw L δ x).toFun (0,j) (fun _ ↦ y) := by
+  unfold coordDerivative
+  change (fderiv ℝ (fun R ↦ (((Real.sqrt (mass L δ x))⁻¹ : ℝ) : ℂ)*(raw L δ x).toFun (project 1 L R)) _) _ = _
+  rw [fderiv_const_mul (((raw L δ x).smooth.differentiable (by simp)) _)]
+  rfl
+
+lemma normalized_energy_le {L : Length} {δ M : ℝ} (hδ : 0<δ) (hδL : δ ≤ L.val)
+    (hM : 0 ≤ M) (hb : ∀ t : ℝ, |deriv Real.smoothTransition t| ≤ M) (x : Torus L) :
+    (normalized L δ x).orbitalEnergy ≤ (δ^3)⁻¹*(3*(24*Real.pi^2*M^2/δ^2)*(4*δ)^3) := by
+  have he : (normalized L δ x).orbitalEnergy=(mass L δ x)⁻¹*(raw L δ x).orbitalEnergy := by
+    unfold SmoothMultiplier.orbitalEnergy
+    simp_rw [normalized_partial,norm_mul,mul_pow,Complex.norm_real,Real.norm_eq_abs,sq_abs,
+      inv_pow,Real.sq_sqrt (mass_pos hδ hδL x).le,integral_const_mul]
+    rw [Finset.mul_sum]
+  rw [he]
+  apply mul_le_mul
+  · exact inv_anti₀ (by positivity) (mass_lower hδ hδL x)
+  · exact raw_energy_le hδ hM hb x
+  · exact Finset.sum_nonneg fun j _ ↦ integral_nonneg fun _ ↦ sq_nonneg _
+  · positivity
+
+theorem uniform_orbitals : ∃ B E : ℝ, 0<B ∧ 0<E ∧
+    ∀ L : Length, (1:ℝ)/100 ≤ L.val → ∀ x : Torus L,
+    (∀ X, conj ((normalized L (1/100) x).toFun X)=(normalized L (1/100) x).toFun X) ∧
+    (∫ y : Torus L, ‖(normalized L (1/100) x).orbital y‖^2)=1 ∧
+    (normalized L (1/100) x).orbitalBound ≤ B ∧
+    (normalized L (1/100) x).orbitalEnergy ≤ E ∧
+    tsupport (normalized L (1/100) x).orbital ⊆ TightCutoff.near L.val (1/100) x := by
+  obtain ⟨M,hM,hb⟩ := exists_transition_bound
+  refine ⟨((1/100:ℝ)^3)⁻¹,((1/100:ℝ)^3)⁻¹*(3*(24*Real.pi^2*M^2/(1/100:ℝ)^2)*(4*(1/100:ℝ))^3),
+    by positivity,by positivity,?_⟩
+  intro L hL x
+  exact ⟨normalized_real L _ x,normalized_mass (by norm_num) hL x,
+    normalized_bound (by norm_num) hL x,normalized_energy_le (by norm_num) hL hM.le hb x,
+    normalized_support (by norm_num) x⟩
+
+end HardSphere.CellOrbital
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/CellPartition.lean

@@ -0,0 +1,74 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Orbitals.CenteredCell
+import OAI.Analysis.HardSphere.Geometry.SelectedUnitCellPenalty
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory Set
+open scoped ENNReal Topology
+namespace HardSphere.CellOrbital
+
+def gridHome {K : ℕ} {L : Length} (hL : L.val=(K:ℝ)) (x : Torus L) : Fin 3→Fin K :=
+  fun j ↦ unitIndex hL (x j+(1/2:ℝ))
+
+lemma gridHome_measurable {K : ℕ} {L : Length} (hL : L.val=(K:ℝ)) : Measurable (gridHome hL) := by
+  exact Measurable.of_eval (fun j ↦ (measurable_unitIndex hL).comp ((measurable_pi_apply j).add_const _))
+
+lemma gridHome_mem {K : ℕ} {L : Length} (hL : L.val=(K:ℝ)) (hK : 1≤K) (x : Torus L) :
+    x∈centeredCell L (gridCenter L (gridHome hL x)) := by
+  apply (centeredCell_image (by rw [hL]; exact_mod_cast hK) _ _).mpr
+  intro j
+  let z := (AddCircle.equivIco L.val 0) (x j+(1/2:ℝ))
+  have hz0 : 0≤z.val := z.property.1
+  let n : ℕ := ⌊z.val⌋₊
+  refine ⟨z.val-(n:ℝ)-1/2,⟨?_,?_⟩,?_⟩
+  · linarith [Nat.floor_le hz0]
+  · have hh := Nat.lt_floor_add_one z.val
+    dsimp [n]
+    linarith
+  · have he : (z.val : AddCircle L.val)=x j+((1/2:ℝ):AddCircle L.val) := AddCircle.coe_equivIco
+    change ((z.val-(n:ℝ)-1/2:ℝ):AddCircle L.val)=x j-((n:ℝ):AddCircle L.val)
+    simp only [QuotientAddGroup.mk_sub]
+    rw [he]
+    abel
+
+lemma centeredCell_disjoint {K : ℕ} {L : Length} (hL : L.val=(K:ℝ)) (hK : 1≤K)
+    {v w : Fin 3→Fin K} (hvw : v≠w) : Disjoint (centeredCell L (gridCenter L v)) (centeredCell L (gridCenter L w)) := by
+  apply Set.disjoint_left.mpr
+  intro x hx hy
+  obtain ⟨j,hj⟩ : ∃j,v j≠w j := by
+    by_contra h
+    push Not at h
+    exact hvw (funext h)
+  have h1 : 1≤L.val := by rw [hL]; exact_mod_cast hK
+  obtain ⟨s,hs,hes⟩ := (centeredCell_image h1 _ _).mp hx j
+  obtain ⟨t,ht,het⟩ := (centeredCell_image h1 _ _).mp hy j
+  have he : gridCenter L v j-gridCenter L w j=((t-s:ℝ):AddCircle L.val) := by
+    rw [QuotientAddGroup.mk_sub,het,hes]
+    abel
+  have ha : |t-s|<1 := by rw [abs_lt]; constructor <;> linarith [ht.1,ht.2,hs.1,hs.2]
+  have hd : dist (gridCenter L v j) (gridCenter L w j)<1 := by
+    rw [dist_eq_norm,he]
+    exact lt_of_le_of_lt (QuotientAddGroup.norm_mk_le_norm (m:=t-s)) (by simpa only [Real.norm_eq_abs] using ha)
+  exact (not_lt_of_ge (fin_circle_dist hL hj)) hd
+
+lemma gridHome_eq_iff {K : ℕ} {L : Length} (hL : L.val=(K:ℝ)) (hK : 1≤K)
+    (x : Torus L) (v : Fin 3→Fin K) : gridHome hL x=v ↔ x∈centeredCell L (gridCenter L v) := by
+  constructor
+  · intro h; exact h ▸ gridHome_mem hL hK x
+  · intro hx
+    by_contra h
+    exact Set.disjoint_left.mp (centeredCell_disjoint hL hK h) (gridHome_mem hL hK x) hx
+
+end HardSphere.CellOrbital
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/CenteredCell.lean

@@ -0,0 +1,209 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.GroundPositionLaw
+
+namespace OAI
+
+section
+section
+noncomputable section
+open MeasureTheory Filter Set
+open scoped ENNReal Topology BigOperators
+noncomputable section
+open scoped BigOperators ComplexConjugate
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Set
+open scoped ENNReal NNReal Topology BigOperators
+noncomputable section
+open MeasureTheory ProbabilityTheory Real Complex
+open scoped ENNReal ComplexConjugate
+open ProbabilityTheory
+noncomputable section
+open MeasureTheory Filter Set
+open scoped ENNReal Topology
+noncomputable section
+open MeasureTheory Set
+open scoped ENNReal
+namespace HardSphere.CellOrbital
+open MeasureTheory Set Filter
+noncomputable section
+
+def centeredCell (L : Length) (c : Torus L) : Set (Torus L) :=
+  {x | ∀ j, ((AddCircle.equivIco L.val (-L.val/2)) (x j-c j)).val ∈ Ico (-1/2:ℝ) (1/2)}
+
+lemma centeredCell_measurable (L : Length) (c : Torus L) : MeasurableSet (centeredCell L c) := by
+  simp only [centeredCell,Set.ofPred_forall]
+  apply MeasurableSet.iInter
+  intro j
+  exact measurableSet_Ico.preimage (measurable_subtype_coe.comp
+    ((AddCircle.measurableEquivIco L.val (-L.val/2)).measurable.comp
+      ((measurable_pi_apply j).sub measurable_const)))
+
+lemma centered_rep_abs (L : Length) (x : AddCircle L.val) :
+    |((AddCircle.equivIco L.val (-L.val/2)) x).val|=‖x‖ := by
+  let t := (AddCircle.equivIco L.val (-L.val/2)) x
+  have ht : |t.val| ≤ |L.val|/2 := by
+    rw [abs_of_pos L.property,abs_le]
+    constructor <;> linarith [t.property.1,t.property.2]
+  have he := (AddCircle.norm_coe_eq_abs_iff L.val L.property.ne').mpr ht
+  rw [AddCircle.coe_equivIco] at he
+  exact he.symm
+
+lemma chi_support_centeredCell (L : Length) (c x : Torus L) (hx : chi L (1/100) c x≠0) :
+    x∈centeredCell L c := by
+  have hnb : bump L (8*(1/100)) c x≠0 := by
+    intro he
+    apply hx
+    simp only [chi,he,zero_pow (by norm_num : (2:ℕ)≠0)]
+  have hb := bump_support (by norm_num : (0:ℝ)<8*(1/100)) c (subset_closure hnb)
+  have hb' := TightCutoff.near_subset_box L.val (by norm_num : (0:ℝ)<8*(1/100)) c hb
+  intro j
+  have hj : dist (x j) (c j) ≤ 2*(8*(1/100)) := Set.mem_univ_pi.mp hb' j
+  have ht : |((AddCircle.equivIco L.val (-L.val/2)) (x j-c j)).val| ≤ 2*(8*(1/100)) := by
+    rw [centered_rep_abs,← dist_eq_norm]
+    exact hj
+  obtain ⟨hl,hu⟩ := abs_le.mp ht
+  constructor <;> linarith
+
+noncomputable def centeredCount {n : ℕ} (L : Length) (c : Torus L) (X : Configuration n L) : ℕ :=
+  by classical exact (Finset.univ.filter (fun i ↦ X i∈centeredCell L c)).card
+
+lemma centeredCount_measurable {n : ℕ} (L : Length) (c : Torus L) :
+    Measurable (centeredCount (n:=n) L c) := by
+  classical
+  unfold centeredCount
+  simp_rw [Finset.card_eq_sum_ones,Finset.sum_filter]
+  apply Finset.measurable_sum
+  intro i _
+  exact Measurable.ite ((centeredCell_measurable L c).preimage (measurable_pi_apply i))
+    measurable_const measurable_const
+
+lemma count_le_centeredCount {n : ℕ} (L : Length) (c : Torus L) (X : Configuration n L) :
+    count L (1/100) c X ≤ (centeredCount L c X:ℝ) := by
+  classical
+  change (∑ i, chi L (1/100) c (X i)) ≤ ((Finset.univ.filter (fun i ↦ X i∈centeredCell L c)).card:ℝ)
+  rw [Finset.card_eq_sum_ones]
+  push_cast
+  rw [Finset.sum_filter]
+  apply Finset.sum_le_sum
+  intro i _
+  by_cases hi : X i∈centeredCell L c
+  · simpa only [ite_eq_left hi] using (chi_bounds L (1/100) c (X i)).2
+  · rw [ite_eq_right hi]
+    have hz : chi L (1/100) c (X i)=0 := by
+      by_contra hh
+      exact hi (chi_support_centeredCell L c (X i) hh)
+    exact hz.le
+
+theorem scaled_centered_low_counts : ∃ α₀ ell D₀ Q : ℝ,
+    0<α₀ ∧ 0<ell ∧ 0<D₀ ∧ 0<Q ∧
+    ∀ (S : Type) [DecidableEq S] (n : ℕ) (L : Length) (D α : ℝ),
+      2≤n → 1 ≤ L.val → D=(n:ℝ)/L.val^3 → D₀ ≤ D →
+      α₀/2 ≤ α → α ≤ 2*α₀ →
+    ∀ (g : Jet n L), IsGroundVector n L (α/D) g →
+    ∀ (c : S → Torus L), (∀ z v, z≠v → 1 ≤ dist (c z) (c v)) →
+    ∀ A : Finset S,
+      groundPositionLaw n L g {X | ∀ s∈A, (centeredCount L (c s) X:ℝ) < ell*D} ≤
+        ENNReal.ofReal ((Q/D^2)^A.card) := by
+  obtain ⟨α₀,ell,D₀,Q,hα,hell,hD₀,hQ,hs⟩ := scaled_low_count_probability
+  refine ⟨α₀,ell,D₀,Q,hα,hell,hD₀,hQ,?_⟩
+  intro S _ n L D α hn hL hDN hDD hαl hαu g hg c hc A
+  apply (measure_mono (show {X : Configuration n L | ∀ s∈A, (centeredCount L (c s) X:ℝ)<ell*D} ⊆
+      {X | ∀ s∈A, count L (1/100) (c s) X<ell*D} from ?_)).trans
+      (hs S n L D α hn hL hDN hDD hαl hαu g hg c hc A)
+  intro X hX s hs
+  exact (count_le_centeredCount L (c s) X).trans_lt (hX s hs)
+
+end
+end HardSphere.CellOrbital
+
+namespace HardSphere.CellOrbital
+open MeasureTheory Set Filter
+noncomputable section
+
+lemma centeredCell_image {L : Length} (hL : 1 ≤ L.val) (c x : Torus L) :
+    x∈centeredCell L c ↔ ∀ j, ∃ t∈Ico (-1/2:ℝ) (1/2), (t : AddCircle L.val)=x j-c j := by
+  constructor
+  · intro hx j
+    exact ⟨_,hx j,AddCircle.coe_equivIco⟩
+  · intro hx j
+    obtain ⟨t,ht,he⟩ := hx j
+    have ht' : t∈Ico (-L.val/2) (-L.val/2+L.val) := by constructor <;> linarith [ht.1,ht.2]
+    rw [← he,AddCircle.equivIco_coe_eq ht']
+    exact ht
+
+def gridCenter {K : ℕ} (L : Length) (v : Fin 3 → Fin K) : Torus L :=
+  fun j ↦ ((v j:ℝ) : AddCircle L.val)
+
+lemma fin_circle_dist {K : ℕ} {L : Length} (hL : L.val=(K:ℝ)) {v w : Fin K} (hvw : v≠w) :
+    1 ≤ dist ((v:ℝ) : AddCircle L.val) ((w:ℝ) : AddCircle L.val) := by
+  have hi (v : Fin K) : (v:ℝ)∈Ico (0:ℝ) (0+L.val) := by
+    constructor
+    · positivity
+    · simpa only [zero_add,hL] using (show (v:ℝ)<(K:ℝ) by exact_mod_cast v.isLt)
+  have hne : ((v:ℝ):AddCircle L.val)≠((w:ℝ):AddCircle L.val) := by
+    intro he
+    have he' := (AddCircle.coe_eq_coe_iff_of_mem_Ico (hi v) (hi w)).mp he
+    exact hvw (Fin.ext (by exact_mod_cast he'))
+  let z : ℤ := (v.val:ℤ)-(w.val:ℤ)-round (L.val⁻¹*((v:ℝ)-(w:ℝ)))*(K:ℤ)
+  have hd : dist ((v:ℝ):AddCircle L.val) ((w:ℝ):AddCircle L.val)=|(z:ℝ)| := by
+    rw [dist_eq_norm,← QuotientAddGroup.mk_sub,AddCircle.norm_eq]
+    dsimp [z]
+    push_cast
+    rw [hL]
+  have hz : z≠0 := by
+    intro hz
+    apply hne
+    apply dist_eq_zero.mp
+    rw [hd,hz,Int.cast_zero,abs_zero]
+  have ha : (1:ℤ)≤|z| := by
+    have hh : 0 < |z| := abs_pos.mpr hz
+    omega
+  rw [hd,← Int.cast_abs]
+  exact_mod_cast ha
+
+lemma gridCenter_separated {K : ℕ} {L : Length} (hL : L.val=(K:ℝ)) :
+    ∀ z v : Fin 3 → Fin K, z≠v → 1 ≤ dist (gridCenter L z) (gridCenter L v) := by
+  intro z v hzv
+  obtain ⟨j,hj⟩ : ∃ j, z j≠v j := by
+    by_contra hh
+    push Not at hh
+    exact hzv (funext hh)
+  exact (fin_circle_dist hL hj).trans (dist_le_pi_dist (gridCenter L z) (gridCenter L v) j)
+
+theorem grid_low_count_probability : ∃ α₀ ell D₀ Q : ℝ,
+    0<α₀ ∧ 0<ell ∧ 0<D₀ ∧ 0<Q ∧
+    ∀ (K n : ℕ) (L : Length) (D α : ℝ),
+      1≤K → L.val=(K:ℝ) → D=(n:ℝ)/L.val^3 → D₀ ≤ D →
+      α₀/2 ≤ α → α ≤ 2*α₀ →
+    ∀ (g : Jet n L), IsGroundVector n L (α/D) g →
+    ∀ A : Finset (Fin 3 → Fin K),
+      groundPositionLaw n L g {X | ∀ s∈A, (centeredCount L (gridCenter L s) X:ℝ) < ell*D} ≤
+        ENNReal.ofReal ((Q/D^2)^A.card) := by
+  obtain ⟨α₀,ell,D₀,Q,hα,hell,hD₀,hQ,hs⟩ := scaled_centered_low_counts
+  refine ⟨α₀,ell,max D₀ 2,Q,hα,hell,lt_of_lt_of_le hD₀ (le_max_left _ _),hQ,?_⟩
+  intro K n L D α hK hLK hDN hDD hαl hαu g hg A
+  have hL : 1 ≤ L.val := by rw [hLK]; exact_mod_cast hK
+  have hD : 2 ≤ D := (le_max_right D₀ 2).trans hDD
+  have hn : 2≤n := by
+    have hp : 1 ≤ L.val^3 := one_le_pow₀ hL
+    have hmul : 2*L.val^3 ≤ (n:ℝ) := by
+      rw [hDN] at hD
+      exact (le_div_iff₀ (by positivity)).mp hD
+    have hn' : (2:ℝ)≤(n:ℝ) := by linarith
+    exact_mod_cast hn'
+  exact hs (Fin 3 → Fin K) n L D α hn hL hDN ((le_max_left D₀ 2).trans hDD) hαl hαu
+    g hg (gridCenter L) (gridCenter_separated hLK) A
+
+end
+end HardSphere.CellOrbital
+
+end
+end
+end
+end
+end
+end
+end
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/Chi.lean

@@ -0,0 +1,110 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Collisions.BalancedInsertion
+import OAI.Analysis.HardSphere.Orbitals.Bump
+
+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.CellOrbital
+open MeasureTheory Set Filter PeriodicCutoff TightCutoff
+open scoped ComplexConjugate
+
+lemma dist_coord_le_torusDistance (L : Length) (x y : Torus L) (j : Fin 3) :
+    dist (x j) (y j) ≤ torusDistance L x y := by
+  calc
+    _ = Real.sqrt (dist (x j) (y j)^2) := (Real.sqrt_sq (dist_nonneg)).symm
+    _ ≤ _ := Real.sqrt_le_sqrt (Finset.single_le_sum
+      (fun k _ ↦ sq_nonneg (dist (x k) (y k))) (Finset.mem_univ j))
+
+def chi (L : Length) (δ : ℝ) (x y : Torus L) : ℝ := bump L (8*δ) x y ^ 2
+
+def count {n : ℕ} (L : Length) (δ : ℝ) (x : Torus L) (X : Configuration n L) : ℝ :=
+  ∑ i, chi L δ x (X i)
+
+lemma chi_bounds (L : Length) (δ : ℝ) (x y : Torus L) : 0 ≤ chi L δ x y ∧ chi L δ x y ≤ 1 := by
+  constructor
+  · exact sq_nonneg _
+  · change bump L (8*δ) x y ^ 2 ≤ 1
+    nlinarith [(bump_bounds L (8*δ) x y).1,(bump_bounds L (8*δ) x y).2]
+
+lemma chi_eq_one_of_reaches {L : Length} {δ r : ℝ} (hδ : 0<δ) (hrδ : r ≤ δ)
+    (x z : Torus L) (hz : ∃ y∈tsupport (normalized L δ x).orbital, torusDistance L y z ≤ 2*r) :
+    chi L δ x z=1 := by
+  obtain ⟨y,hy,hyz⟩ := hz
+  have hyn := TightCutoff.near_subset_box L.val hδ x (normalized_support hδ x hy)
+  have hbox : z∈box L.val ((8*δ)/2) x := by
+    intro j _
+    change dist (z j) (x j) ≤ (8*δ)/2
+    have hb : dist (y j) (x j) ≤ 2*δ := (Set.mem_univ_pi.mp hyn) j
+    have hg := (dist_coord_le_torusDistance L y z j).trans hyz
+    have ht := dist_triangle (z j) (y j) (x j)
+    rw [dist_comm (z j) (y j)] at ht
+    linarith
+  rw [chi,bump_eq_one (by positivity) x hbox,one_pow]
+
+lemma closeLabels_card_le_count {n : ℕ} {L : Length} {δ r : ℝ} (hδ : 0<δ) (hrδ : r ≤ δ)
+    (x : Torus L) (X : Configuration n L) :
+    ((closeLabels r (normalized L δ x) X).card : ℝ) ≤ count L δ x X := by
+  classical
+  calc
+    _ = ∑ i∈closeLabels r (normalized L δ x) X, chi L δ x (X i) := by
+      rw [Finset.sum_eq_card_nsmul (b:= (1:ℝ)) (fun i hi ↦ ?_)]
+      · simp
+      · exact chi_eq_one_of_reaches hδ hrδ x (X i) (Finset.mem_filter.mp hi).2
+    _ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _)
+      (fun j _ _ ↦ (chi_bounds L δ x (X j)).1)
+
+lemma orbitals_separated {S : Type*} {L : Length} {r : ℝ} (hr : r ≤ 1/100)
+    (c : S → Torus L) (hc : ∀ z v, z≠v → 1 ≤ dist (c z) (c v)) :
+    ∀ z v : S, z≠v → ∀ x : Torus L, (normalized L (1/100) (c v)).orbital x≠0 →
+      ¬ ∃ y∈tsupport (normalized L (1/100) (c z)).orbital, torusDistance L y x ≤ 2*r := by
+  intro z v hzv x hx ⟨y,hy,hyx⟩
+  have hxb := TightCutoff.near_subset_box L.val (by norm_num : (0:ℝ)<1/100) (c v)
+    (normalized_support (by norm_num) (c v) (subset_closure hx))
+  have hyb := TightCutoff.near_subset_box L.val (by norm_num : (0:ℝ)<1/100) (c z)
+    (normalized_support (by norm_num) (c z) hy)
+  have hd : dist (c z) (c v) ≤ (6:ℝ)/100 := by
+    apply (dist_pi_le_iff (by norm_num)).mpr
+    intro j
+    have hxj : dist (x j) (c v j) ≤ 2*(1/100) := Set.mem_univ_pi.mp hxb j
+    have hyj : dist (y j) (c z j) ≤ 2*(1/100) := Set.mem_univ_pi.mp hyb j
+    have hyxj := (dist_coord_le_torusDistance L y x j).trans hyx
+    have ht := dist_triangle4 (c z j) (y j) (x j) (c v j)
+    rw [dist_comm (c z j) (y j)] at ht
+    linarith
+  linarith [hc z v hzv]
+
+theorem physical_deficiency : ∃ C B E : ℝ, 0<C ∧ 0<B ∧ 0<E ∧
+    ∀ (S : Type) [Fintype S] [Nonempty S] [DecidableEq S]
+      (n : ℕ) (L : Length) (r : ℝ), 0<r → r ≤ 1/100 → 0<n → 1/100 ≤ L.val →
+    ∀ (g : Jet n L), IsGroundVector n L r g →
+    ∀ (c : S → Torus L), (∀ z v, z≠v → 1 ≤ dist (c z) (c v)) →
+    ∀ (k m : ℕ), C*B*(k+m)*r^3 ≤ 1/4 →
+    ∀ u : Jet n L, u∈dirichletDomain n L r →
+    (∀ᵐ X ∂volume, u.1 X≠0 → ∀ z, count L (1/100) (c z) X ≤ k) →
+    m*Fintype.card S*(energy g/(n:ℝ)-C*(E+B*(k+m)*r))*‖u.1‖^2 ≤
+      energy u-energy g*‖u.1‖^2 := by
+  obtain ⟨C,hC,hdef⟩ := deficiency_penalty_cells
+  obtain ⟨B,E,hB,hE,hw⟩ := uniform_orbitals
+  refine ⟨C,B,E,hC,hB,hE,?_⟩
+  intro S _ _ _ n L r hr hrδ hn hL g hg c hc k m hs u hu hk
+  apply hdef S n L r hr hn g hg (fun z ↦ normalized L (1/100) (c z))
+    (fun z ↦ (hw L hL (c z)).1) (fun z ↦ (hw L hL (c z)).2.1)
+    (orbitals_separated hrδ c hc) k m B E
+    (fun z ↦ (hw L hL (c z)).2.2.1) (fun z ↦ (hw L hL (c z)).2.2.2.1) hs u hu
+  filter_upwards [hk] with X hX huX z
+  exact_mod_cast (closeLabels_card_le_count (by norm_num) hrδ (c z) X).trans (hX huX z)
+
+end HardSphere.CellOrbital
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/Chi2.lean

@@ -0,0 +1,93 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Orbitals.Chi
+import OAI.Analysis.HardSphere.Geometry.LabelLift
+
+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.CellOrbital
+open MeasureTheory Set Filter PeriodicCutoff TightCutoff
+open scoped ComplexConjugate
+
+def chiOne (L : Length) (δ : ℝ) (x : Torus L) : SmoothMultiplier 1 L :=
+  (raw L (8*δ) x).mul (raw L (8*δ) x)
+
+lemma chiOne_apply (L : Length) (δ : ℝ) (x : Torus L) (X : Configuration 1 L) :
+    (chiOne L δ x).toFun X=(chi L δ x (X 0) : ℂ) := by
+  simp only [chiOne,SmoothMultiplier.mul,Pi.mul_apply,raw,SmoothMultiplier.ofSmooth,chi]
+  rw [Complex.ofReal_pow,pow_two]
+
+def countMultiplier (n : ℕ) (L : Length) (δ : ℝ) (x : Torus L) : SmoothMultiplier n L :=
+  SmoothMultiplier.sum (fun i : Fin n ↦ (chiOne L δ x).liftLabel n i)
+
+lemma countMultiplier_apply (n : ℕ) (L : Length) (δ : ℝ) (x : Torus L) (X : Configuration n L) :
+    (countMultiplier n L δ x).toFun X=(count L δ x X : ℂ) := by
+  change (∑ i : Fin n, (chiOne L δ x).toFun (fun _ ↦ X i)) = _
+  simp_rw [chiOne_apply]
+  exact (Complex.ofReal_sum _ _).symm
+
+lemma countMultiplier_real (n : ℕ) (L : Length) (δ : ℝ) (x : Torus L) (X : Configuration n L) :
+    conj ((countMultiplier n L δ x).toFun X)=(countMultiplier n L δ x).toFun X := by
+  rw [countMultiplier_apply,Complex.conj_ofReal]
+
+lemma count_nonneg {n : ℕ} (L : Length) (δ : ℝ) (x : Torus L) (X : Configuration n L) :
+    0 ≤ count L δ x X := Finset.sum_nonneg fun _ _ ↦ (chi_bounds _ _ _ _).1
+
+lemma chiOne_partial (L : Length) (δ : ℝ) (x y : Torus L) (j : Fin 3) :
+    coordDerivative 1 L (chiOne L δ x).toFun (0,j) (fun _ ↦ y)=
+      2*(bump L (8*δ) x y : ℂ)*coordDerivative 1 L (raw L (8*δ) x).toFun (0,j) (fun _ ↦ y) := by
+  have he := congrFun (coordDerivative_mul ((raw L (8*δ) x).smooth.differentiable (by simp))
+    ((raw L (8*δ) x).smooth.differentiable (by simp)) (0,j)) (fun _ ↦ y)
+  change coordDerivative 1 L ((raw L (8*δ) x).toFun * (raw L (8*δ) x).toFun) (0,j) _ = _
+  rw [he]
+  change (bump L (8*δ) x y : ℂ)*_+(bump L (8*δ) x y : ℂ)*_=_
+  ring
+
+lemma countMultiplier_partial (n : ℕ) (L : Length) (δ : ℝ) (x : Torus L)
+    (p : Direction n) (X : Configuration n L) :
+    coordDerivative n L (countMultiplier n L δ x).toFun p X=
+      coordDerivative 1 L (chiOne L δ x).toFun (0,p.2) (fun _ ↦ X p.1) := by
+  classical
+  rw [countMultiplier,SmoothMultiplier.partial_sum]
+  simp_rw [SmoothMultiplier.partial_liftLabel]
+  simp
+
+lemma chiOne_partial_sq_le {L : Length} {δ M : ℝ} (hδ : 0<δ) (hM : 0 ≤ M)
+    (hb : ∀ t : ℝ, |deriv Real.smoothTransition t| ≤ M) (x y : Torus L) (j : Fin 3) :
+    ‖coordDerivative 1 L (chiOne L δ x).toFun (0,j) (fun _ ↦ y)‖^2 ≤
+      (4*(24*Real.pi^2*M^2/(8*δ)^2))*chi L δ x y := by
+  rw [chiOne_partial,norm_mul,norm_mul,mul_pow,mul_pow,Complex.norm_real,Real.norm_eq_abs,sq_abs]
+  rw [show ‖(2:ℂ)‖=2 by norm_num]
+  have h := mul_le_mul_of_nonneg_left (raw_partial_sq_le (by positivity : 0<8*δ) hM hb x y j)
+    (show 0 ≤ 4*(bump L (8*δ) x y)^2 by positivity)
+  dsimp [chi]
+  nlinarith
+
+lemma countMultiplier_gradient_le {n : ℕ} {L : Length} {δ M : ℝ} (hδ : 0<δ) (hM : 0 ≤ M)
+    (hb : ∀ t : ℝ, |deriv Real.smoothTransition t| ≤ M) (x : Torus L) (X : Configuration n L) :
+    (∑ p : Direction n, ‖coordDerivative n L (countMultiplier n L δ x).toFun p X‖^2) ≤
+      (3*(4*(24*Real.pi^2*M^2/(8*δ)^2)))*count L δ x X := by
+  simp_rw [countMultiplier_partial]
+  rw [Fintype.sum_prod_type]
+  calc
+    _ ≤ ∑ i : Fin n, ∑ _j : Fin 3, (4*(24*Real.pi^2*M^2/(8*δ)^2))*chi L δ x (X i) := by
+      exact Finset.sum_le_sum fun i _ ↦ Finset.sum_le_sum fun j _ ↦ chiOne_partial_sq_le hδ hM hb x (X i) j
+    _ = _ := by
+      simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,count,Finset.mul_sum]
+      apply Finset.sum_congr rfl
+      intro i _
+      ring
+
+end HardSphere.CellOrbital
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/FieldApply.lean

@@ -0,0 +1,244 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.CoordinateLine
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory Filter Set
+open scoped Topology ENNReal BigOperators
+
+namespace L2Contraction
+variable {α E F G : Type*} [MeasurableSpace α] {μ : Measure α}
+  [NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
+
+lemma unifIntegrable_of_domination {ι : Type*} {p : ℝ≥0∞}
+    {f : ι → α → E} {b : α → F} (hp : 1 ≤ p) (hp' : p ≠ ∞) (hb : MemLp b p μ)
+    (hf_meas : ∀ index, AEStronglyMeasurable (f index) μ)
+    (hbound : ∀ n, ∀ᵐ x ∂μ, ‖f n x‖ ≤ ‖b x‖) : UnifIntegrable f p μ := by
+  refine unifIntegrable_iff.2 fun ε hε ↦ ?_
+  obtain ⟨δ, hδ, hi⟩ := unifIntegrable_iff.1 (unifIntegrable_const (ι := ι) hp hp' hb) ε hε
+  refine ⟨δ, hδ, fun index region hμs ↦ le_trans ?_ (hi index region hμs)⟩
+  exact eLpNorm_mono_ae (hf_meas index).restrict (ae_restrict_of_ae (hbound index))
+
+lemma tendsto_toLp_of_domination [IsFiniteMeasure μ]
+    {f : ℕ → α → E} {g : α → E} {b : α → F}
+    (hf : ∀ n, MemLp (f n) 2 μ) (hg : MemLp g 2 μ) (hb : MemLp b 2 μ)
+    (hbound : ∀ n, ∀ᵐ x ∂μ, ‖f n x‖ ≤ ‖b x‖)
+    (hl : ∀ᵐ x ∂μ, Tendsto (fun n ↦ f n x) atTop (𝓝 (g x))) :
+    Tendsto (fun n ↦ (hf n).toLp (f n)) atTop (𝓝 (hg.toLp g)) := by
+  apply (Lp.tendsto_Lp_iff_tendsto_eLpNorm'' f hf g hg).2
+  exact tendsto_Lp_finite_of_tendsto_ae (by norm_num) (by norm_num)
+    (fun n ↦ (hf n).aestronglyMeasurable) hg
+    (unifIntegrable_of_domination (by norm_num) (by norm_num) hb
+      (fun index ↦ (hf index).aestronglyMeasurable) hbound) hl
+
+section Field
+variable [NormedSpace ℝ E] [NormedSpace ℝ F]
+    (A : α → E →L[ℝ] F) (hA : AEStronglyMeasurable A μ)
+    (hbound : ∀ᵐ x ∂μ, ‖A x‖ ≤ 1)
+include hA hbound
+
+lemma field_memLp (v : Lp E 2 μ) : MemLp (fun x ↦ A x (v x)) 2 μ := by
+  apply (Lp.memLp v).of_le ((continuous_fst.clm_apply continuous_snd).comp_aestronglyMeasurable
+    (hA.prodMk (Lp.aestronglyMeasurable v)))
+  filter_upwards [hbound] with x hx
+  exact (A x).le_opNorm (v x) |>.trans (by nlinarith [norm_nonneg (v x)])
+
+def fieldApply (v : Lp E 2 μ) : Lp F 2 μ :=
+  (field_memLp A hA hbound v).toLp _
+
+lemma coe_fieldApply (v : Lp E 2 μ) :
+    fieldApply A hA hbound v =ᵐ[μ] fun x ↦ A x (v x) :=
+  MemLp.coeFn_toLp _
+
+lemma norm_fieldApply_le (v : Lp E 2 μ) : ‖fieldApply A hA hbound v‖ ≤ ‖v‖ := by
+  apply Lp.norm_le_norm_of_ae_le
+  filter_upwards [coe_fieldApply A hA hbound v, hbound] with x hx hb
+  rw [hx]
+  exact (A x).le_opNorm (v x) |>.trans (by nlinarith [norm_nonneg (v x)])
+
+lemma fieldApply_sub (v w : Lp E 2 μ) :
+    fieldApply A hA hbound (v - w) = fieldApply A hA hbound v - fieldApply A hA hbound w := by
+  apply Lp.ext
+  filter_upwards [coe_fieldApply A hA hbound (v - w), coe_fieldApply A hA hbound v,
+    coe_fieldApply A hA hbound w, Lp.coeFn_sub v w,
+    Lp.coeFn_sub (fieldApply A hA hbound v) (fieldApply A hA hbound w)] with x h1 h2 h3 h4 h5
+  simp only [h1, h4, Pi.sub_apply, map_sub, h5, h2, h3]
+
+lemma norm_fieldApply_sub_le (v w : Lp E 2 μ) :
+    ‖fieldApply A hA hbound v - fieldApply A hA hbound w‖ ≤ ‖v - w‖ := by
+  rw [← fieldApply_sub]
+  exact norm_fieldApply_le A hA hbound _
+end Field
+
+variable [NormedSpace ℝ E] [NormedSpace ℝ F]
+
+lemma coeff_meas (A : G → E →L[ℝ] F) (hA : Continuous A) (u : Lp G 2 μ) :
+    AEStronglyMeasurable (fun x ↦ A (u x)) μ :=
+  hA.comp_aestronglyMeasurable (Lp.aestronglyMeasurable u)
+
+lemma tendsto_fieldApply_fixed [IsFiniteMeasure μ]
+    (A : G → E →L[ℝ] F) (hA : Continuous A) (hb : ∀ z, ‖A z‖ ≤ 1)
+    (u : ℕ → Lp G 2 μ) (u₀ : Lp G 2 μ)
+    (hu : ∀ᵐ x ∂μ, Tendsto (fun n ↦ u n x) atTop (𝓝 (u₀ x))) (v : Lp E 2 μ) :
+    Tendsto (fun n ↦ fieldApply (fun x ↦ A (u n x)) (coeff_meas A hA (u n))
+      (Eventually.of_forall (fun x ↦ hb (u n x))) v) atTop
+      (𝓝 (fieldApply (fun x ↦ A (u₀ x)) (coeff_meas A hA u₀)
+        (Eventually.of_forall (fun x ↦ hb (u₀ x))) v)) := by
+  apply tendsto_toLp_of_domination _ _ (Lp.memLp v)
+  · intro n
+    exact Eventually.of_forall fun x ↦ (A (u n x)).le_opNorm (v x) |>.trans
+      (by nlinarith [norm_nonneg (v x), hb (u n x)])
+  · filter_upwards [hu] with x hx
+    exact ((ContinuousLinearMap.apply ℝ F (v x)).continuous.tendsto _).comp
+      (hA.continuousAt.tendsto.comp hx)
+
+lemma tendsto_fieldApply [IsFiniteMeasure μ]
+    (A : G → E →L[ℝ] F) (hA : Continuous A) (hb : ∀ z, ‖A z‖ ≤ 1)
+    (u : ℕ → Lp G 2 μ) (u₀ : Lp G 2 μ)
+    (hu : ∀ᵐ x ∂μ, Tendsto (fun n ↦ u n x) atTop (𝓝 (u₀ x)))
+    (v : ℕ → Lp E 2 μ) (v₀ : Lp E 2 μ) (hv : Tendsto v atTop (𝓝 v₀)) :
+    Tendsto (fun n ↦ fieldApply (fun x ↦ A (u n x)) (coeff_meas A hA (u n))
+      (Eventually.of_forall (fun x ↦ hb (u n x))) (v n)) atTop
+      (𝓝 (fieldApply (fun x ↦ A (u₀ x)) (coeff_meas A hA u₀)
+        (Eventually.of_forall (fun x ↦ hb (u₀ x))) v₀)) := by
+  have hdiff : Tendsto (fun n ↦
+      fieldApply (fun x ↦ A (u n x)) (coeff_meas A hA (u n))
+        (Eventually.of_forall (fun x ↦ hb (u n x))) (v n) -
+      fieldApply (fun x ↦ A (u n x)) (coeff_meas A hA (u n))
+        (Eventually.of_forall (fun x ↦ hb (u n x))) v₀) atTop (𝓝 0) := by
+    apply squeeze_zero_norm (fun n ↦ norm_fieldApply_sub_le _ _ _ (v n) v₀)
+    simpa using (hv.sub_const v₀).norm
+  simpa only [sub_add_cancel, zero_add] using
+    hdiff.add (tendsto_fieldApply_fixed A hA hb u u₀ hu v₀)
+
+end L2Contraction
+
+namespace HardSphere
+
+structure SmoothContraction where
+  toFun : ℂ → ℂ
+  smooth : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) toFun
+  zero : toFun 0 = 0
+  derivative_le : ∀ z, ‖fderiv ℝ toFun z‖ ≤ 1
+
+namespace SmoothContraction
+variable (f : SmoothContraction)
+
+lemma lipschitz : LipschitzWith 1 f.toFun :=
+  lipschitzWith_of_nnnorm_fderiv_le (f.smooth.differentiable (by simp))
+    (fun z ↦ NNReal.coe_le_coe.mp (f.derivative_le z))
+
+lemma derivative_continuous : Continuous (fderiv ℝ f.toFun) :=
+  f.smooth.continuous_fderiv (by simp)
+
+lemma coordDerivative_comp {N : ℕ} {L : Length} {a : ℝ}
+    (g : SmoothTest N L a) (p : Direction N) :
+    coordDerivative N L (f.toFun ∘ g.toFun) p = fun X ↦
+      fderiv ℝ f.toFun (g.toFun X) (coordDerivative N L g.toFun p X) := by
+  funext X
+  unfold coordDerivative
+  rw [show (fun Y : LiftedConfiguration N ↦ (f.toFun ∘ g.toFun) (project N L Y)) =
+    f.toFun ∘ (fun Y ↦ g.toFun (project N L Y)) from rfl]
+  rw [fderiv_comp (representative N L X)
+    (f.smooth.differentiable (by simp)).differentiableAt
+    (g.smooth.differentiable (by simp)).differentiableAt]
+  simp only [ContinuousLinearMap.comp_apply, project_representative]
+
+def composeTest {N : ℕ} {L : Length} {a : ℝ}
+    (g : SmoothTest N L a) : SmoothTest N L a where
+  toFun := f.toFun ∘ g.toFun
+  smooth := f.smooth.comp g.smooth
+  compact := g.compact.comp_left f.zero
+  support_allowed := (tsupport_comp_subset f.zero g.toFun).trans g.support_allowed
+  memLp := f.lipschitz.comp_memLp f.zero g.memLp
+  partial_memLp := by
+    intro p
+    rw [f.coordDerivative_comp g p]
+    have hm := f.derivative_continuous.comp_aestronglyMeasurable g.memLp.aestronglyMeasurable
+    apply (g.partial_memLp p).of_le
+      ((continuous_fst.clm_apply continuous_snd).comp_aestronglyMeasurable
+        (hm.prodMk (g.partial_memLp p).aestronglyMeasurable))
+    exact Eventually.of_forall fun X ↦
+      (fderiv ℝ f.toFun (g.toFun X)).le_opNorm _ |>.trans
+        (by nlinarith [f.derivative_le (g.toFun X),
+          norm_nonneg (coordDerivative N L g.toFun p X)])
+
+def onScalar {N : ℕ} {L : Length} (u : ScalarL2 N L) : ScalarL2 N L :=
+  f.lipschitz.compLp f.zero u
+
+def onPartial {N : ℕ} {L : Length} (u v : ScalarL2 N L) : ScalarL2 N L :=
+  L2Contraction.fieldApply (fun X ↦ fderiv ℝ f.toFun (u X))
+    (L2Contraction.coeff_meas _ f.derivative_continuous u)
+    (Eventually.of_forall (fun X ↦ f.derivative_le (u X))) v
+
+def onJet {N : ℕ} {L : Length} (u : Jet N L) : Jet N L :=
+  (f.onScalar u.1, fun p ↦ f.onPartial u.1 (u.2 p))
+
+lemma coe_onScalar {N : ℕ} {L : Length} (u : ScalarL2 N L) :
+    f.onScalar u =ᵐ[volume] fun X ↦ f.toFun (u X) := f.lipschitz.coeFn_compLp f.zero u
+
+lemma coe_onPartial {N : ℕ} {L : Length} (u v : ScalarL2 N L) :
+    f.onPartial u v =ᵐ[volume] fun X ↦ fderiv ℝ f.toFun (u X) (v X) :=
+  L2Contraction.coe_fieldApply _ _ _ v
+
+lemma jet_composeTest {N : ℕ} {L : Length} {a : ℝ}
+    (g : SmoothTest N L a) : (f.composeTest g).jet = f.onJet g.jet := by
+  apply Prod.ext
+  · apply Lp.ext
+    filter_upwards [(f.composeTest g).memLp.coeFn_toLp, f.coe_onScalar g.jet.1,
+      g.memLp.coeFn_toLp] with X h1 h2 h3
+    change g.jet.1 X = g.toFun X at h3
+    change (f.composeTest g).jet.1 X = f.toFun (g.toFun X) at h1
+    change (f.composeTest g).jet.1 X = f.onScalar g.jet.1 X
+    rw [h1, h2, h3]
+  · funext p
+    apply Lp.ext
+    filter_upwards [(f.composeTest g).partial_memLp p |>.coeFn_toLp,
+      f.coe_onPartial g.jet.1 (g.jet.2 p), g.memLp.coeFn_toLp,
+      (g.partial_memLp p).coeFn_toLp] with X h1 h2 h3 h4
+    change (f.composeTest g).jet.2 p X = coordDerivative N L (f.toFun ∘ g.toFun) p X at h1
+    change g.jet.1 X = g.toFun X at h3
+    change g.jet.2 p X = coordDerivative N L g.toFun p X at h4
+    change (f.composeTest g).jet.2 p X = f.onPartial g.jet.1 (g.jet.2 p) X
+    rw [h1, h2]
+    rw [f.coordDerivative_comp g p, h3, h4]
+
+lemma onJet_mem_domain {N : ℕ} {L : Length} {a : ℝ} {u : Jet N L}
+    (hu : u ∈ dirichletDomain N L a) : f.onJet u ∈ dirichletDomain N L a := by
+  obtain ⟨v, hv, hl⟩ := mem_closure_iff_seq_limit.mp hu
+  choose g hg using hv
+  have hl' : Tendsto (fun n ↦ (g n).jet) atTop (𝓝 u) := by simpa only [hg] using hl
+  have hs := (continuous_fst.tendsto u).comp hl'
+  obtain ⟨ns, hns, hae⟩ := (tendstoInMeasure_of_tendsto_Lp hs).exists_seq_tendsto_ae
+  have hlim : Tendsto (fun n ↦ (f.composeTest (g (ns n))).jet) atTop (𝓝 (f.onJet u)) := by
+    simp only [f.jet_composeTest]
+    apply Tendsto.prodMk_nhds
+    · exact (f.lipschitz.continuous_compLp f.zero).continuousAt.tendsto.comp
+        (hs.comp hns.tendsto_atTop)
+    · apply tendsto_pi_nhds.mpr
+      intro p
+      apply L2Contraction.tendsto_fieldApply _ f.derivative_continuous f.derivative_le
+        _ u.1 hae _ (u.2 p)
+      exact ((continuous_apply p).tendsto u.2).comp
+        ((continuous_snd.tendsto u).comp (hl'.comp hns.tendsto_atTop))
+  exact isClosed_closure.mem_of_tendsto hlim
+    (Eventually.of_forall fun n ↦ subset_closure ⟨f.composeTest (g (ns n)), rfl⟩)
+
+lemma energy_onJet_le {N : ℕ} {L : Length} (u : Jet N L) :
+    energy (f.onJet u) ≤ energy u := by
+  apply Finset.sum_le_sum
+  intro p _
+  apply pow_le_pow_left₀ (norm_nonneg _) _ 2
+  exact L2Contraction.norm_fieldApply_le _
+    (L2Contraction.coeff_meas _ f.derivative_continuous u.1)
+    (Eventually.of_forall fun X ↦ f.derivative_le (u.1 X)) (u.2 p)
+
+end SmoothContraction
+end HardSphere
+
+open scoped RealInnerProductSpace
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/FreePathLawFiniteDeletion.lean

@@ -0,0 +1,133 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.SliceNormSq
+
+namespace OAI
+
+section
+section
+noncomputable section
+open MeasureTheory Filter Set
+open scoped Topology ENNReal BigOperators
+open scoped RealInnerProductSpace
+noncomputable section
+open MeasureTheory Filter Set
+open scoped Topology ENNReal BigOperators
+namespace HardSphere
+open MeasureTheory Wiener Set Filter
+noncomputable section
+
+instance freePathLaw_finite_deletion (N : ℕ) (L : Length) (t : ℝ) :
+    IsFiniteMeasure (freePathLaw N L t) := by unfold freePathLaw; infer_instance
+instance killedPathLaw_finite_deletion (N : ℕ) (L : Length) (a t : ℝ) :
+    IsFiniteMeasure (killedPathLaw N L a t) := by unfold killedPathLaw; infer_instance
+
+@[simp] lemma joinConfigurationPath_apply (m n : ℕ) (L : Length)
+    (p : ConfigurationPath m L × ConfigurationPath n L) (t : Time) :
+    joinConfigurationPath m n L p t=joinConfiguration m n L (p.1 t,p.2 t) := rfl
+
+lemma selected_reversal_integral {m n : ℕ} {L : Length} (u : ScalarL2 (m+n) L) (t : ℝ)
+    {h : ConfigurationPath m L → ℝ≥0∞} (hh : Measurable h)
+    (hrev : ∀ ω, h (reverseConfigurationPath m L ω)=h ω) :
+    (∫⁻ ω : ConfigurationPath m L, h ω*ENNReal.ofReal (sliceNormSq u (ω 1)) ∂freePathLaw m L t)=
+      ∫⁻ ω : ConfigurationPath m L, h ω*ENNReal.ofReal (sliceNormSq u (ω 0)) ∂freePathLaw m L t := by
+  have hmeas : Measurable (fun ω : ConfigurationPath m L ↦ h ω*ENNReal.ofReal (sliceNormSq u (ω 0))) :=
+    hh.mul (((sliceNormSq_measurable u).comp (continuous_eval_const (0:Time)).measurable).ennreal_ofReal)
+  simpa only [reverseConfigurationPath_apply,reverseTime_zero,hrev] using
+    (reverse_freePath_preserving m L t).lintegral_comp hmeas
+
+lemma deleted_path_integral_le {m n : ℕ} {L : Length} (u : ScalarL2 (m+n) L) (a t : ℝ)
+    {h : ConfigurationPath m L → ℝ≥0∞} (hh : Measurable h)
+    (hrev : ∀ ω, h (reverseConfigurationPath m L ω)=h ω) :
+    (∫⁻ ω : ConfigurationPath (m+n) L,
+      h (splitConfigurationPath m n L ω).1*ENNReal.ofReal (‖u (ω 0)‖*‖u (ω 1)‖)
+      ∂killedPathLaw (m+n) L a t) ≤
+      ENNReal.ofReal ‖killedTransition n L a t‖*
+        ∫⁻ ω : ConfigurationPath m L, h ω*ENNReal.ofReal (sliceNormSq u (ω 0)) ∂freePathLaw m L t := by
+  let F : ConfigurationPath (m+n) L → ℝ≥0∞ := fun ω ↦
+    h (splitConfigurationPath m n L ω).1*ENNReal.ofReal (‖u (ω 0)‖*‖u (ω 1)‖)
+  let G : ConfigurationPath m L × ConfigurationPath n L → ℝ≥0∞ := fun p ↦
+    h p.1*ENNReal.ofReal (‖u (joinConfiguration m n L (p.1 0,p.2 0))‖*
+      ‖u (joinConfiguration m n L (p.1 1,p.2 1))‖)
+  have hu := (Lp.stronglyMeasurable u).measurable
+  have hF : Measurable F := by
+    exact (hh.comp ((splitConfigurationPath_continuous m n L).measurable.fst)).mul
+      (((hu.comp (continuous_eval_const (0:Time)).measurable).norm.mul
+        (hu.comp (continuous_eval_const (1:Time)).measurable).norm).ennreal_ofReal)
+  have hG : Measurable G := by
+    simpa only [F,G,Function.comp_def,split_joinConfigurationPath,joinConfigurationPath_apply]
+      using hF.comp (joinConfigurationPath_continuous m n L).measurable
+  have hS0 : Measurable (fun ω : ConfigurationPath m L ↦ h ω*ENNReal.ofReal (sliceNormSq u (ω 0))) :=
+    hh.mul (((sliceNormSq_measurable u).comp (continuous_eval_const (0:Time)).measurable).ennreal_ofReal)
+  have hS1 : Measurable (fun ω : ConfigurationPath m L ↦ h ω*ENNReal.ofReal (sliceNormSq u (ω 1))) :=
+    hh.mul (((sliceNormSq_measurable u).comp (continuous_eval_const (1:Time)).measurable).ennreal_ofReal)
+  have hj := (joinConfigurationPath_preserving m n L t).restrict_preimage
+    (staysAllowed_open (m+n) L a).measurableSet
+  have hd : ((freePathLaw m L t).prod (freePathLaw n L t)).restrict
+      (joinConfigurationPath m n L ⁻¹' staysAllowed (m+n) L a) ≤
+      (freePathLaw m L t).prod (killedPathLaw n L a t) := by
+    calc
+      _ ≤ ((freePathLaw m L t).prod (freePathLaw n L t)).restrict
+          (Set.univ ×ˢ staysAllowed n L a) :=
+        Measure.restrict_mono_set _ fun p hp ↦
+          ⟨mem_univ _,staysAllowed_join_subset_bath m n L a hp⟩
+      _ = _ := by rw [← Measure.prod_restrict,Measure.restrict_univ]; rfl
+  have hq := bath_slice_quadratic_ae u a t
+  calc
+    _ = ∫⁻ p, G p ∂((freePathLaw m L t).prod (freePathLaw n L t)).restrict
+        (joinConfigurationPath m n L ⁻¹' staysAllowed (m+n) L a) := by
+      symm
+      simpa only [F,G,killedPathLaw,split_joinConfigurationPath,joinConfigurationPath_apply] using
+        hj.lintegral_comp hF
+    _ ≤ ∫⁻ p, G p ∂((freePathLaw m L t).prod (killedPathLaw n L a t)) :=
+      lintegral_mono' hd le_rfl
+    _ = ∫⁻ ω : ConfigurationPath m L, h ω*(∫⁻ η : ConfigurationPath n L,
+        ENNReal.ofReal (‖u (joinConfiguration m n L (ω 0,η 0))‖*
+          ‖u (joinConfiguration m n L (ω 1,η 1))‖) ∂killedPathLaw n L a t) ∂freePathLaw m L t := by
+      rw [lintegral_prod _ hG.aemeasurable]
+      apply lintegral_congr
+      intro ω
+      dsimp only [G]
+      exact lintegral_const_mul _ (by
+        apply Measurable.ennreal_ofReal
+        apply Measurable.mul
+        all_goals
+          apply Measurable.norm
+          apply hu.comp
+          exact (joinConfiguration_continuous m n L).measurable.comp
+            (measurable_const.prodMk (continuous_eval_const _).measurable))
+    _ ≤ ∫⁻ ω : ConfigurationPath m L, h ω*(ENNReal.ofReal (‖killedTransition n L a t‖/2)*
+        (ENNReal.ofReal (sliceNormSq u (ω 0))+ENNReal.ofReal (sliceNormSq u (ω 1)))) ∂freePathLaw m L t := by
+      apply lintegral_mono_ae
+      filter_upwards [hq] with ω hω
+      exact mul_le_mul_right hω _
+    _ = ENNReal.ofReal (‖killedTransition n L a t‖/2)*
+        ((∫⁻ ω : ConfigurationPath m L, h ω*ENNReal.ofReal (sliceNormSq u (ω 0)) ∂freePathLaw m L t)+
+         (∫⁻ ω : ConfigurationPath m L, h ω*ENNReal.ofReal (sliceNormSq u (ω 1)) ∂freePathLaw m L t)) := by
+      calc
+        _ = ∫⁻ ω : ConfigurationPath m L, ENNReal.ofReal (‖killedTransition n L a t‖/2)*
+            (h ω*ENNReal.ofReal (sliceNormSq u (ω 0))+h ω*ENNReal.ofReal (sliceNormSq u (ω 1)))
+            ∂freePathLaw m L t := by
+          apply lintegral_congr
+          intro ω
+          rw [← mul_add,mul_left_comm]
+        _ = _ := by
+          calc
+            _ = ENNReal.ofReal (‖killedTransition n L a t‖/2)*
+                (∫⁻ ω : ConfigurationPath m L,
+                  h ω*ENNReal.ofReal (sliceNormSq u (ω 0))+
+                    h ω*ENNReal.ofReal (sliceNormSq u (ω 1)) ∂freePathLaw m L t) :=
+              lintegral_const_mul _ (hS0.add hS1)
+            _ = _ := by rw [lintegral_add_left hS0]
+    _ = _ := by
+      rw [selected_reversal_integral u t hh hrev,mul_add,← add_mul,
+        ← ENNReal.ofReal_add (div_nonneg (norm_nonneg _) (by norm_num))
+          (div_nonneg (norm_nonneg _) (by norm_num)),add_halves]
+end
+end HardSphere
+
+end
+end
+end
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/GridLowStationary.lean

@@ -0,0 +1,50 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Operators.Stationary
+import OAI.Analysis.HardSphere.Thermodynamics.LowCountAbove
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.CellOrbital
+open Wiener
+
+theorem grid_stationary_low_above (Amin : ℝ) : ∃ α₀ ell D₀ Q : ℝ,
+    Amin≤α₀ ∧ 0<α₀ ∧ 0<ell ∧ 0<D₀ ∧ 0<Q ∧
+    ∀ (K n : ℕ) [Nontrivial (Fin n)] (L : Length) (D α : ℝ),
+      1≤K → L.val=(K:ℝ) → D=(n:ℝ)/L.val^3 → D₀≤D → α₀/2≤α → α≤2*α₀ →
+    ∀ (g : Jet n L), IsGroundVector n L (α/D) g →
+    ∀ (T : ℝ), 0≤T → ∀ (q : Time) (A : Finset (Fin 3→Fin K)),
+      groundPathLaw n L (α/D) T g {ω | ∀v∈A,(centeredCount L (gridCenter L v) (ω q):ℝ)<ell*D}≤
+        ENNReal.ofReal ((Q/D^2)^A.card) := by
+  obtain ⟨α₀,ell,D₀,Q,hA,hα,hell,hD₀,hQ,hs⟩ := scaled_joint_low_counts_above Amin
+  refine ⟨α₀,ell,D₀,Q,hA,hα,hell,hD₀,hQ,?_⟩
+  intro K n inst L D α hK hLK hDN hDD hαl hαu g hg T hT q A
+  have hL : 1≤L.val := by rw [hLK]; exact_mod_cast hK
+  have hn : 2≤n := Nat.succ_le_of_lt (by simpa only [Fintype.card_fin] using (Fintype.one_lt_card_iff_nontrivial.mpr (inferInstance : Nontrivial (Fin n))))
+  have hset : MeasurableSet {X : Configuration n L | ∀v∈A,(centeredCount L (gridCenter L v) X:ℝ)<ell*D} := by
+    simpa only [Set.ofPred_forall, Function.comp_def] using MeasurableSet.iInter (fun site ↦
+      MeasurableSet.iInter (fun _ : site∈A ↦ measurableSet_lt
+        ((measurable_of_countable (fun count : ℕ ↦ (count:ℝ))).comp
+          (centeredCount_measurable L (gridCenter L site))) measurable_const))
+  have hm := (hg.groundPathLaw_marginal T hT q).measure_preimage hset.nullMeasurableSet
+  change groundPathLaw n L (α/D) T g ((fun ω ↦ ω q) ⁻¹' {X | ∀v∈A,(centeredCount L (gridCenter L v) X:ℝ)<ell*D})≤_
+  rw [hm]
+  apply (groundPositionLaw_le_joint (mul_pos hell (hD₀.trans_le hDD)) (gridCenter L) A g _ hset ?_).trans
+  · exact ENNReal.ofReal_le_ofReal (hs (Fin 3→Fin K) n L D α hn hL hDN hDD hαl hαu g hg
+      (gridCenter L) (gridCenter_separated hLK) A)
+  · intro X hX v hv
+    exact (count_le_centeredCount L (gridCenter L v) X).trans (hX v hv).le
+
+end HardSphere.CellOrbital
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/Joint.lean

@@ -0,0 +1,103 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Orbitals.Profile
+import OAI.Analysis.HardSphere.Geometry.FinsetProd
+
+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.CellOrbital
+open MeasureTheory Set Filter PeriodicCutoff TightCutoff
+open scoped ComplexConjugate
+
+lemma bump_separated {S : Type*} {L : Length} (c : S → Torus L)
+    (hc : ∀ z v, z≠v → 1 ≤ dist (c z) (c v)) (z v : S) (hzv : z≠v) (y : Torus L) :
+    bump L (8*(1/100)) (c z) y=0 ∨ bump L (8*(1/100)) (c v) y=0 := by
+  by_contra hn
+  push Not at hn
+  have hbz := TightCutoff.near_subset_box L.val (by norm_num : (0:ℝ)<8*(1/100)) (c z)
+    (bump_support (by norm_num) (c z) (subset_closure hn.1))
+  have hbv := TightCutoff.near_subset_box L.val (by norm_num : (0:ℝ)<8*(1/100)) (c v)
+    (bump_support (by norm_num) (c v) (subset_closure hn.2))
+  have hd : dist (c z) (c v) ≤ (32:ℝ)/100 := by
+    apply (dist_pi_le_iff (by norm_num)).mpr
+    intro j
+    have hzj : dist (y j) (c z j) ≤ 2*(8*(1/100)) := Set.mem_univ_pi.mp hbz j
+    have hvj : dist (y j) (c v j) ≤ 2*(8*(1/100)) := Set.mem_univ_pi.mp hbv j
+    have ht := dist_triangle (c z j) (y j) (c v j)
+    rw [dist_comm (c z j) (y j)] at ht
+    linarith
+  linarith [hc z v hzv]
+
+lemma cutoff_partials_disjoint {S : Type*} {n : ℕ} {L : Length} (c : S → Torus L)
+    (hc : ∀ z v, z≠v → 1 ≤ dist (c z) (c v)) (h : ℝ) (z v : S) (hzv : z≠v)
+    (p : Direction n) (X : Configuration n L) :
+    coordDerivative n L (cutoff n L (1/100) (c z) h).toFun p X=0 ∨
+    coordDerivative n L (cutoff n L (1/100) (c v) h).toFun p X=0 := by
+  rcases bump_separated c hc z v hzv (X p.1) with hz | hv
+  · left
+    simp only [cutoff_partial,countMultiplier_partial,chiOne_partial,hz,Complex.ofReal_zero,mul_zero,zero_mul]
+  · right
+    simp only [cutoff_partial,countMultiplier_partial,chiOne_partial,hv,Complex.ofReal_zero,mul_zero,zero_mul]
+
+def joint {S : Type*} [DecidableEq S] (n : ℕ) (L : Length) (c : S → Torus L) (h : ℝ) (A : Finset S) :
+    SmoothMultiplier n L := SmoothMultiplier.finsetProd A (fun s ↦ cutoff n L (1/100) (c s) h)
+
+lemma joint_apply {S : Type*} [DecidableEq S] (n : ℕ) (L : Length) (c : S → Torus L)
+    (h : ℝ) (A : Finset S) (X : Configuration n L) :
+    (joint n L c h A).toFun X=(∏ s∈A, (profile h (count L (1/100) (c s) X) : ℂ)) := by
+  change (∏ s∈A, (cutoff n L (1/100) (c s) h).toFun X)=_
+  simp_rw [cutoff_apply]
+
+lemma joint_real {S : Type*} [DecidableEq S] (n : ℕ) (L : Length) (c : S → Torus L)
+    (h : ℝ) (A : Finset S) (X : Configuration n L) :
+    conj ((joint n L c h A).toFun X)=(joint n L c h A).toFun X := by
+  simp only [joint_apply,map_prod,Complex.conj_ofReal]
+
+lemma joint_partial {S : Type*} [DecidableEq S] (n : ℕ) (L : Length) (c : S → Torus L)
+    (h : ℝ) (A : Finset S) (p : Direction n) (X : Configuration n L) :
+    coordDerivative n L (joint n L c h A).toFun p X=
+      ∑ s∈A, (joint n L c h (A.erase s)).toFun X*
+        coordDerivative n L (cutoff n L (1/100) (c s) h).toFun p X := by
+  exact SmoothMultiplier.partial_finsetProd A _ p X
+
+lemma joint_gradient_le {S : Type*} [DecidableEq S] {n : ℕ} {L : Length} {h M : ℝ}
+    (hh : 0<h) (hM : 0 ≤ M) (hb : ∀ t : ℝ, |deriv Real.smoothTransition t| ≤ M)
+    (c : S → Torus L) (hc : ∀ z v, z≠v → 1 ≤ dist (c z) (c v))
+    (A : Finset S) (X : Configuration n L) :
+    (∑ p : Direction n, ‖coordDerivative n L (joint n L c h A).toFun p X‖^2) ≤
+      ((2*M^2*(3*(4*(24*Real.pi^2*M^2/(8*(1/100))^2))))/h)*
+        ∑ s∈A, ‖(joint n L c h (A.erase s)).toFun X‖^2 := by
+  have he (p : Direction n) :
+      ‖coordDerivative n L (joint n L c h A).toFun p X‖^2=
+      ∑ s∈A, ‖(joint n L c h (A.erase s)).toFun X‖^2*
+        ‖coordDerivative n L (cutoff n L (1/100) (c s) h).toFun p X‖^2 := by
+    rw [joint_partial,norm_sq_sum_of_disjoint]
+    · simp_rw [norm_mul,mul_pow]
+    · intro z hz v hv hzv
+      rcases cutoff_partials_disjoint c hc h z v hzv p X with h1 | h2
+      · exact Or.inl (by rw [h1,mul_zero])
+      · exact Or.inr (by rw [h2,mul_zero])
+  simp_rw [he]
+  rw [Finset.sum_comm]
+  simp_rw [← Finset.mul_sum]
+  rw [Finset.mul_sum]
+  apply Finset.sum_le_sum
+  intro s hs
+  calc
+    _ ≤ ‖(joint n L c h (A.erase s)).toFun X‖^2 * ((2*M^2*(3*(4*(24*Real.pi^2*M^2/(8*(1/100))^2))))/h) :=
+      mul_le_mul_of_nonneg_left (cutoff_gradient_le (δ:=1/100) (by norm_num) hh hM hb (c s) X) (sq_nonneg _)
+    _ = _ := mul_comm _ _
+
+end HardSphere.CellOrbital
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/Joint2.lean

@@ -0,0 +1,45 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Orbitals.Joint
+import OAI.Analysis.HardSphere.Geometry.CoeScalar
+
+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.CellOrbital
+open MeasureTheory Set Filter
+open scoped ComplexConjugate
+
+lemma joint_support {S : Type*} [DecidableEq S] {n : ℕ} {L : Length} {h : ℝ} (hh : 0<h)
+    (c : S → Torus L) (A : Finset S) (u : ScalarL2 n L) :
+    ∀ᵐ X ∂volume, ((joint n L c h A).onScalar u) X≠0 → ∀ s∈A, count L (1/100) (c s) X ≤ 2*h := by
+  filter_upwards [(joint n L c h A).coe_onScalar u] with X hX hu s hs
+  have hj : (joint n L c h A).toFun X≠0 := fun hz ↦ hu (by rw [hX,hz,zero_mul])
+  rw [joint_apply] at hj
+  have he : (profile h (count L (1/100) (c s) X) : ℂ)≠0 :=
+    (Finset.prod_ne_zero_iff.mp hj) s hs
+  by_contra hn
+  have hz := profile_zero hh (le_of_lt (not_le.mp hn))
+  exact he (by rw [hz,Complex.ofReal_zero])
+
+lemma joint_gradient_norm_le {S : Type*} [DecidableEq S] {n : ℕ} {L : Length} {h M : ℝ}
+    (hh : 0<h) (hM : 0 ≤ M) (hb : ∀ t : ℝ, |deriv Real.smoothTransition t| ≤ M)
+    (c : S → Torus L) (hc : ∀ z v, z≠v → 1 ≤ dist (c z) (c v))
+    (A : Finset S) (u : ScalarL2 n L) :
+    (∑ p : Direction n, ‖(joint n L c h A).derivativeScalar p u‖^2) ≤
+      ((2*M^2*(3*(4*(24*Real.pi^2*M^2/(8*(1/100))^2))))/h)*
+        ∑ s∈A, ‖(joint n L c h (A.erase s)).onScalar u‖^2 :=
+  SmoothMultiplier.gradient_norm_le A _ _ _ (joint_gradient_le hh hM hb c hc A) u
+
+end HardSphere.CellOrbital
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/JointEmptyScalar.lean

@@ -0,0 +1,97 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Orbitals.Joint2
+import OAI.Analysis.HardSphere.Geometry.FinsetEraseRecursion
+
+namespace OAI
+
+section
+section
+noncomputable section
+open MeasureTheory Filter Set
+open scoped ENNReal Topology BigOperators
+noncomputable section
+open scoped BigOperators ComplexConjugate
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Set
+open scoped ENNReal NNReal Topology BigOperators
+noncomputable section
+open MeasureTheory ProbabilityTheory Real Complex
+open scoped ENNReal ComplexConjugate
+open ProbabilityTheory
+namespace HardSphere.CellOrbital
+open MeasureTheory Set Filter PeriodicCutoff
+open scoped ComplexConjugate
+noncomputable section
+
+lemma joint_empty_onScalar {S : Type*} [DecidableEq S] {n : ℕ} {L : Length}
+    (c : S → Torus L) (h : ℝ) (u : ScalarL2 n L) : (joint n L c h ∅).onScalar u=u := by
+  apply Lp.ext
+  filter_upwards [(joint n L c h ∅).coe_onScalar u] with X hX
+  simpa only [joint_apply,Finset.prod_empty,one_mul] using hX
+
+theorem joint_low_counts : ∃ C B E G : ℝ, 0<C ∧ 0<B ∧ 0<E ∧ 0<G ∧
+    ∀ (S : Type) [DecidableEq S] (n : ℕ) (L : Length) (r : ℝ),
+      0<r → r ≤ 1/100 → 0<n → 1/100 ≤ L.val →
+    ∀ (g : Jet n L), IsGroundVector n L r g →
+    ∀ (c : S → Torus L), (∀ z v, z≠v → 1 ≤ dist (c z) (c v)) →
+    ∀ (k m : ℕ) (h : ℝ), 0<h → 2*h ≤ k → C*B*(k+m)*r^3 ≤ 1/4 →
+      0 < m*(energy g/(n:ℝ)-C*(E+B*(k+m)*r)) →
+    ∀ A : Finset S, ‖(joint n L c h A).onScalar g.1‖^2 ≤
+      (G/(h*(m*(energy g/(n:ℝ)-C*(E+B*(k+m)*r)))))^A.card := by
+  obtain ⟨C,B,E,hC,hB,hE,hdef⟩ := physical_deficiency
+  obtain ⟨M,hM,hb⟩ := exists_transition_bound
+  let G : ℝ := 2*M^2*(3*(4*(24*Real.pi^2*M^2/(8*(1/100))^2)))
+  have hG : 0<G := by dsimp [G]; positivity
+  refine ⟨C,B,E,G,hC,hB,hE,hG,?_⟩
+  intro S _ n L r hr hrd hn hL g hg c hc k m h hh hk hsmall hgap A
+  let γ : ℝ := m*(energy g/(n:ℝ)-C*(E+B*(k+m)*r))
+  have hγ : 0<γ := hgap
+  let q : ℝ := G/(h*γ)
+  have hq : 0 ≤ q := by dsimp [q]; positivity
+  change ‖(joint n L c h A).onScalar g.1‖^2 ≤ q^A.card
+  apply finset_erase_recursion (fun A ↦ ‖(joint n L c h A).onScalar g.1‖^2) q hq
+  · rw [joint_empty_onScalar,hg.2.2.1]
+    norm_num
+  · intro A hA
+    let : Nonempty A := hA.to_subtype
+    let u := (joint n L c h A).onJet g
+    have hu : u∈dirichletDomain n L r := (joint n L c h A).onJet_mem_domain hg.1
+    have hs : ∀ᵐ X ∂volume, u.1 X≠0 → ∀ z : A, count L (1/100) (c z) X ≤ k := by
+      filter_upwards [joint_support hh c A g.1] with X hX huX z
+      exact (hX huX z z.property).trans hk
+    have hp := hdef A n L r hr hrd hn hL g hg (fun z : A ↦ c z)
+      (fun z v hzv ↦ hc z v (fun he ↦ hzv (Subtype.ext he))) k m hsmall u hu hs
+    have hm := hg.smooth_multiplier_identity (joint n L c h A) (joint_real n L c h A)
+    have hbnd := joint_gradient_norm_le hh hM.le hb c hc A g.1
+    have hpen : γ*((A.card : ℝ)*‖(joint n L c h A).onScalar g.1‖^2) ≤
+        (G/h)*∑ s∈A, ‖(joint n L c h (A.erase s)).onScalar g.1‖^2 := by
+      calc
+        _ = m*Fintype.card A*(energy g/(n:ℝ)-C*(E+B*(k+m)*r))*‖u.1‖^2 := by
+          simp only [Fintype.card_coe,u,SmoothMultiplier.onJet_fst,γ]
+          ring
+        _ ≤ energy u-energy g*‖u.1‖^2 := hp
+        _ = ∑ p : Direction n, ‖(joint n L c h A).derivativeScalar p g.1‖^2 := hm
+        _ ≤ _ := hbnd
+    have hdiv := (le_div_iff₀ hγ).mpr (by simpa only [mul_comm γ] using hpen)
+    have he : ((G/h)*∑ s∈A, ‖(joint n L c h (A.erase s)).onScalar g.1‖^2)/γ =
+        q*∑ s∈A, ‖(joint n L c h (A.erase s)).onScalar g.1‖^2 := by
+      dsimp [q]
+      field_simp
+    simpa only [he] using hdiv
+
+end
+end HardSphere.CellOrbital
+
+noncomputable section
+open MeasureTheory Filter Set
+open scoped ENNReal Topology
+
+end
+end
+end
+end
+end
+end
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/OrbitalOperator.lean

@@ -0,0 +1,98 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Thermodynamics.OccupationBound
+
+namespace OAI
+
+section
+
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal BigOperators Topology
+namespace HardSphere
+
+namespace Orbital
+variable {N : ℕ} (hN : 0<N) {L : Length}
+
+lemma sliceIntegral_memLp (ψ : ScalarL2 N L) : MemLp (sliceIntegral hN ψ) 2 volume := by
+  have hf := ground_slice_memLp hN ψ
+  have ha := Phase.memLp_integral_norm hf
+  have hh : MemLp (fun Y ↦ ∫x : Torus L,ψ (insertFirst hN x Y)) 2 volume := by
+    refine ha.mono' hf.aestronglyMeasurable.integral_prod_right' ?_
+    exact Eventually.of_forall fun Y ↦ norm_integral_le_integral_norm _
+  exact hh.const_smul ((Real.sqrt (L.val^3))⁻¹ : ℝ)
+
+lemma map_ae (ψ : ScalarL2 N L) : (map hN ψ : Configuration (N-1) L→ℂ)=ᵐ[volume] sliceIntegral hN ψ :=
+  by
+  unfold map
+  exact MemLp.coeFn_toLp _
+
+lemma map_add (f g : ScalarL2 N L) : map hN (f+g)=map hN f+map hN g := by
+  apply Lp.ext
+  have hp := (bathFirst_preserving hN L).quasiMeasurePreserving.tendsto_ae.eventually (Lp.coeFn_add f g)
+  have hs := Measure.ae_ae_of_ae_prod hp
+  filter_upwards [map_ae hN (f+g),map_ae hN f,map_ae hN g,Lp.coeFn_add (map hN f) (map hN g),hs,
+    Phase.memLp_slices (ground_slice_memLp hN f),Phase.memLp_slices (ground_slice_memLp hN g)] with Y hh hf hg hsum hY hfi hgi
+  rw [hh,hsum]
+  change sliceIntegral hN (f+g) Y=(map hN f) Y+(map hN g) Y
+  rw [hf,hg]
+  unfold sliceIntegral
+  rw [←smul_add,←integral_add (hfi.integrable (by norm_num)) (hgi.integrable (by norm_num))]
+  congr 1
+  apply integral_congr_ae
+  exact hY
+
+lemma map_smul (c : ℂ) (f : ScalarL2 N L) : map hN (c • f)=c • map hN f := by
+  apply Lp.ext
+  have hp := (bathFirst_preserving hN L).quasiMeasurePreserving.tendsto_ae.eventually (Lp.coeFn_smul c f)
+  have hs := Measure.ae_ae_of_ae_prod hp
+  filter_upwards [map_ae hN (c•f),map_ae hN f,Lp.coeFn_smul c (map hN f),hs] with Y hh hf hc hY
+  rw [hh,hc]
+  change sliceIntegral hN (c•f) Y=c • (map hN f) Y
+  rw [hf]
+  change (Real.sqrt (L.val^3))⁻¹ • (∫x : Torus L,(c•f) (insertFirst hN x Y))=
+    c • ((Real.sqrt (L.val^3))⁻¹ • ∫x : Torus L,f (insertFirst hN x Y))
+  rw [integral_congr_ae hY]
+  simp only [Pi.smul_apply]
+  rw [integral_smul]
+  exact smul_comm _ _ _
+
+section
+attribute [local instance] scalarL2_addCommMonoid scalarL2_module
+
+def linear : ScalarL2 N L →ₗ[ℂ] ScalarL2 (N-1) L where
+  toFun := map hN
+  map_add' := map_add hN
+  map_smul' := map_smul hN
+
+lemma map_norm_sq (ψ : ScalarL2 N L) : ‖map hN ψ‖^2=occupation hN ψ := by
+  have hLp := L.property
+  rw [scalar_norm_sq_integral]
+  have hsi := integral_congr_ae ((map_ae hN ψ).fun_comp fun x ↦ ‖x‖^2)
+  simp only [Function.comp_def] at hsi
+  rw [hsi]
+  unfold sliceIntegral occupation
+  simp only [norm_smul,Real.norm_eq_abs,mul_pow,sq_abs,inv_pow,
+    integral_const_mul,Real.sq_sqrt (by positivity : 0≤L.val^3)]
+
+lemma map_norm_le (ψ : ScalarL2 N L) : ‖map hN ψ‖≤‖ψ‖ := by
+  have hh := (map_norm_sq hN ψ).trans_le (occupation_le_norm_sq hN ψ)
+  nlinarith [norm_nonneg (map hN ψ),norm_nonneg ψ]
+
+
+end
+
+lemma norm_sq (ψ : ScalarL2 N L) : ‖continuous hN ψ‖^2=occupation hN ψ := map_norm_sq hN ψ
+
+end Orbital
+
+lemma occupation_smul {N : ℕ} (hN : 0<N) {L : Length} (c : ℝ) (ψ : ScalarL2 N L) :
+    occupation hN (c • ψ)=c^2*occupation hN ψ := by
+  rw [←Orbital.norm_sq,←Orbital.norm_sq]
+  have hh := (Orbital.continuous hN (L:=L)).map_smul_of_tower c ψ
+  rw [hh,norm_smul,mul_pow,Real.norm_eq_abs,sq_abs]
+
+end HardSphere
+end
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/PhysicalOrbitalReference.lean

@@ -0,0 +1,89 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Comparison.PhysicalAffinity
+
+namespace OAI
+
+section
+
+noncomputable section
+open MeasureTheory ProbabilityTheory Set
+open scoped ENNReal BigOperators
+namespace HardSphere.Comparison
+variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y]
+
+def orbitalObservationEquiv : ((Y×X)×X)≃ᵐ(X×X×Y) where
+  toFun p := (p.1.2,p.2,p.1.1)
+  invFun p := ((p.2.2,p.1),p.2.1)
+  left_inv _ := rfl
+  right_inv _ := rfl
+  measurable_toFun := by change Measurable (fun p : (Y×X)×X ↦ (p.1.2,p.2,p.1.1)); fun_prop
+  measurable_invFun := by change Measurable (fun p : X×X×Y ↦ ((p.2.2,p.1),p.2.1)); fun_prop
+
+def tagBathSwapEquiv : ((X×Y)×X)≃ᵐ((Y×X)×X) where
+  toFun p := ((p.1.2,p.1.1),p.2)
+  invFun p := ((p.1.2,p.1.1),p.2)
+  left_inv _ := rfl
+  right_inv _ := rfl
+  measurable_toFun := by change Measurable (fun p : (X×Y)×X ↦ ((p.1.2,p.1.1),p.2)); fun_prop
+  measurable_invFun := by change Measurable (fun p : (Y×X)×X ↦ ((p.1.2,p.1.1),p.2)); fun_prop
+
+def orbitalSwapEquiv : ((Y×X)×X)≃ᵐ((Y×X)×X) where
+  toFun p := ((p.1.1,p.2),p.1.2)
+  invFun p := ((p.1.1,p.2),p.1.2)
+  left_inv _ := rfl
+  right_inv _ := rfl
+  measurable_toFun := by change Measurable (fun p : (Y×X)×X ↦ ((p.1.1,p.2),p.1.2)); fun_prop
+  measurable_invFun := by change Measurable (fun p : (Y×X)×X ↦ ((p.1.1,p.2),p.1.2)); fun_prop
+
+lemma tagBathSwap_preserving (μ : Measure X) (ν : Measure Y) [SFinite μ] [SFinite ν] :
+    MeasurePreserving (tagBathSwapEquiv (X:=X) (Y:=Y)) ((μ.prod ν).prod μ) ((ν.prod μ).prod μ) :=
+  (Measure.measurePreserving_swap (μ:=μ) (ν:=ν)).prod (MeasurePreserving.id μ)
+
+lemma physical_unrestricted_affinity {n : ℕ} (μ : Measure X) (ν : Measure (Fin n→X))
+    [IsFiniteMeasure μ] [IsFiniteMeasure ν]
+    (f : (Fin n→X)×X→ℝ) (hfm : Measurable f) (hf : MemLp f 2 (ν.prod μ))
+    (hf0 : ∀p,0 ≤ f p) :
+    let P := ((μ.prod ν).withDensity (fun p ↦ ENNReal.ofReal (f (p.2,p.1)^2))).prod μ
+    measureAffinity (P.map (cellObservation true)) (P.map (cellObservation false))=
+      ∫Y,(∫x,f (Y,x) ∂μ)^2 ∂ν := by
+  dsimp only
+  let P := ((μ.prod ν).withDensity (fun p ↦ ENNReal.ofReal (f (p.2,p.1)^2))).prod μ
+  let ξ := (ν.prod μ).prod μ
+  let g₁ := fun p : ((Fin n→X)×X)×X ↦ ENNReal.ofReal (f p.1^2)
+  let g₂ := fun p : ((Fin n→X)×X)×X ↦ ENNReal.ofReal (f (p.1.1,p.2)^2)
+  have hg₁ : Measurable g₁ := ((hfm.comp measurable_fst).pow_const 2).ennreal_ofReal
+  have hg₂ : Measurable g₂ := ((hfm.comp ((measurable_fst.comp measurable_fst).prodMk measurable_snd)).pow_const 2).ennreal_ofReal
+  have hD : P.map tagBathSwapEquiv=ξ.withDensity g₁ := by
+    dsimp only [P]
+    have hρ : Measurable (fun p : X×(Fin n→X) ↦ ENNReal.ofReal (f (p.2,p.1)^2)) := by fun_prop
+    rw [prod_withDensity_left hρ]
+    change (((μ.prod ν).prod μ).withDensity (g₁∘tagBathSwapEquiv)).map tagBathSwapEquiv=ξ.withDensity g₁
+    rw [map_density_comp _ _ tagBathSwapEquiv.measurable g₁ hg₁,(tagBathSwap_preserving μ ν).map_eq]
+  have hS : (ξ.withDensity g₁).map orbitalSwapEquiv=ξ.withDensity g₂ := by
+    change (ξ.withDensity (g₂∘orbitalSwapEquiv)).map orbitalSwapEquiv=ξ.withDensity g₂
+    rw [map_density_comp _ _ orbitalSwapEquiv.measurable g₂ hg₂]
+    change ((ξ.map (fun p ↦ ((p.1.1,p.2),p.1.2))).withDensity g₂)=_
+    rw [(swapLast_preserving μ ν).map_eq]
+  have he₁ : P.map (cellObservation true)=(ξ.withDensity g₁).map orbitalObservationEquiv := by
+    rw [←hD,Measure.map_map orbitalObservationEquiv.measurable tagBathSwapEquiv.measurable]
+    rfl
+  have he₂ : P.map (cellObservation false)=(ξ.withDensity g₂).map orbitalObservationEquiv := by
+    rw [←hS,←hD,Measure.map_map orbitalSwapEquiv.measurable tagBathSwapEquiv.measurable,
+      Measure.map_map orbitalObservationEquiv.measurable (orbitalSwapEquiv.measurable.comp tagBathSwapEquiv.measurable)]
+    rfl
+  have hi₁ : Integrable (fun p : ((Fin n→X)×X)×X ↦ f p.1^2) ξ :=
+    (memLp_two_iff_integrable_sq (hf.comp_fst μ).aestronglyMeasurable).1 (hf.comp_fst μ)
+  have hi₂ : Integrable (fun p : ((Fin n→X)×X)×X ↦ f (p.1.1,p.2)^2) ξ := by
+    have h := (hf.comp_fst μ).comp_measurePreserving (swapLast_preserving μ ν)
+    exact (memLp_two_iff_integrable_sq h.aestronglyMeasurable).1 h
+  have : IsFiniteMeasure (ξ.withDensity g₁) := isFiniteMeasure_withDensity_ofReal hi₁.2
+  have : IsFiniteMeasure (ξ.withDensity g₂) := isFiniteMeasure_withDensity_ofReal hi₂.2
+  change measureAffinity (P.map _) (P.map _)=_
+  rw [he₁,he₂,measureAffinity_map_equiv]
+  simpa only [one_mul] using full_affinity_square μ ν f hf hf0 1 (by norm_num)
+
+end HardSphere.Comparison
+end
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/Profile.lean

@@ -0,0 +1,107 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Orbitals.Chi2
+import OAI.Analysis.HardSphere.Geometry.RealComp
+
+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.CellOrbital
+open MeasureTheory Set Filter PeriodicCutoff TightCutoff
+open scoped ComplexConjugate
+
+def profile (h t : ℝ) : ℝ := 1-Real.smoothTransition (t/h-1)
+
+lemma profile_smooth (h : ℝ) : ContDiff ℝ ((⊤:ℕ∞):WithTop ℕ∞) (profile h) :=
+  contDiff_const.sub (Real.smoothTransition.contDiff.comp ((contDiff_id.div_const h).sub contDiff_const))
+
+lemma profile_bounds (h t : ℝ) : 0 ≤ profile h t ∧ profile h t ≤ 1 := by
+  unfold profile
+  constructor <;> linarith [Real.smoothTransition.nonneg (t/h-1),Real.smoothTransition.le_one (t/h-1)]
+
+lemma profile_one {h : ℝ} (hh : 0<h) {t : ℝ} (ht : t ≤ h) : profile h t=1 := by
+  rw [profile,Real.smoothTransition.zero_of_nonpos (by rw [sub_nonpos]; exact (div_le_one hh).mpr ht)]
+  ring
+
+lemma profile_zero {h : ℝ} (hh : 0<h) {t : ℝ} (ht : 2*h ≤ t) : profile h t=0 := by
+  rw [profile,Real.smoothTransition.one_of_one_le (by have hd := (le_div_iff₀ hh).mpr ht; linarith)]
+  ring
+
+lemma profile_deriv (h t : ℝ) : deriv (profile h) t= -deriv Real.smoothTransition (t/h-1)/h := by
+  have hd := (transition_derivative (t/h-1)).comp t (((hasDerivAt_id t).div_const h).sub_const 1)
+  have he := hd.const_sub 1
+  have heq : (fun x : ℝ ↦ 1 - (Real.smoothTransition ∘ fun x : ℝ ↦ id x / h - 1) x) = profile h := rfl
+  rw [heq] at he
+  rw [he.deriv]
+  ring
+
+lemma profile_deriv_zero {h : ℝ} (hh : 0<h) {t : ℝ} (ht : t∉Icc h (2*h)) :
+    deriv (profile h) t=0 := by
+  rw [profile_deriv,transition_deriv_eq_zero]
+  · simp
+  · intro hc
+    apply ht
+    constructor
+    · have hd := hc.1
+      have hv : 1 ≤ t/h := by linarith
+      exact (one_le_div hh).mp hv
+    · have hv : t/h ≤ 2 := by linarith [hc.2]
+      exact (div_le_iff₀ hh).mp hv
+
+lemma profile_deriv_bound {h M : ℝ} (hh : 0<h) (_hM : 0 ≤ M)
+    (hb : ∀ t : ℝ, |deriv Real.smoothTransition t| ≤ M) (t : ℝ) :
+    |deriv (profile h) t| ≤ M/h := by
+  rw [profile_deriv,abs_div,abs_neg,abs_of_pos hh]
+  exact div_le_div_of_nonneg_right (hb _) hh.le
+
+def cutoff (n : ℕ) (L : Length) (δ : ℝ) (x : Torus L) (h : ℝ) : SmoothMultiplier n L :=
+  (countMultiplier n L δ x).realComp (profile h) (profile_smooth h)
+
+lemma cutoff_apply (n : ℕ) (L : Length) (δ : ℝ) (x : Torus L) (h : ℝ) (X : Configuration n L) :
+    (cutoff n L δ x h).toFun X=(profile h (count L δ x X) : ℂ) := by
+  change (profile h ((countMultiplier n L δ x).toFun X).re : ℂ)=_
+  rw [countMultiplier_apply,Complex.ofReal_re]
+
+lemma cutoff_real (n : ℕ) (L : Length) (δ : ℝ) (x : Torus L) (h : ℝ) (X : Configuration n L) :
+    conj ((cutoff n L δ x h).toFun X)=(cutoff n L δ x h).toFun X := by
+  rw [cutoff_apply,Complex.conj_ofReal]
+
+lemma cutoff_partial (n : ℕ) (L : Length) (δ : ℝ) (x : Torus L) (h : ℝ)
+    (p : Direction n) (X : Configuration n L) :
+    coordDerivative n L (cutoff n L δ x h).toFun p X=
+      ((deriv (profile h) (count L δ x X) : ℝ) : ℂ)*coordDerivative n L (countMultiplier n L δ x).toFun p X := by
+  rw [cutoff,SmoothMultiplier.partial_realComp _ _ _ (countMultiplier_real n L δ x),
+    countMultiplier_apply,Complex.ofReal_re]
+
+lemma cutoff_gradient_le {n : ℕ} {L : Length} {δ h M : ℝ} (hδ : 0<δ) (hh : 0<h) (hM : 0 ≤ M)
+    (hb : ∀ t : ℝ, |deriv Real.smoothTransition t| ≤ M) (x : Torus L) (X : Configuration n L) :
+    (∑ p : Direction n, ‖coordDerivative n L (cutoff n L δ x h).toFun p X‖^2) ≤
+      (2*M^2*(3*(4*(24*Real.pi^2*M^2/(8*δ)^2))))/h := by
+  by_cases ht : count L δ x X∈Icc h (2*h)
+  · simp_rw [cutoff_partial,norm_mul,mul_pow,Complex.norm_real,Real.norm_eq_abs,sq_abs]
+    rw [← Finset.mul_sum]
+    have hb2 : (deriv (profile h) (count L δ x X))^2 ≤ (M/h)^2 := by
+      rw [← sq_abs (deriv _ _)]
+      exact (sq_le_sq₀ (abs_nonneg _) (by positivity)).mpr (profile_deriv_bound hh hM hb _)
+    calc
+      _ ≤ (M/h)^2*((3*(4*(24*Real.pi^2*M^2/(8*δ)^2)))*count L δ x X) :=
+        mul_le_mul hb2 (countMultiplier_gradient_le hδ hM hb x X)
+          (Finset.sum_nonneg fun _ _ ↦ sq_nonneg _) (by positivity)
+      _ ≤ (M/h)^2*((3*(4*(24*Real.pi^2*M^2/(8*δ)^2)))*(2*h)) := by gcongr; try exact ht.2
+      _ = _ := by field_simp
+  · simp_rw [cutoff_partial,profile_deriv_zero hh ht,Complex.ofReal_zero,zero_mul,norm_zero,
+      zero_pow (by norm_num : 2≠0),Finset.sum_const_zero]
+    positivity
+
+end HardSphere.CellOrbital
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/SelectedDeletion.lean

@@ -0,0 +1,142 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.FreePathExpectation
+import OAI.Analysis.HardSphere.Geometry.PathPermutation
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open scoped BigOperators
+namespace HardSphere
+
+def selectedPermutation {m n : ℕ} (S : Finset (Fin (m+n))) (hS : S.card=m) : Equiv.Perm (Fin (m+n)) := by
+  classical
+  have hc : Fintype.card {i : Fin (m+n) // i∉S}=n := by
+    simp [hS]
+  let eS : Fin m ≃ {i : Fin (m+n) //i∈S} := (S.equivFinOfCardEq hS).symm
+  let eT : Fin n ≃ {i : Fin (m+n) //i∉S} := (Fintype.equivFinOfCardEq hc).symm
+  exact (finSumFinEquiv (m:=m) (n:=n)).symm.trans
+    ((eS.sumCongr eT).trans (Equiv.sumCompl fun i : Fin (m+n) ↦ i∈S))
+
+lemma selectedPermutation_prod {m n : ℕ} (S : Finset (Fin (m+n))) (hS : S.card=m)
+    {M : Type*} [CommMonoid M] (f : Fin (m+n) → M) :
+    (∏ i : Fin m,f (selectedPermutation S hS (Fin.castAdd n i)))=∏i∈S,f i := by
+  classical
+  have he (i : Fin m) : selectedPermutation S hS (Fin.castAdd n i)=((S.equivFinOfCardEq hS).symm i).val := by
+    simp [selectedPermutation]
+  simp only [he]
+  exact ((S.equivFinOfCardEq hS).symm.prod_comp (fun i : S ↦ f i.val)).trans (Finset.prod_coe_sort S f)
+
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Topology
+open Wiener
+
+@[simp] lemma onePathAt_permute {n : ℕ} {L : Length} (σ : Equiv.Perm (Fin n))
+    (i : Fin n) (ω : ConfigurationPath n L) :
+    onePathAt i (permuteConfigurationPath σ ω)=onePathAt (σ i) ω := rfl
+
+@[simp] lemma onePathAt_split_left {m n : ℕ} {L : Length} (i : Fin m)
+    (ω : ConfigurationPath (m+n) L) :
+    onePathAt i (splitConfigurationPath m n L ω).1=onePathAt (Fin.castAdd n i) ω := rfl
+
+lemma selected_product_deletion : ∃ C : ℝ, 0<C ∧
+    ∀ (N : ℕ) (L : Length) (r t : ℝ), 0<r → 0<t →
+    (N:ℝ)*(2*Real.pi*r)^3≤L.val^3/2 →
+    ∀ u : Jet N L, IsGroundVector N L r u →
+    ∀ h : ConfigurationPath 1 L → ℝ≥0∞, Measurable h →
+    (∀ ω,h (reverseConfigurationPath 1 L ω)=h ω) →
+    ∀ S : Finset (Fin N),
+      (∫⁻ ω : ConfigurationPath N L, ∏i∈S,h (onePathAt i ω) ∂groundPathLaw N L r t u) ≤
+      ENNReal.ofReal (Real.exp (t*C*(S.card:ℝ)*(N:ℝ)*r/L.val^3))*
+        ∫⁻ X : Configuration N L, ∏i∈S,oneFreeExpectation t h (X i) ∂groundPositionLaw N L u := by
+  classical
+  obtain ⟨C,hC,hdel⟩ := groundPathLaw_deletion
+  refine ⟨C,hC,?_⟩
+  intro N L r t hr ht hs u hu h hh hrev S
+  have hc : S.card≤N := by simpa using Finset.card_le_univ S
+  obtain ⟨n,hn⟩ := Nat.exists_eq_add_of_le hc
+  generalize hm : S.card=m at hn
+  subst N
+  let σ := selectedPermutation S hm
+  let H : ConfigurationPath m L → ℝ≥0∞ := fun ω ↦ ∏i,h (onePathAt i ω)
+  have hH : Measurable H := pathProduct_measurable Finset.univ hh
+  have hHrev (ω : ConfigurationPath m L) : H (reverseConfigurationPath m L ω)=H ω := by
+    simp only [H,onePathAt_reverse,hrev]
+  have hD := hdel m n L r t hr ht hs u hu H hH hHrev
+  have hexp : (∫⁻ ω : ConfigurationPath (m+n) L,H (splitConfigurationPath m n L ω).1
+      ∂groundPathLaw (m+n) L r t u)=
+      ∫⁻ ω : ConfigurationPath (m+n) L,∏i∈S,h (onePathAt i ω) ∂groundPathLaw (m+n) L r t u := by
+    have hp := (groundPathLaw_permute u hu.2.1 r t σ).lintegral_comp
+      (hH.comp (splitConfigurationPath_continuous m n L).measurable.fst)
+    simp only [Function.comp_def] at hp
+    rw [←hp]
+    apply lintegral_congr
+    intro ω
+    simp only [H,onePathAt_split_left,onePathAt_permute]
+    exact selectedPermutation_prod S hm (fun i ↦ h (onePathAt i ω))
+  have hF (X : Configuration (m+n) L) :
+      freePathExpectation t H (splitConfiguration m n L X).1=
+        ∏i:Fin m,oneFreeExpectation t h (X (Fin.castAdd n i)) :=
+    free_product_expectation t hh _
+  have hM : Measurable (fun X : Configuration (m+n) L ↦
+      ∏i:Fin m,oneFreeExpectation t h (X (Fin.castAdd n i))) :=
+    Finset.measurable_prod Finset.univ fun i _ ↦ (oneFreeExpectation_measurable t hh).comp (measurable_pi_apply _)
+  have hpos : (∫⁻ X : Configuration (m+n) L,
+      freePathExpectation t H (splitConfiguration m n L X).1 ∂groundPositionLaw (m+n) L u)=
+      ∫⁻ X : Configuration (m+n) L,∏i∈S,oneFreeExpectation t h (X i) ∂groundPositionLaw (m+n) L u := by
+    simp only [hF]
+    rw [←(groundPositionLaw_permute u hu.2.1 σ).lintegral_comp hM]
+    apply lintegral_congr
+    intro X
+    exact selectedPermutation_prod S hm (fun i ↦ oneFreeExpectation t h (X i))
+  rw [hexp,hpos] at hD
+  simpa only [hm] using hD
+
+lemma ground_product_one_add : ∃ C : ℝ, 0<C ∧
+    ∀ (N : ℕ) (L : Length) (r t : ℝ), 0<r → 0<t →
+    (N:ℝ)*(2*Real.pi*r)^3≤L.val^3/2 →
+    ∀ u : Jet N L, IsGroundVector N L r u →
+    ∀ h : ConfigurationPath 1 L → ℝ≥0∞, Measurable h →
+    (∀ ω,h (reverseConfigurationPath 1 L ω)=h ω) →
+      (∫⁻ ω : ConfigurationPath N L, ∏i, (1+h (onePathAt i ω)) ∂groundPathLaw N L r t u) ≤
+        ∫⁻ X : Configuration N L, ∏i,(1+ENNReal.ofReal (Real.exp (t*C*(N:ℝ)*r/L.val^3))*
+          oneFreeExpectation t h (X i)) ∂groundPositionLaw N L u := by
+  classical
+  obtain ⟨C,hC,hdel⟩ := selected_product_deletion
+  refine ⟨C,hC,?_⟩
+  intro N L r t hr ht hs u hu h hh hrev
+  let a : ℝ≥0∞ := ENNReal.ofReal (Real.exp (t*C*(N:ℝ)*r/L.val^3))
+  have ha (S : Finset (Fin N)) :
+      ENNReal.ofReal (Real.exp (t*C*(S.card:ℝ)*(N:ℝ)*r/L.val^3))=a^S.card := by
+    rw [show t*C*(S.card:ℝ)*(N:ℝ)*r/L.val^3=(S.card:ℝ)*(t*C*(N:ℝ)*r/L.val^3) by ring,
+      Real.exp_nat_mul,ENNReal.ofReal_pow (Real.exp_nonneg _)]
+  have hb (S : Finset (Fin N)) : Measurable (fun X : Configuration N L ↦
+      ∏i∈S,a*oneFreeExpectation t h (X i)) :=
+    Finset.measurable_prod S fun i _ ↦ measurable_const.mul
+      ((oneFreeExpectation_measurable t hh).comp (measurable_pi_apply i))
+  simp only [Finset.prod_one_add]
+  rw [lintegral_finsetSum _ (fun S _ ↦ pathProduct_measurable S hh),
+    lintegral_finsetSum _ (fun S _ ↦ hb S)]
+  apply Finset.sum_le_sum
+  intro S _
+  calc
+    _ ≤ a^S.card*∫⁻ X : Configuration N L,∏i∈S,oneFreeExpectation t h (X i)
+        ∂groundPositionLaw N L u := by simpa only [ha] using hdel N L r t hr ht hs u hu h hh hrev S
+    _ = ∫⁻ X : Configuration N L,∏i∈S,a*oneFreeExpectation t h (X i) ∂groundPositionLaw N L u := by
+      have hM : Measurable (fun X : Configuration N L ↦ ∏i∈S,oneFreeExpectation t h (X i)) :=
+        Finset.measurable_prod S fun i _ ↦ (oneFreeExpectation_measurable t hh).comp (measurable_pi_apply i)
+      rw [←lintegral_const_mul _ hM]
+      apply lintegral_congr
+      intro X
+      simp only [Finset.prod_mul_distrib,Finset.prod_const]
+
+end HardSphere
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/Orbitals/StrongContractionLimitDense.lean

@@ -0,0 +1,35 @@
+import Mathlib
+
+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
+namespace HardSphere
+lemma strong_contraction_limit_of_dense {E F ι : Type*} [NormedAddCommGroup E]
+    [NormedSpace ℂ E] {l : Filter ι} (A : ι → E →L[ℂ] E) (B : E →L[ℂ] E)
+    (hA : ∀ t u, ‖A t u‖≤‖u‖) (hB : ∀ u, ‖B u‖≤‖u‖)
+    (f : F → E) (hf : DenseRange f)
+    (ht : ∀ y, Tendsto (fun t ↦ A t (f y)) l (𝓝 (B (f y)))) (u : E) :
+    Tendsto (fun t ↦ A t u) l (𝓝 (B u)) := by
+  rw [Metric.tendsto_nhds]
+  intro ε hε
+  obtain ⟨y,hy⟩ := hf.exists_dist_lt u (show 0<ε/3 by positivity)
+  filter_upwards [(Metric.tendsto_nhds.mp (ht y)) (ε/3) (by positivity)] with t ht
+  have h1 : dist (A t u) (A t (f y))≤dist u (f y) := by
+    simpa only [dist_eq_norm,map_sub] using hA t (u-f y)
+  have h2 : dist (B (f y)) (B u)≤dist (f y) u := by
+    simpa only [dist_eq_norm,map_sub] using hB (f y-u)
+  have htriangle := dist_triangle4 (A t u) (A t (f y)) (B (f y)) (B u)
+  rw [dist_comm (f y) u] at h2
+  linarith
+end HardSphere
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/CertificateUnion.lean

@@ -0,0 +1,60 @@
+import Mathlib
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory Set
+open scoped ENNReal NNReal BigOperators
+namespace HardSphere.FreeVisits
+
+lemma largest_fiber {V : Type*} [Fintype V] {q : ℕ} (hq : 0<q) (f : V→Fin q) :
+    ∃i : Fin q,Fintype.card V≤q*(Finset.univ.filter (fun v ↦ f v=i)).card := by
+  classical
+  have hq' : (0:ℝ)<q := by exact_mod_cast hq
+  have hf : ∀v∈(Finset.univ : Finset V),f v∈(Finset.univ : Finset (Fin q)) := by simp
+  have ht : (Finset.univ : Finset (Fin q)).Nonempty := ⟨⟨0,hq⟩,Finset.mem_univ _⟩
+  have hb : (Finset.univ : Finset (Fin q)).card • ((Fintype.card V:ℝ)/(q:ℝ))≤(Finset.univ : Finset V).card := by
+    simp only [Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
+    rw [mul_div_cancel₀ _ hq'.ne']
+  obtain ⟨i,hi,h⟩ := Finset.exists_le_card_fiber_of_nsmul_le_card_of_maps_to hf ht hb
+  refine ⟨i,?_⟩
+  have hh := (div_le_iff₀ hq').mp h
+  exact_mod_cast hh.trans_eq (mul_comm _ _)
+
+lemma finite_failure_union {W V : Type*} [MeasurableSpace W] [Fintype V]
+    (μ : Measure W) {q : ℕ} (hq : 0<q) (bad : Fin q→V→W→Prop)
+    {p : ℝ≥0∞} (hp : p≤1)
+    (hjoint : ∀i : Fin q,∀A : Finset V,μ {ω | ∀v∈A,bad i v ω}≤p^(q*A.card)) :
+    μ {ω | ∀v,∃i,bad i v ω}≤((q:ℝ≥0∞)*p)^(Fintype.card V) := by
+  classical
+  have hsub : {ω | ∀v,∃i,bad i v ω}⊆⋃f : V→Fin q,{ω | ∀v,bad (f v) v ω} := by
+    intro ω hω
+    let f : V→Fin q := fun v ↦ Classical.choose (hω v)
+    exact mem_iUnion.mpr ⟨f,fun v ↦ Classical.choose_spec (hω v)⟩
+  have hf (f : V→Fin q) : μ {ω | ∀v,bad (f v) v ω}≤p^(Fintype.card V) := by
+    obtain ⟨i,hi⟩ := largest_fiber hq f
+    calc
+      _ ≤ μ {ω | ∀v∈Finset.univ.filter (fun v ↦ f v=i),bad i v ω} := by
+        apply measure_mono
+        intro ω hω v hv
+        rw [←(Finset.mem_filter.mp hv).2]
+        exact hω v
+      _ ≤ p^(q*(Finset.univ.filter (fun v ↦ f v=i)).card) := hjoint i _
+      _ ≤ _ := pow_le_pow_right_of_le_one' hp hi
+  calc
+    _ ≤ μ (⋃f : V→Fin q,{ω | ∀v,bad (f v) v ω}) := measure_mono hsub
+    _ ≤ ∑f : V→Fin q,μ {ω | ∀v,bad (f v) v ω} := measure_iUnion_fintype_le _ _
+    _ ≤ ∑_f : V→Fin q,p^(Fintype.card V) := Finset.sum_le_sum (fun f _ ↦ hf f)
+    _ = _ := by simp [nsmul_eq_mul,mul_pow]
+
+end HardSphere.FreeVisits
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/CloseTailBaseTendsto.lean

@@ -0,0 +1,85 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Thermodynamics.SpatialCloseScale2
+
+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
+open MeasureTheory Filter Set
+open scoped ENNReal Topology
+open MeasureTheory Set
+open scoped ENNReal
+namespace HardSphere
+open MeasureTheory Set Filter
+open scoped Topology
+
+lemma closeTailBase_tendsto_zero (G b : ℝ) :
+    Tendsto (fun D : ℝ ↦ (G/b^2)*D^(-(4/3):ℝ)) atTop (𝓝 0) := by
+  simpa using (tendsto_rpow_neg_atTop (by norm_num : (0:ℝ)<4/3)).const_mul (G/b^2)
+
+lemma closeTailProbability_tendsto_zero (G b : ℝ) {Q : ℕ} (hQ : 0<Q) :
+    Tendsto (fun D : ℝ ↦ ((G/b^2)*D^(-(4/3):ℝ))^(1/(Q:ℝ))) atTop (𝓝 0) := by
+  have hQpos : (0:ℝ)<Q := by exact_mod_cast hQ
+  have he : (0:ℝ)<1/(Q:ℝ) := by positivity
+  have hc := (Real.continuous_rpow_const he.le).continuousAt.tendsto.comp (closeTailBase_tendsto_zero G b)
+  simpa only [Function.comp_def,Real.zero_rpow he.ne'] using hc
+
+lemma smallness_of_large_density {n : ℕ} (L : Length) {D α αmax : ℝ}
+    (hDeq : D=(n:ℝ)/L.val^3) (hD : 1≤D) (hα : 0≤α) (hαmax : α≤αmax)
+    (hlarge : 2*(2*Real.pi*αmax)^3≤D) :
+    (n:ℝ)*(2*Real.pi*(α/D))^3≤L.val^3/2 := by
+  have hDpos : 0<D := zero_lt_one.trans_le hD
+  have hL3 : 0<L.val^3 := pow_pos L.property _
+  have hn : (n:ℝ)=D*L.val^3 := ((eq_div_iff hL3.ne').mp hDeq).symm
+  have halpha : (2*Real.pi*α)^3≤(2*Real.pi*αmax)^3 := by gcongr
+  have hDsq : D≤D^2 := by nlinarith only [mul_le_mul_of_nonneg_left hD hDpos.le]
+  have hratio : (2*Real.pi*α)^3/D^2≤1/2 := by
+    apply (div_le_iff₀ (sq_pos_of_pos hDpos)).mpr
+    nlinarith only [halpha,hlarge,hDsq]
+  calc
+    _ = L.val^3*((2*Real.pi*α)^3/D^2) := by rw [hn]; field_simp
+    _ ≤ L.val^3*(1/2) := mul_le_mul_of_nonneg_left hratio hL3.le
+    _ = _ := by ring
+
+theorem spatial_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 : ℕ) [Nontrivial (Fin n)] (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 → ∀ A : Finset (CubeCell K),
+      groundPositionLaw n L g {X | ∀ v∈A, θ*D≤((localCloseLabels L (spatialCloseScale D b) (unitCenter L v) X).card:ℝ)}≤
+        ENNReal.ofReal (((((Gθ/b^2)*D^(-(4/3):ℝ))^(1/(Q:ℝ)))^A.card)) := by
+  obtain ⟨Q,hQ,htail⟩ := spatial_scaled_close_tail
+  refine ⟨Q,hQ,?_⟩
+  intro θ hθ
+  obtain ⟨b,Gθ,hb,hb1,hGθ,hfin⟩ := htail θ hθ
+  refine ⟨b,Gθ,hb,hb1,hGθ,closeTailProbability_tendsto_zero Gθ b hQ,?_⟩
+  intro αmax
+  have hev : ∀ᶠ D : ℝ in atTop, (Gθ/b^2)*D^(-(4/3):ℝ)<1 :=
+    (tendsto_order.1 (closeTailBase_tendsto_zero Gθ b)).2 1 zero_lt_one
+  obtain ⟨D₁,hD₁⟩ := eventually_atTop.1 hev
+  let D₀ : ℝ := max 1 (max D₁ (2*(2*Real.pi*αmax)^3))
+  refine ⟨D₀,le_max_left _ _,?_⟩
+  intro n K _ L hL D α hL100 hDeq hD₀ hα hαmax g hg A
+  have hD : 1≤D := (le_max_left _ _).trans hD₀
+  have hD1 : D₁≤D := (le_max_left _ _).trans ((le_max_right _ _).trans hD₀)
+  have hlarge : 2*(2*Real.pi*αmax)^3≤D := (le_max_right _ _).trans ((le_max_right _ _).trans hD₀)
+  have hDpos : 0<D := zero_lt_one.trans_le hD
+  have hαpos : 0<α := zero_lt_one.trans_le hα
+  have hprod : D*(α/D)=α := by field_simp
+  exact hfin n K L hL (α/D) D hL100 hDeq hD (by rwa [hprod]) (by positivity)
+    (smallness_of_large_density L hDeq hD hαpos.le hαmax hlarge) (hD₁ D hD1).le g hg A
+
+end HardSphere
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/ConfigurationTailLp.lean

@@ -0,0 +1,299 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.SmoothMultiplier
+
+namespace OAI
+
+section
+section
+noncomputable section
+open MeasureTheory Filter Set
+open scoped ENNReal Topology BigOperators
+noncomputable section
+open scoped BigOperators ComplexConjugate
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Set
+open scoped ENNReal NNReal Topology BigOperators
+noncomputable section
+open MeasureTheory ProbabilityTheory Real Complex
+open scoped ENNReal ComplexConjugate
+open ProbabilityTheory
+namespace HardSphere
+open MeasureTheory Set Filter
+open scoped ComplexConjugate
+noncomputable section
+
+lemma configurationTail_preserving (n : ℕ) (L : Length) :
+    MeasurePreserving (Fin.tail : Configuration (n+1) L → Configuration n L)
+      volume ((volume (Set.univ : Set (Torus L))) • (volume : Measure (Configuration n L))) := by
+  have h : MeasurePreserving (Prod.snd : Torus L × Configuration n L → Configuration n L)
+      volume ((volume (Set.univ : Set (Torus L))) • (volume : Measure (Configuration n L))) :=
+    ⟨measurable_snd,Measure.map_snd_prod⟩
+  simpa only [Function.comp_def,MeasurableEquiv.piFinSuccAbove_apply,Fin.zero_succAbove,Fin.insertNthEquiv_zero,Fin.consEquiv_symm_apply] using
+    h.comp (volume_preserving_piFinSuccAbove (fun _ : Fin (n+1) ↦ Torus L) 0)
+
+lemma configurationTail_quasiPreserving (n : ℕ) (L : Length) :
+    Measure.QuasiMeasurePreserving (Fin.tail : Configuration (n+1) L → Configuration n L)
+      volume volume := by
+  refine ⟨(configurationTail_preserving n L).measurable,?_⟩
+  rw [(configurationTail_preserving n L).map_eq]
+  exact Measure.smul_absolutelyContinuous
+
+lemma memLp_configurationTail {n : ℕ} {L : Length} {f : Configuration n L → ℂ}
+    (hf : MemLp f 2 volume) : MemLp (fun X : Configuration (n+1) L ↦ f (Fin.tail X)) 2 volume :=
+  (hf.smul_measure (measure_ne_top _ _)).comp_measurePreserving (configurationTail_preserving n L)
+
+def configurationTailLp {n : ℕ} {L : Length} (u : ScalarL2 n L) : ScalarL2 (n+1) L :=
+  (memLp_configurationTail (Lp.memLp u)).toLp _
+
+lemma coe_configurationTailLp {n : ℕ} {L : Length} (u : ScalarL2 n L) :
+    configurationTailLp u =ᵐ[volume] fun X ↦ u (Fin.tail X) := MemLp.coeFn_toLp _
+
+def configurationTailLinear (n : ℕ) (L : Length) : ScalarL2 n L →ₗ[ℂ] ScalarL2 (n+1) L where
+  toFun := configurationTailLp
+  map_add' u v := by
+    apply Lp.ext
+    filter_upwards [coe_configurationTailLp (u+v),coe_configurationTailLp u,coe_configurationTailLp v,
+      (configurationTail_quasiPreserving n L).ae_eq_comp (Lp.coeFn_add u v),
+      Lp.coeFn_add (configurationTailLp u) (configurationTailLp v)] with X h1 h2 h3 h4 h5
+    simp only [Function.comp_def,Pi.add_apply] at h4
+    rw [h1,h4,h5,Pi.add_apply,h2,h3]
+  map_smul' c u := by
+    apply Lp.ext
+    filter_upwards [coe_configurationTailLp (c • u),coe_configurationTailLp u,
+      (configurationTail_quasiPreserving n L).ae_eq_comp (Lp.coeFn_smul c u),
+      Lp.coeFn_smul c (configurationTailLp u)] with X h1 h2 h3 h4
+    simp only [Function.comp_def,Pi.smul_apply] at h3
+    simp only [h1,h3,h4,Pi.smul_apply,h2,RingHom.id_apply]
+
+lemma norm_configurationTailLp {n : ℕ} {L : Length} (u : ScalarL2 n L) :
+    ‖configurationTailLp u‖ = (volume (Set.univ : Set (Torus L)) ^ (1 / (2:ℝ))).toReal * ‖u‖ := by
+  rw [configurationTailLp,Lp.norm_toLp]
+  have he := eLpNorm_comp_measurePreserving (p:= (2:ℝ≥0∞))
+    ((Lp.stronglyMeasurable u).aestronglyMeasurable
+      (μ := volume univ • (volume : Measure (Configuration n L)))) (configurationTail_preserving n L)
+  simp only [Function.comp_def] at he
+  rw [he]
+  have hv : volume (Set.univ : Set (Torus L))≠0 := Measure.measure_univ_ne_zero.mpr (NeZero.ne volume)
+  rw [eLpNorm_smul_measure_of_ne_zero hv,smul_eq_mul,ENNReal.toReal_mul,Lp.norm_def]
+  congr 2
+  norm_num
+
+def configurationTailCLM (n : ℕ) (L : Length) : ScalarL2 n L →L[ℂ] ScalarL2 (n+1) L :=
+  (configurationTailLinear n L).mkContinuous
+    (volume (Set.univ : Set (Torus L)) ^ (1 / (2:ℝ))).toReal
+    (fun u ↦ (norm_configurationTailLp u).le)
+
+lemma coe_configurationTailCLM {n : ℕ} {L : Length} (u : ScalarL2 n L) :
+    configurationTailCLM n L u =ᵐ[volume] fun X ↦ u (Fin.tail X) := coe_configurationTailLp u
+
+end
+end HardSphere
+
+namespace HardSphere
+open MeasureTheory Set Filter
+open scoped ComplexConjugate
+noncomputable section
+
+def tailLift (n : ℕ) : LiftedConfiguration (n+1) →L[ℝ] LiftedConfiguration n :=
+  .pi fun i ↦ .proj i.succ
+
+lemma tailLift_direction_zero (n : ℕ) (j : Fin 3) :
+    tailLift n (Pi.single 0 (Pi.single j 1))=0 := by
+  ext i k
+  simp [tailLift]
+
+lemma tailLift_direction_succ (n : ℕ) (i : Fin n) (j : Fin 3) :
+    tailLift n (Pi.single i.succ (Pi.single j 1))=Pi.single i (Pi.single j 1) := by
+  ext k q
+  by_cases h : k=i
+  · subst k; simp [tailLift]
+  · simp [tailLift,Pi.single_eq_of_ne h,Pi.single_eq_of_ne (fun h' ↦ h (Fin.succ_injective _ h'))]
+
+lemma smooth_tail {n : ℕ} {L : Length} {f : Configuration n L → ℂ}
+    (hf : ContDiff ℝ ((⊤:ℕ∞):WithTop ℕ∞) (fun X : LiftedConfiguration n ↦ f (project n L X))) :
+    ContDiff ℝ ((⊤:ℕ∞):WithTop ℕ∞)
+      (fun X : LiftedConfiguration (n+1) ↦ f (Fin.tail (project (n+1) L X))) :=
+  hf.comp (tailLift n).contDiff
+
+lemma coordDerivative_tail_zero {n : ℕ} {L : Length} {f : Configuration n L → ℂ}
+    (hf : Differentiable ℝ (fun X : LiftedConfiguration n ↦ f (project n L X))) (j : Fin 3) :
+    coordDerivative (n+1) L (fun X ↦ f (Fin.tail X)) (0,j)=0 := by
+  funext X
+  have h := (hf (tailLift n (representative (n+1) L X))).hasFDerivAt.comp
+    (representative (n+1) L X) (tailLift n).hasFDerivAt
+  change (fderiv ℝ ((fun Y : LiftedConfiguration n ↦ f (project n L Y)) ∘ tailLift n)
+    (representative (n+1) L X)) (Pi.single 0 (Pi.single j 1))=0
+  rw [h.fderiv,ContinuousLinearMap.comp_apply,tailLift_direction_zero,map_zero]
+
+lemma coordDerivative_tail_succ {n : ℕ} {L : Length} {f : Configuration n L → ℂ}
+    (hf : Differentiable ℝ (fun X : LiftedConfiguration n ↦ f (project n L X)))
+    (i : Fin n) (j : Fin 3) :
+    coordDerivative (n+1) L (fun X ↦ f (Fin.tail X)) (i.succ,j)=
+      fun X ↦ coordDerivative n L f (i,j) (Fin.tail X) := by
+  funext X
+  have h := (hf (tailLift n (representative (n+1) L X))).hasFDerivAt.comp
+    (representative (n+1) L X) (tailLift n).hasFDerivAt
+  change (fderiv ℝ ((fun Y : LiftedConfiguration n ↦ f (project n L Y)) ∘ tailLift n)
+    (representative (n+1) L X)) (Pi.single i.succ (Pi.single j 1))=_
+  rw [h.fderiv,ContinuousLinearMap.comp_apply,tailLift_direction_succ]
+  rfl
+
+lemma allowed_of_tail {n : ℕ} {L : Length} {a : ℝ} {X : Configuration (n+1) L}
+    (htail : Fin.tail X∈allowed n L a)
+    (hhead : ∀ i : Fin n, a<torusDistance L (X 0) (X i.succ)) :
+    X∈allowed (n+1) L a := by
+  intro i
+  refine Fin.cases ?_ (fun k ↦ ?_) i
+  · intro j hij
+    exact Fin.cases (fun h ↦ (lt_irrefl _ h).elim) (fun k _ ↦ hhead k) j hij
+  · intro j hij
+    exact Fin.cases (fun h ↦ (Fin.not_lt_zero _ h).elim)
+      (fun l h ↦ htail k l (Fin.succ_lt_succ_iff.mp h)) j hij
+
+def InsertionClearance {n : ℕ} {L : Length} (a : ℝ) (f : SmoothMultiplier (n+1) L) : Prop :=
+  tsupport f.toFun ⊆ {X | ∀ i : Fin n, a<torusDistance L (X 0) (X i.succ)}
+
+def SmoothTest.insert {n : ℕ} {L : Length} {a : ℝ} (g : SmoothTest n L a)
+    (f : SmoothMultiplier (n+1) L) (hc : InsertionClearance a f) : SmoothTest (n+1) L a where
+  toFun := fun X ↦ f.toFun X * g.toFun (Fin.tail X)
+  smooth := f.smooth.mul (smooth_tail g.smooth)
+  compact := HasCompactSupport.of_compactSpace _
+  support_allowed := by
+    intro X hX
+    have hf : X∈tsupport f.toFun := tsupport_mul_subset_left hX
+    have hg : X∈tsupport (fun X : Configuration (n+1) L ↦ g.toFun (Fin.tail X)) :=
+      tsupport_mul_subset_right hX
+    have htail : Fin.tail X∈tsupport g.toFun := by
+      exact (tsupport_comp_subset_preimage g.toFun
+        (f := (Fin.tail : Configuration (n+1) L → Configuration n L))
+        (continuous_pi fun i ↦ continuous_apply i.succ)) hg
+    exact allowed_of_tail (g.support_allowed htail) (hc hf)
+  memLp := f.memLp_top.mul (memLp_configurationTail g.memLp)
+  partial_memLp := by
+    rintro ⟨i,j⟩
+    rw [show (fun X ↦ f.toFun X*g.toFun (Fin.tail X))=f.toFun*(fun X ↦ g.toFun (Fin.tail X)) from rfl,
+      coordDerivative_mul (f.smooth.differentiable (by simp)) ((smooth_tail g.smooth).differentiable (by simp))]
+    apply MemLp.add
+    · refine Fin.cases ?_ (fun k ↦ ?_) i
+      · rw [coordDerivative_tail_zero (g.smooth.differentiable (by simp))]
+        simp
+      · rw [coordDerivative_tail_succ (g.smooth.differentiable (by simp))]
+        exact f.memLp_top.mul (memLp_configurationTail (g.partial_memLp (k,j)))
+    · exact (memLp_configurationTail g.memLp).mul (f.partial_memLp_top (i,j))
+
+def insertionParentDerivative (n : ℕ) (L : Length) (p : Direction (n+1)) :
+    Jet n L →L[ℂ] ScalarL2 n L :=
+  Fin.cases 0 (fun i ↦ (ContinuousLinearMap.proj (i,p.2)).comp (.snd ℂ _ _)) p.1
+
+def SmoothMultiplier.insertionScalar {n : ℕ} {L : Length} (f : SmoothMultiplier (n+1) L) :
+    ScalarL2 n L →L[ℂ] ScalarL2 (n+1) L :=
+  f.onScalar.comp (configurationTailCLM n L)
+
+def SmoothMultiplier.insertionJet {n : ℕ} {L : Length} (f : SmoothMultiplier (n+1) L) :
+    Jet n L →L[ℂ] Jet (n+1) L :=
+  (f.insertionScalar.comp (.fst ℂ _ _)).prod (.pi fun p ↦
+    f.insertionScalar.comp (insertionParentDerivative n L p) +
+    ((L2Multiplier.clm _ (f.partial_memLp_top p)).comp (configurationTailCLM n L)).comp (.fst ℂ _ _))
+
+lemma coe_insertionScalar {n : ℕ} {L : Length} (f : SmoothMultiplier (n+1) L) (u : ScalarL2 n L) :
+    f.insertionScalar u =ᵐ[volume] fun X ↦ f.toFun X*u (Fin.tail X) := by
+  filter_upwards [coe_configurationTailCLM u,L2Multiplier.coe_clm f.toFun f.memLp_top (configurationTailCLM n L u)]
+    with X h1 h2
+  exact h2.trans (by rw [h1])
+
+lemma coe_insertionParentDerivative {n : ℕ} {L : Length} (u : Jet n L) (p : Direction (n+1)) :
+    insertionParentDerivative n L p u = Fin.cases 0 (fun i ↦ u.2 (i,p.2)) p.1 := by
+  rcases p with ⟨p,j⟩
+  cases p using Fin.cases <;> rfl
+
+lemma coe_insertionJet_zero {n : ℕ} {L : Length} (f : SmoothMultiplier (n+1) L)
+    (u : Jet n L) (j : Fin 3) :
+    (f.insertionJet u).2 (0,j) =ᵐ[volume]
+      fun X ↦ coordDerivative (n+1) L f.toFun (0,j) X*u.1 (Fin.tail X) := by
+  change (f.insertionScalar 0+L2Multiplier.clm _ (f.partial_memLp_top (0,j))
+    (configurationTailCLM n L u.1)) =ᵐ[volume] _
+  rw [map_zero,zero_add]
+  filter_upwards [coe_configurationTailCLM u.1,
+    L2Multiplier.coe_clm _ (f.partial_memLp_top (0,j)) (configurationTailCLM n L u.1)] with X h1 h2
+  exact h2.trans (by rw [h1])
+
+lemma coe_insertionJet_succ {n : ℕ} {L : Length} (f : SmoothMultiplier (n+1) L)
+    (u : Jet n L) (i : Fin n) (j : Fin 3) :
+    (f.insertionJet u).2 (i.succ,j) =ᵐ[volume]
+      fun X ↦ f.toFun X*u.2 (i,j) (Fin.tail X)+
+        coordDerivative (n+1) L f.toFun (i.succ,j) X*u.1 (Fin.tail X) := by
+  change (f.insertionScalar (u.2 (i,j))+L2Multiplier.clm _ (f.partial_memLp_top (i.succ,j))
+    (configurationTailCLM n L u.1)) =ᵐ[volume] _
+  filter_upwards [coe_insertionScalar f (u.2 (i,j)),coe_configurationTailCLM u.1,
+    L2Multiplier.coe_clm _ (f.partial_memLp_top (i.succ,j)) (configurationTailCLM n L u.1),
+    Lp.coeFn_add (f.insertionScalar (u.2 (i,j)))
+      (L2Multiplier.clm _ (f.partial_memLp_top (i.succ,j)) (configurationTailCLM n L u.1))]
+      with X h1 h2 h3 h4
+  rw [h4,Pi.add_apply,h1,h3,h2]
+
+lemma SmoothTest.jet_insert {n : ℕ} {L : Length} {a : ℝ} (g : SmoothTest n L a)
+    (f : SmoothMultiplier (n+1) L) (hc : InsertionClearance a f) :
+    (g.insert f hc).jet=f.insertionJet g.jet := by
+  apply Prod.ext
+  · apply Lp.ext
+    filter_upwards [MemLp.coeFn_toLp (g.insert f hc).memLp,
+      (configurationTail_quasiPreserving n L).ae_eq_comp (MemLp.coeFn_toLp g.memLp),
+      coe_insertionScalar f g.jet.1] with X h1 h2 h3
+    dsimp only [Function.comp_def] at h2
+    change ((g.insert f hc).jet.1) X=(f.insertionScalar g.jet.1) X
+    rw [h3]
+    dsimp only [SmoothTest.jet]
+    rw [h1,h2]
+    rfl
+  · funext p
+    rcases p with ⟨i,j⟩
+    refine Fin.cases ?_ (fun k ↦ ?_) i
+    · apply Lp.ext
+      filter_upwards [MemLp.coeFn_toLp ((g.insert f hc).partial_memLp (0,j)),
+        (configurationTail_quasiPreserving n L).ae_eq_comp (MemLp.coeFn_toLp g.memLp),
+        coe_insertionJet_zero f g.jet j] with X h1 h2 h3
+      dsimp only [Function.comp_def] at h2
+      rw [h3]
+      dsimp only [SmoothTest.jet]
+      rw [h1]
+      change coordDerivative (n+1) L (f.toFun*(fun X ↦ g.toFun (Fin.tail X))) (0,j) X=_
+      rw [coordDerivative_mul (f.smooth.differentiable (by simp))
+        ((smooth_tail g.smooth).differentiable (by simp)),
+        coordDerivative_tail_zero (g.smooth.differentiable (by simp))]
+      simp only [Pi.add_apply,Pi.mul_apply,Pi.zero_apply,mul_zero,zero_add,h2]
+      ring
+    · apply Lp.ext
+      filter_upwards [MemLp.coeFn_toLp ((g.insert f hc).partial_memLp (k.succ,j)),
+        (configurationTail_quasiPreserving n L).ae_eq_comp (MemLp.coeFn_toLp g.memLp),
+        (configurationTail_quasiPreserving n L).ae_eq_comp (MemLp.coeFn_toLp (g.partial_memLp (k,j))),
+        coe_insertionJet_succ f g.jet k j] with X h1 h2 h3 h4
+      dsimp only [Function.comp_def] at h2 h3
+      rw [h4]
+      dsimp only [SmoothTest.jet]
+      rw [h1]
+      change coordDerivative (n+1) L (f.toFun*(fun X ↦ g.toFun (Fin.tail X))) (k.succ,j) X=_
+      rw [coordDerivative_mul (f.smooth.differentiable (by simp))
+        ((smooth_tail g.smooth).differentiable (by simp)),
+        coordDerivative_tail_succ (g.smooth.differentiable (by simp))]
+      simp only [Pi.add_apply,Pi.mul_apply,h2,h3]
+      ring
+
+lemma SmoothMultiplier.insertionJet_mem_domain {n : ℕ} {L : Length} {a : ℝ}
+    (f : SmoothMultiplier (n+1) L) (hc : InsertionClearance a f)
+    {u : Jet n L} (hu : u∈dirichletDomain n L a) :
+    f.insertionJet u∈dirichletDomain (n+1) L a := by
+  apply map_mem_closure f.insertionJet.continuous hu
+  rintro _ ⟨g,rfl⟩
+  exact ⟨g.insert f hc,g.jet_insert f hc⟩
+
+end
+end HardSphere
+
+end
+end
+end
+end
+end
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/ExpNatTail.lean

@@ -0,0 +1,247 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Bridges.WienerGaussian
+import OAI.Analysis.HardSphere.PathBounds.FreeVisitProbability
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory Set
+open scoped ENNReal NNReal BigOperators
+namespace HardSphere.FreeVisits
+
+lemma exp_block_sum_bound (C J : ℕ) (hC : 0<C) {η : ℝ} (hη : 0≤η) :
+    ENNReal.ofReal (Real.exp (η*(J:ℝ))) ≤ 1 + ∑' k : ℕ,
+      if C*k<J then ENNReal.ofReal (Real.exp (η*(C:ℝ)*((k:ℝ)+1))) else 0 := by
+  by_cases hJ : J=0
+  · simp [hJ]
+  · let k := (J-1)/C
+    have hk : C*k<J := (Nat.mul_div_le (J-1) C).trans_lt (by omega)
+    have hJle : J≤C*(k+1) := by
+      have h:=Nat.lt_mul_div_succ (J-1) hC
+      dsimp [k]
+      omega
+    have he : ENNReal.ofReal (Real.exp (η*(J:ℝ))) ≤
+        ENNReal.ofReal (Real.exp (η*(C:ℝ)*((k:ℝ)+1))) := by
+      apply ENNReal.ofReal_le_ofReal
+      apply Real.exp_le_exp.mpr
+      have hJle' : (J:ℝ)≤(C:ℝ)*((k:ℝ)+1) := by exact_mod_cast hJle
+      nlinarith
+    have hs : ENNReal.ofReal (Real.exp (η*(C:ℝ)*((k:ℝ)+1))) ≤ ∑' j : ℕ,
+        if C*j<J then ENNReal.ofReal (Real.exp (η*(C:ℝ)*((j:ℝ)+1))) else 0 := by
+      simpa only [ite_eq_left hk] using (ENNReal.le_tsum (f:=fun j : ℕ ↦ if C*j<J then
+        ENNReal.ofReal (Real.exp (η*(C:ℝ)*((j:ℝ)+1))) else 0) k)
+    exact he.trans (hs.trans le_add_self)
+
+lemma weighted_exp_tail_le (C k : ℕ) (η : ℝ) :
+    Real.exp (η*(C:ℝ)*((k:ℝ)+1)) * (k:ℝ) *
+      Real.exp (-(η*(C:ℝ)+2)*(k:ℝ)) ≤
+    Real.exp (η*(C:ℝ)) * Real.exp (-1)^k := by
+  rw [← Real.exp_nat_mul]
+  have hk : (k:ℝ)≤Real.exp (k:ℝ) := by have := Real.add_one_le_exp (k:ℝ); linarith
+  calc
+    _ = (k:ℝ)*Real.exp (η*(C:ℝ)-2*(k:ℝ)) := by
+      rw [mul_right_comm,mul_comm _ (k:ℝ),←Real.exp_add]
+      congr 2
+      ring
+    _ ≤ Real.exp (k:ℝ)*Real.exp (η*(C:ℝ)-2*(k:ℝ)) := mul_le_mul_of_nonneg_right hk (Real.exp_nonneg _)
+    _ = _ := by rw [←Real.exp_add,←Real.exp_add]; congr 1; ring
+
+def expTailBound (C : ℕ) (η : ℝ) (a : ℝ≥0∞) : ℝ≥0∞ :=
+  1+(ENNReal.ofReal (Real.exp (η*(C:ℝ)))+
+       ENNReal.ofReal (Real.exp (η*(C:ℝ)))*a)*(1-ENNReal.ofReal (Real.exp (-1)))⁻¹
+
+lemma expTailBound_ne_top (C : ℕ) (η : ℝ) {a : ℝ≥0∞} (ha : a≠⊤) :
+    expTailBound C η a≠⊤ := by
+  have hr : ENNReal.ofReal (Real.exp (-1))<1 := by
+    rw [ENNReal.ofReal_lt_one]
+    exact Real.exp_lt_one_iff.mpr (by norm_num)
+  exact ENNReal.add_ne_top.mpr ⟨by simp, ENNReal.mul_ne_top
+    (ENNReal.add_ne_top.mpr ⟨ENNReal.ofReal_ne_top,ENNReal.mul_ne_top ENNReal.ofReal_ne_top ha⟩)
+    (ENNReal.inv_ne_top.mpr (tsub_pos_iff_lt.mpr hr).ne')⟩
+
+lemma lintegral_exp_nat_le {Ω : Type*} [MeasurableSpace Ω]
+    (μ : Measure Ω) [IsProbabilityMeasure μ] (F : Ω → ℕ) (hF : Measurable F)
+    (C : ℕ) (hC : 0<C) {η : ℝ} (hη : 0≤η) (a : ℝ≥0∞)
+    (htail : ∀ k : ℕ, 0<k → μ {w | C*k<F w} ≤
+      (k:ℝ≥0∞)*a*ENNReal.ofReal (Real.exp (-(η*(C:ℝ)+2)*(k:ℝ)))) :
+    ∫⁻ w, ENNReal.ofReal (Real.exp (η*(F w:ℝ))) ∂μ ≤ expTailBound C η a := by
+  classical
+  let W : ℕ → Ω → ℝ≥0∞ := fun k ↦
+    {w | C*k<F w}.indicator (fun _ ↦ ENNReal.ofReal (Real.exp (η*(C:ℝ)*((k:ℝ)+1))))
+  have hW (k : ℕ) : Measurable (W k) := measurable_const.indicator
+    (measurableSet_lt measurable_const hF)
+  have hweight (index : ℕ) (sample : Ω) :
+      W index sample = if C*index<F sample then
+        ENNReal.ofReal (Real.exp (η*(C:ℝ)*((index:ℝ)+1))) else 0 := by
+    by_cases hindex : C*index<F sample <;> simp [W,hindex]
+  have hterm (k : ℕ) : (∫⁻ w,W k w ∂μ) ≤
+      (ENNReal.ofReal (Real.exp (η*(C:ℝ)))+ENNReal.ofReal (Real.exp (η*(C:ℝ)))*a)*
+        ENNReal.ofReal (Real.exp (-1))^k := by
+    rw [show (∫⁻ w,W k w ∂μ) = ENNReal.ofReal (Real.exp (η*(C:ℝ)*((k:ℝ)+1))) * μ {w | C*k<F w} from
+      lintegral_indicator_const (measurableSet_lt measurable_const hF) _]
+    by_cases hk : k=0
+    · subst k
+      simpa only [Nat.cast_zero,zero_add,mul_one,pow_zero] using
+        (mul_le_mul_right (prob_le_one (μ:=μ))
+          (ENNReal.ofReal (Real.exp (η*(C:ℝ))))).trans (by simp)
+    · have hb := htail k (Nat.pos_of_ne_zero hk)
+      calc
+        _ ≤ ENNReal.ofReal (Real.exp (η*(C:ℝ)*((k:ℝ)+1))) *
+          ((k:ℝ≥0∞)*a*ENNReal.ofReal (Real.exp (-(η*(C:ℝ)+2)*(k:ℝ)))) := mul_le_mul_right hb _
+        _ = a*ENNReal.ofReal (Real.exp (η*(C:ℝ)*((k:ℝ)+1))*(k:ℝ)*Real.exp (-(η*(C:ℝ)+2)*(k:ℝ))) := by
+          simp only [ENNReal.ofReal_mul (Real.exp_nonneg _), ENNReal.ofReal_mul (mul_nonneg (Real.exp_nonneg _) (Nat.cast_nonneg k)),ENNReal.ofReal_natCast]
+          ring
+        _ ≤ a*ENNReal.ofReal (Real.exp (η*(C:ℝ))*Real.exp (-1)^k) :=
+          mul_le_mul_right (ENNReal.ofReal_le_ofReal (weighted_exp_tail_le C k η)) _
+        _ ≤ _ := by
+          rw [ENNReal.ofReal_mul (Real.exp_nonneg _),ENNReal.ofReal_pow (Real.exp_nonneg _)]
+          calc
+            _ = (ENNReal.ofReal (Real.exp (η*(C:ℝ)))*a)*ENNReal.ofReal (Real.exp (-1))^k := by ring
+            _ ≤ _ := by gcongr; exact le_add_self
+  calc
+    _ ≤ ∫⁻ w,1+∑' k,W k w ∂μ := lintegral_mono (fun w ↦ by
+      simpa only [hweight] using exp_block_sum_bound C (F w) hC hη)
+    _ = 1+∑' k,∫⁻ w,W k w ∂μ := by rw [lintegral_add_left measurable_const,lintegral_const,measure_univ,mul_one,lintegral_tsum (fun k ↦ (hW k).aemeasurable)]
+    _ ≤ 1+∑' k,(ENNReal.ofReal (Real.exp (η*(C:ℝ)))+ENNReal.ofReal (Real.exp (η*(C:ℝ)))*a)*ENNReal.ofReal (Real.exp (-1))^k :=
+      add_le_add_right (ENNReal.tsum_le_tsum hterm) _
+    _ = _ := by rw [ENNReal.tsum_mul_left,ENNReal.tsum_geometric]; rfl
+
+end HardSphere.FreeVisits
+
+end
+
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.FreeVisits
+open HardSphere.Wiener HardSphere.Lattice HardSphere.CellOrbital HardSphere.BathSlice
+attribute [local irreducible] freeTrajectory pathVisitedSites
+
+def visitWeight {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+    (t η : ℝ) (X : Configuration n L) (w : CoordinatePaths n) : ℝ≥0∞ :=
+  ENNReal.ofReal (Real.exp (η*(visitCount L A i t X w:ℝ)))
+
+lemma visitWeight_measurable {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+    (t η : ℝ) (X : Configuration n L) : Measurable (visitWeight L A i t η X) :=
+  ((measurable_const.mul ((measurable_of_countable (fun k : ℕ ↦ (k:ℝ))).comp (visitCount_measurable L A i t X))).exp).ennreal_ofReal
+
+lemma exp_nat_sum_le {a b c : ℕ} (h : a≤b+c) {η : ℝ} (hη : 0≤η) :
+    ENNReal.ofReal (Real.exp (η*(a:ℝ))) ≤
+      ENNReal.ofReal (Real.exp (η*(b:ℝ)))*ENNReal.ofReal (Real.exp (η*(c:ℝ))) := by
+  rw [←ENNReal.ofReal_mul (Real.exp_nonneg _),←Real.exp_add]
+  apply ENNReal.ofReal_le_ofReal
+  apply Real.exp_le_exp.mpr
+  have h' : (a:ℝ)≤(b:ℝ)+(c:ℝ) := by exact_mod_cast h
+  nlinarith
+
+lemma visit_moment_add {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+    {s t η : ℝ} (hs : 0<s) (ht : 0<t) (hη : 0≤η) (p q : ℝ≥0∞)
+    (hsbound : ∀ X, ∫⁻ w,visitWeight L A i s η X w ∂coordinateWiener n ≤p)
+    (htbound : ∀ X, ∫⁻ w,visitWeight L A i t η X w ∂coordinateWiener n ≤q)
+    (X : Configuration n L) :
+    ∫⁻ w,visitWeight L A i (s+t) η X w ∂coordinateWiener n ≤p*q := by
+  let F : CoordinatePaths n × CoordinatePaths n → ℝ≥0∞ := fun w ↦
+    visitWeight L A i s η X w.1 * visitWeight L A i t η (freeTrajectory n L s w.1 X 1) w.2
+  have hG : Measurable (fun w : CoordinatePaths n × CoordinatePaths n ↦
+      visitWeight L A i t η (freeTrajectory n L s w.1 X 1) w.2) := by
+    change Measurable (fun w : CoordinatePaths n × CoordinatePaths n ↦
+      ENNReal.ofReal (Real.exp (η*((pathVisitedSites L (siteCenter L) A i
+        (freeTrajectory n L t w.2 (freeTrajectory n L s w.1 X 1))).card:ℝ))))
+    exact (measurable_const.mul ((measurable_of_countable (fun k : ℕ ↦ (k:ℝ))).comp
+      ((pathVisitedSites_card_measurable L (siteCenter L) A i).comp
+        (measurable_snd.comp (split_fixedTrajectory_measurable n L s t X))))).exp.ennreal_ofReal
+  have hF : Measurable F := ((visitWeight_measurable L A i s η X).comp measurable_fst).mul hG
+  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 :=
+      lintegral_mono (fun w ↦ exp_nat_sum_le (visit_count_split L A i hs ht w X) hη)
+    _ = ∫⁻ w,F w ∂(coordinateWiener n).prod (coordinateWiener n) :=
+      (coordinateSplit_preserving n (splitTime s t hs ht)
+        (splitTime_pos s t hs ht) (splitTime_lt_one s t hs ht)).lintegral_comp hF
+    _ = ∫⁻ w₁,∫⁻ w₂,F (w₁,w₂) ∂coordinateWiener n ∂coordinateWiener n :=
+      lintegral_prod _ hF.aemeasurable
+    _ ≤ ∫⁻ w₁,visitWeight L A i s η X w₁*q ∂coordinateWiener n := by
+      apply lintegral_mono
+      intro w₁
+      dsimp only [F]
+      rw [lintegral_const_mul _ (visitWeight_measurable L A i t η _)]
+      exact mul_le_mul_right (htbound _) _
+    _ = (∫⁻ w,visitWeight L A i s η X w ∂coordinateWiener n)*q :=
+      lintegral_mul_const _ (visitWeight_measurable L A i s η X)
+    _ ≤ p*q := mul_le_mul_left (hsbound X) _
+
+lemma n_segment_visit_moment {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+    {t η : ℝ} (ht : 0<t) (hη : 0≤η) (B : ℝ≥0∞)
+    (hbound : ∀ X, ∫⁻ w,visitWeight L A i t η X w ∂coordinateWiener n ≤ B) :
+    ∀ k : ℕ, 0<k → ∀ X,
+      ∫⁻ w,visitWeight L A i ((k:ℝ)*t) η X w ∂coordinateWiener n ≤ B^k := by
+  intro k hk
+  induction k, hk using Nat.le_induction with
+  | base => simpa only [Nat.succ_eq_add_one,Nat.zero_add,Nat.cast_one,one_mul,pow_one] using hbound
+  | succ k hk ih =>
+    intro X
+    have h := visit_moment_add L A i (mul_pos (by exact_mod_cast hk) ht) ht hη
+      (B^k) B ih hbound X
+    convert h using 1 <;> push_cast <;> ring_nf
+
+lemma small_visit_moment {c : ℝ} (_hc : 0<c) {M : ℝ≥0∞}
+    (htail : ∀ R : ℝ, 0≤R → wiener {w | R≤‖w‖}≤M*ENNReal.ofReal (Real.exp (-c*R^2)))
+    {n K : ℕ} [NeZero K] (L : Length) (hL : L.val=(K:ℝ))
+    (A : Finset (DiscreteTorus K)) (i : Fin n) {η t : ℝ} (hη : 0≤η) (ht : 0<t)
+    (htsmall : t≤c/(2*(η*(29^3:ℝ)+2))) (X : Configuration n L) :
+    ∫⁻ w,visitWeight L A i t η X w ∂coordinateWiener n ≤ expTailBound (29^3) η (3*M) := by
+  apply lintegral_exp_nat_le (coordinateWiener n) (visitCount L A i t X)
+    (visitCount_measurable L A i t X) (29^3) (by norm_num) hη (3*M)
+  intro k hk
+  have he : η*(29^3:ℝ)+2 ≤ c/(2*t) := by
+    apply (le_div_iff₀ (by positivity : 0<2*t)).mpr
+    have h := (le_div_iff₀ (by positivity : 0<2*(η*(29^3:ℝ)+2))).mp htsmall
+    nlinarith
+  have hexp : -c*(k:ℝ)/(2*t) ≤ -(η*(29^3:ℝ)+2)*(k:ℝ) := by
+    calc
+      _ = -(c/(2*t))*(k:ℝ) := by ring
+      _ ≤ _ := mul_le_mul_of_nonneg_right (neg_le_neg he) (Nat.cast_nonneg k)
+  have hb := whole_time_visit_tail htail L hL A i ht k hk X
+  apply hb.trans
+  calc
+    _ ≤ (k:ℝ≥0∞)*(3*M*ENNReal.ofReal (Real.exp (-(η*(29^3:ℝ)+2)*(k:ℝ)))) := by
+      exact mul_le_mul_right (mul_le_mul_right (ENNReal.ofReal_le_ofReal (Real.exp_le_exp.mpr hexp)) _) _
+    _ = _ := by norm_num only [Nat.cast_pow,Nat.cast_ofNat]; ring
+
+theorem free_visit_moment (η₀ : ℝ) (hη₀ : 0≤η₀) :
+    ∃ B : ℝ≥0∞, B<⊤ ∧ ∀ {n K : ℕ} [NeZero K], ∀ (L : Length), L.val=(K:ℝ) →
+      ∀ (A : Finset (DiscreteTorus K)) (i : Fin n) (t η : ℝ),
+        0<t → t≤2 → η≤η₀ → ∀ X : Configuration n L,
+        ∫⁻ w,visitWeight L A i t η X w ∂coordinateWiener n ≤ B := by
+  obtain ⟨c,M,hc,hM,htail⟩ := wiener_norm_gaussian_tail
+  let τ : ℝ := c/(2*(η₀*(29^3:ℝ)+2))
+  have hτ : 0<τ := div_pos hc (by positivity)
+  obtain ⟨m,hm⟩ := exists_nat_gt (max 1 (2/τ))
+  have hm1 : (1:ℝ) < m := (le_max_left _ _).trans_lt hm
+  have hmpos : 0 < m := by exact_mod_cast (lt_trans (by norm_num : (0:ℝ)<1) hm1)
+  have hmpos' : (0:ℝ) < m := by exact_mod_cast hmpos
+  have hτm : 2≤τ*(m:ℝ) := by
+    have h := (le_max_right _ _).trans hm.le
+    have h' := (div_le_iff₀ hτ).mp h
+    nlinarith
+  let B := expTailBound (29^3) η₀ (3*M)
+  have hB : B≠⊤ := expTailBound_ne_top _ _ (ENNReal.mul_ne_top (by simp) hM.ne)
+  refine ⟨B^m,lt_top_iff_ne_top.mpr (ENNReal.pow_ne_top hB),?_⟩
+  intro n K _ L hL A i t η ht ht2 hη X
+  have hts : t/(m:ℝ)≤τ := (div_le_iff₀ hmpos').mpr (by nlinarith)
+  have hs : ∀ X, ∫⁻ w,visitWeight L A i (t/(m:ℝ)) η₀ X w ∂coordinateWiener n ≤ B :=
+    fun X ↦ small_visit_moment hc htail L hL A i hη₀ (div_pos ht hmpos') hts X
+  have h := n_segment_visit_moment L A i (div_pos ht hmpos') hη₀ B hs m hmpos X
+  have he : (m:ℝ)*(t/(m:ℝ))=t := mul_div_cancel₀ t (ne_of_gt hmpos')
+  rw [he] at h
+  apply le_trans _ h
+  apply lintegral_mono
+  intro w
+  exact ENNReal.ofReal_le_ofReal (Real.exp_le_exp.mpr
+    (mul_le_mul_of_nonneg_right hη (Nat.cast_nonneg _)))
+
+end HardSphere.FreeVisits
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/FiberDerivativeMulTailLocal.lean

@@ -0,0 +1,93 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Comparison.SafeMass
+
+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 MeasureTheory Set Filter
+open scoped ComplexConjugate
+
+lemma SmoothMultiplier.fiber_derivative_mul_tail_le_local {n : ℕ} {L : Length}
+    (g : SmoothMultiplier (n+1) L) (r : SmoothMultiplier n L)
+    (hr : ∀ X, conj (g.toFun X)=g.toFun X)
+    (p : Direction (n+1)) (Y : Configuration n L)
+    (hn : ∀ᶠ Z in 𝓝 Y, g.fiberMass Z=1) :
+    ‖r.toFun Y‖^2 * (∫ x : Torus L, ‖coordDerivative (n+1) L g.toFun p (Fin.cons x Y)‖^2) ≤
+      ∫ x : Torus L, ‖coordDerivative (n+1) L (fun X ↦ g.toFun X*r.toFun (Fin.tail X)) p
+        (Fin.cons x Y)‖^2 := by
+  have hd := coordDerivative_mul (g := fun X : Configuration (n+1) L ↦ r.toFun (Fin.tail X))
+    (g.smooth.differentiable (by simp))
+    ((smooth_tail r.smooth).differentiable (by simp)) p
+  have hc : Continuous (fun x : Torus L ↦ (Fin.cons x Y : Configuration (n+1) L)) :=
+    (continuous_id : Continuous (id : Torus L → Torus L)).finCons
+      (continuous_const : Continuous (fun _ : Torus L ↦ Y))
+  have hg := (continuous_of_continuous_lift g.smooth.continuous).comp hc
+  have hdg := (continuous_coordDerivative g.smooth p).comp hc
+  have hs := r.smooth.differentiable (by simp)
+  rcases p with ⟨i,j⟩
+  induction i using Fin.cases with
+  | zero =>
+    simp only [coordDerivative_tail_zero hs j,mul_zero,zero_add] at hd
+    rw [show (fun X ↦ g.toFun X*r.toFun (Fin.tail X))=g.toFun*(fun X ↦ r.toFun (Fin.tail X)) from rfl,hd]
+    simp only [Pi.mul_apply,Fin.tail_cons,norm_mul,mul_pow]
+    rw [integral_const_mul]
+  | succ k =>
+    have he := g.insertion_orthogonal_local hr k j Y hn
+    have ho : (∫ x : Torus L,
+        conj (g.toFun (Fin.cons x Y)*coordDerivative n L r.toFun (k,j) Y)*
+          (r.toFun Y*coordDerivative (n+1) L g.toFun (k.succ,j) (Fin.cons x Y)))=0 := by
+      calc
+        _ = (conj (coordDerivative n L r.toFun (k,j) Y)*r.toFun Y)*
+            ∫ x : Torus L, conj (g.toFun (Fin.cons x Y))*
+              coordDerivative (n+1) L g.toFun (k.succ,j) (Fin.cons x Y) := by
+          rw [← integral_const_mul]
+          apply integral_congr_ae
+          exact Eventually.of_forall fun x ↦ by simp only [map_mul]; ring
+        _ = 0 := by rw [he,mul_zero]
+    have heq := integral_norm_add_sq_orthogonal (hg.mul continuous_const) (continuous_const.mul hdg) ho
+    simp only [Pi.mul_apply,Function.comp_def] at heq
+    have hd' := coordDerivative_mul (g := fun X : Configuration (n+1) L ↦ r.toFun (Fin.tail X))
+      (g.smooth.differentiable (by simp))
+      ((smooth_tail r.smooth).differentiable (by simp)) (k.succ,j)
+    rw [coordDerivative_tail_succ hs k j] at hd'
+    rw [show (fun X ↦ g.toFun X*r.toFun (Fin.tail X))=g.toFun*(fun X ↦ r.toFun (Fin.tail X)) from rfl,hd']
+    simp only [Pi.mul_apply,Pi.add_apply,Fin.tail_cons]
+    rw [heq]
+    simp only [norm_mul,mul_pow]
+    rw [integral_const_mul]
+    exact le_add_of_nonneg_left (integral_nonneg fun x ↦ mul_nonneg (sq_nonneg _) (sq_nonneg _))
+
+lemma SmoothMultiplier.localNormalization_derivative_le {n : ℕ} {L : Length}
+    (f : SmoothMultiplier (n+1) L) (hr : ∀ X, conj (f.toFun X)=f.toFun X)
+    (p : Direction (n+1)) (Y : Configuration n L) (hY : 1/2<f.fiberMass Y) :
+    f.fiberMass Y * (∫ x : Torus L,
+      ‖coordDerivative (n+1) L (f.localNormalization hr).toFun p (Fin.cons x Y)‖^2) ≤
+      ∫ x : Torus L, ‖coordDerivative (n+1) L f.toFun p (Fin.cons x Y)‖^2 := by
+  have he : (fun X ↦ (f.localNormalization hr).toFun X *
+      (f.safeRoot hr).toFun (Fin.tail X))=f.toFun := by
+    funext X
+    exact div_mul_cancel₀ _ (Complex.ofReal_ne_zero.mpr
+      (Real.sqrt_pos.mpr (safeMass_pos (f.fiberMass_nonneg _))).ne')
+  have hh := (f.localNormalization hr).fiber_derivative_mul_tail_le_local (f.safeRoot hr)
+    (f.localNormalization_real hr) p Y (f.localNormalization_mass_eventually hr Y hY)
+  rw [he] at hh
+  have hn : ‖(f.safeRoot hr).toFun Y‖^2=f.fiberMass Y := by
+    change ‖(Real.sqrt (safeMass (f.fiberMass Y)) : ℂ)‖^2=_
+    rw [Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (Real.sqrt_nonneg _),
+      Real.sq_sqrt (safeMass_pos (f.fiberMass_nonneg _)).le,safeMass_eq hY.le]
+  rwa [hn] at hh
+
+end HardSphere
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/FreeVisitProbability.lean

@@ -0,0 +1,176 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.KilledObservable
+import OAI.Analysis.HardSphere.PathBounds.VisitPacking
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.FreeVisits
+open HardSphere.BathSlice HardSphere.Lattice HardSphere.CellOrbital HardSphere.Wiener
+
+lemma pathVisitedSites_card_measurable {S : Type*} {n : ℕ} (L : Length)
+    (v : S → Torus L) (A : Finset S) (i : Fin n) :
+    Measurable (fun ω : ConfigurationPath n L ↦ (pathVisitedSites L v A i ω).card) := by
+  classical
+  simp only [pathVisitedSites,Finset.card_filter]
+  apply Finset.measurable_sum
+  intro a _
+  exact Measurable.ite (pathVisitsBall_isClosed L 12 (v a) i).measurableSet
+    measurable_const measurable_const
+
+def visitCount {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+    (t : ℝ) (X : Configuration n L) (w : CoordinatePaths n) : ℕ :=
+  (pathVisitedSites L (siteCenter L) A i (freeTrajectory n L t w X)).card
+
+lemma visitCount_measurable {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+    (t : ℝ) (X : Configuration n L) : Measurable (visitCount L A i t X) :=
+  (pathVisitedSites_card_measurable L (siteCenter L) A i).comp
+    ((freeTrajectory_continuous n L t).comp (continuous_id.prodMk continuous_const)).measurable
+
+lemma one_segment_visit_tail {c : ℝ} {M : ℝ≥0∞}
+    (htail : ∀ R : ℝ, 0≤R → wiener {w | R≤‖w‖}≤M*ENNReal.ofReal (Real.exp (-c*R^2)))
+    {n K : ℕ} [NeZero K] (L : Length) (hL : L.val=(K:ℝ))
+    (A : Finset (DiscreteTorus K)) (i : Fin n) {t : ℝ} (ht : 0<t) (X : Configuration n L) :
+    coordinateWiener n {w | 29^3<visitCount L A i t X w} ≤
+      3*M*ENNReal.ofReal (Real.exp (-c/(2*t))) := by
+  let R : ℝ := (Real.sqrt (2*t))⁻¹
+  have hs : 0<Real.sqrt (2*t) := Real.sqrt_pos.mpr (by positivity)
+  have hR : 0≤R := inv_nonneg.mpr hs.le
+  have hsub : {w | 29^3<visitCount L A i t X w} ⊆
+      ⋃ j : Fin 3, {w | R≤‖w (i,j)‖} := by
+    intro w hw
+    by_contra hnot
+    have hn : ∀ j, ‖w (i,j)‖<R := by simpa only [Set.mem_iUnion,Set.mem_ofPred_eq,not_exists,not_le] using hnot
+    have hb := free_visited_card_le_of_norm L hL A i t w X (fun j ↦ ?_)
+    · exact (not_lt_of_ge hb) hw
+    · calc
+        Real.sqrt (2*t)*‖w (i,j)‖ ≤ Real.sqrt (2*t)*R := mul_le_mul_of_nonneg_left (hn j).le hs.le
+        _ = 1 := mul_inv_cancel₀ (ne_of_gt hs)
+  have he (j : Fin 3) : coordinateWiener n {w | R≤‖w (i,j)‖} = wiener {w | R≤‖w‖} := by
+    exact (measurePreserving_eval (fun _ : Direction n ↦ wiener) (i,j)).measure_preimage
+      (measurableSet_le measurable_const measurable_norm).nullMeasurableSet
+  calc
+    _ ≤ coordinateWiener n (⋃ j : Fin 3, {w | R≤‖w (i,j)‖}) := measure_mono hsub
+    _ ≤ ∑' j : Fin 3, coordinateWiener n {w | R≤‖w (i,j)‖} := measure_iUnion_le _
+    _ = 3 * wiener {w | R≤‖w‖} := by simp [he,tsum_fintype]
+    _ ≤ 3*(M*ENNReal.ofReal (Real.exp (-c*R^2))) := mul_le_mul_right (htail R hR) _
+    _ = _ := by
+      dsimp [R]
+      rw [inv_pow,Real.sq_sqrt (by positivity : 0≤2*t)]
+      simp only [div_eq_mul_inv,mul_assoc]
+
+lemma visit_count_split {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+    {s t : ℝ} (hs : 0<s) (ht : 0<t) (w : CoordinatePaths n) (X : Configuration n L) :
+    visitCount L A i (s+t) X w ≤
+      visitCount L A i s X (fun p ↦ normalizedPrefix (splitTime s t hs ht) (w p)) +
+      visitCount L A i t
+        (freeTrajectory n L s (fun p ↦ normalizedPrefix (splitTime s t hs ht) (w p)) X 1)
+        (fun p ↦ normalizedSuffix (splitTime s t hs ht) (w p)) := by
+  have hle := visited_card_split_le L (siteCenter L) A i (freeTrajectory n L (s+t) w X)
+    (splitTime s t hs ht) (splitTime_pos s t hs ht) (splitTime_lt_one s t hs ht)
+  have hp := congrArg Prod.fst (split_fixedTrajectory n L s t hs ht w X)
+  have hq := congrArg Prod.snd (split_fixedTrajectory n L s t hs ht w X)
+  dsimp only [Prod.fst,Prod.snd] at hp hq
+  rw [hp,hq] at hle
+  exact hle
+
+attribute [local irreducible] freeTrajectory pathVisitedSites
+
+lemma visit_tail_add {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+    {s t : ℝ} (hs : 0<s) (ht : 0<t) (a b : ℕ) (p q : ℝ≥0∞)
+    (hsbound : ∀ X, coordinateWiener n {w | a<visitCount L A i s X w}≤p)
+    (htbound : ∀ X, coordinateWiener n {w | b<visitCount L A i t X w}≤q)
+    (X : Configuration n L) :
+    coordinateWiener n {w | a+b<visitCount L A i (s+t) X w}≤p+q := by
+  let u := splitTime s t hs ht
+  let split : CoordinatePaths n → CoordinatePaths n × CoordinatePaths n := fun w ↦
+    (fun p ↦ normalizedPrefix u (w p),fun p ↦ normalizedSuffix u (w p))
+  let E₁ : Set (CoordinatePaths n × CoordinatePaths n) :=
+    {p | a<visitCount L A i s X p.1}
+  let E₂ : Set (CoordinatePaths n × CoordinatePaths n) :=
+    {p | b<visitCount L A i t (freeTrajectory n L s p.1 X 1) p.2}
+  have hE₁ : MeasurableSet E₁ := measurableSet_lt measurable_const
+    ((visitCount_measurable L A i s X).comp measurable_fst)
+  have hE₂ : MeasurableSet E₂ := by
+    apply measurableSet_lt measurable_const
+    exact (pathVisitedSites_card_measurable L (siteCenter L) A i).comp
+      (measurable_snd.comp (split_fixedTrajectory_measurable n L s t X))
+  have hsub : {w | a+b<visitCount L A i (s+t) X w} ⊆ split ⁻¹' (E₁∪E₂) := by
+    intro w hw
+    have hle := visit_count_split L A i hs ht w X
+    change a<visitCount L A i s X (split w).1 ∨
+      b<visitCount L A i t (freeTrajectory n L s (split w).1 X 1) (split w).2
+    change a+b<visitCount L A i (s+t) X w at hw
+    change visitCount L A i (s+t) X w ≤ visitCount L A i s X (split w).1 +
+      visitCount L A i t (freeTrajectory n L s (split w).1 X 1) (split w).2 at hle
+    omega
+  have hp₁ : ((coordinateWiener n).prod (coordinateWiener n)) E₁≤p := by
+    have he : E₁={w | a<visitCount L A i s X w} ×ˢ Set.univ := by ext v; simp [E₁]
+    rw [he,Measure.prod_prod,measure_univ,mul_one]
+    exact hsbound X
+  have hp₂ : ((coordinateWiener n).prod (coordinateWiener n)) E₂≤q := by
+    rw [Measure.prod_apply hE₂]
+    calc
+      _ ≤ ∫⁻ _w : CoordinatePaths n, q ∂coordinateWiener n := by
+        apply lintegral_mono
+        intro w
+        exact htbound (freeTrajectory n L s w X 1)
+      _ = q := by simp
+  calc
+    _ ≤ coordinateWiener n (split ⁻¹' (E₁∪E₂)) := measure_mono hsub
+    _ = ((coordinateWiener n).prod (coordinateWiener n)) (E₁∪E₂) :=
+      (coordinateSplit_preserving n u (splitTime_pos s t hs ht) (splitTime_lt_one s t hs ht)).measure_preimage
+        (hE₁.union hE₂).nullMeasurableSet
+    _ ≤ ((coordinateWiener n).prod (coordinateWiener n)) E₁ +
+        ((coordinateWiener n).prod (coordinateWiener n)) E₂ := measure_union_le _ _
+    _ ≤ p+q := add_le_add hp₁ hp₂
+
+lemma n_segment_visit_tail {c : ℝ} {M : ℝ≥0∞}
+    (htail : ∀ R : ℝ, 0≤R → wiener {w | R≤‖w‖}≤M*ENNReal.ofReal (Real.exp (-c*R^2)))
+    {n K : ℕ} [NeZero K] (L : Length) (hL : L.val=(K:ℝ))
+    (A : Finset (DiscreteTorus K)) (i : Fin n) {t : ℝ} (ht : 0<t) :
+    ∀ k : ℕ, 0<k → ∀ X : Configuration n L,
+      coordinateWiener n {w | 29^3*k<visitCount L A i ((k:ℝ)*t) X w} ≤
+        (k:ℝ≥0∞)*(3*M*ENNReal.ofReal (Real.exp (-c/(2*t)))) := by
+  intro k hk
+  induction k, hk using Nat.le_induction with
+  | base =>
+    intro X
+    simpa only [Nat.succ_eq_add_one,Nat.zero_add,Nat.cast_one,one_mul,mul_one] using one_segment_visit_tail htail L hL A i ht X
+  | succ k hk ih =>
+    intro X
+    have hkt : 0<(k:ℝ)*t := mul_pos (by exact_mod_cast hk) ht
+    have h := visit_tail_add L A i hkt ht (29^3*k) (29^3)
+      ((k:ℝ≥0∞)*(3*M*ENNReal.ofReal (Real.exp (-c/(2*t)))))
+      (3*M*ENNReal.ofReal (Real.exp (-c/(2*t)))) ih
+      (fun X ↦ one_segment_visit_tail htail L hL A i ht X) X
+    convert h using 1 <;> push_cast <;> ring_nf
+
+lemma whole_time_visit_tail {c : ℝ} {M : ℝ≥0∞}
+    (htail : ∀ R : ℝ, 0≤R → wiener {w | R≤‖w‖}≤M*ENNReal.ofReal (Real.exp (-c*R^2)))
+    {n K : ℕ} [NeZero K] (L : Length) (hL : L.val=(K:ℝ))
+    (A : Finset (DiscreteTorus K)) (i : Fin n) {t : ℝ} (ht : 0<t)
+    (k : ℕ) (hk : 0<k) (X : Configuration n L) :
+    coordinateWiener n {w | 29^3*k<visitCount L A i t X w} ≤
+      (k:ℝ≥0∞)*(3*M*ENNReal.ofReal (Real.exp (-c*(k:ℝ)/(2*t)))) := by
+  have hk' : (0:ℝ)<k := by exact_mod_cast hk
+  have h := n_segment_visit_tail htail L hL A i (div_pos ht hk') k hk X
+  have he : (k:ℝ)*(t/k)=t := mul_div_cancel₀ t (ne_of_gt hk')
+  rw [he] at h
+  convert h using 1
+  congr 3
+  field_simp
+
+end HardSphere.FreeVisits
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/FreeVisitTravel.lean

@@ -0,0 +1,243 @@
+import Mathlib
+import OAI.Analysis.HardSphere.PathBounds.PathTailConstant
+import OAI.Analysis.HardSphere.PathBounds.ExpNatTail
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.FreeVisits
+open HardSphere.Wiener HardSphere.Lattice HardSphere.CellOrbital HardSphere.BathSlice
+
+lemma torusDistance_le_three_of_coord (L : Length) (x y : Torus L) {B : ℝ}
+    (hB : 0≤B) (h : ∀ j, dist (x j) (y j)≤B) : torusDistance L x y≤3*B := by
+  apply Real.sqrt_le_iff.mpr
+  constructor
+  · positivity
+  · have hs : ∑ j : Fin 3, dist (x j) (y j)^2 ≤ ∑ _j : Fin 3, B^2 :=
+      Finset.sum_le_sum (fun j _ ↦ pow_le_pow_left₀ dist_nonneg (h j) 2)
+    simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] at hs
+    norm_num at hs
+    nlinarith [sq_nonneg B]
+
+lemma freeTrajectory_dist_le {n : ℕ} (L : Length) {t R : ℝ} (ht : t≤2) (hR : 0≤R)
+    (w : CoordinatePaths n) (X : Configuration n L) (i : Fin n)
+    (hw : ∀ j, ‖w (i,j)‖≤R) (u : Time) :
+    torusDistance L (freeTrajectory n L t w X u i) (X i)≤6*R := by
+  have hs : Real.sqrt (2*t)≤2 := (Real.sqrt_le_iff).mpr ⟨by norm_num,by nlinarith⟩
+  have hcoord (j : Fin 3) : dist (freeTrajectory n L t w X u i j) (X i j)≤2*R := by
+    apply (freeTrajectory_coord_dist_le L t w X i u j).trans
+    exact mul_le_mul hs (hw j) (norm_nonneg _) (by norm_num)
+  have h := torusDistance_le_three_of_coord L _ _ (mul_nonneg (by norm_num) hR) hcoord
+  nlinarith
+
+attribute [local irreducible] freeTrajectory pathVisitedSites torusDistance
+
+def visitStartDistance {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
+    (i : Fin n) (X : Configuration n L) : ℝ := by
+  classical
+  exact spatialSiteDistance L (A.image (siteCenter L)) (X i)
+
+lemma visitStartDistance_nonneg {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
+    (i : Fin n) (X : Configuration n L) : 0≤visitStartDistance L A i X :=
+  spatialSiteDistance_nonneg _ _ _
+
+lemma visit_distance_le {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
+    (i : Fin n) (t : ℝ) (X : Configuration n L) (w : CoordinatePaths n)
+    (hw : 0<visitCount L A i t X w) :
+    ∃ u : Time, visitStartDistance L A i X≤
+      torusDistance L (freeTrajectory n L t w X u i) (X i)+12 := by
+  classical
+  obtain ⟨v,hv⟩ := Finset.card_pos.mp hw
+  have hm : v∈A ∧ pathVisitsBall L 12 (siteCenter L v) i (freeTrajectory n L t w X) := by
+    rw [pathVisitedSites] at hv
+    exact Finset.mem_filter.mp hv
+  obtain ⟨u,hu⟩ := hm.2
+  have hd := spatialSiteDistance_le L (A.image (siteCenter L)) (X i) (siteCenter L v)
+    (Finset.mem_image.mpr ⟨v,hm.1,rfl⟩)
+  have htri := torusDistance_triangle' L (X i) (freeTrajectory n L t w X u i) (siteCenter L v)
+  rw [torusDistance_comm L (X i) (freeTrajectory n L t w X u i)] at htri
+  exact ⟨u,hd.trans (htri.trans (add_le_add le_rfl hu))⟩
+
+lemma free_visit_travel_gaussian {c : ℝ} {M : ℝ≥0∞}
+    (htail : ∀ R : ℝ, 0≤R → wiener {w | R≤‖w‖}≤M*ENNReal.ofReal (Real.exp (-c*R^2)))
+    {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n) {t : ℝ}
+    (ht : t≤2) (X : Configuration n L) (hd : 24≤visitStartDistance L A i X) :
+    coordinateWiener n {w | 0<visitCount L A i t X w} ≤
+      3*M*ENNReal.ofReal (Real.exp (-c*(visitStartDistance L A i X)^2/576)) := by
+  let d := visitStartDistance L A i X
+  let R := d/24
+  have hR : 0≤R := div_nonneg (by dsimp [d]; linarith) (by norm_num)
+  have hsub : {w | 0<visitCount L A i t X w} ⊆ ⋃ j : Fin 3, {w | R≤‖w (i,j)‖} := by
+    intro w hw
+    by_contra hn
+    have hw' : ∀ j, ‖w (i,j)‖≤R := by
+      have h : ∀ j, ‖w (i,j)‖<R := by simpa only [Set.mem_iUnion,Set.mem_ofPred_eq,not_exists,not_le] using hn
+      exact fun j ↦ (h j).le
+    obtain ⟨u,hu⟩ := visit_distance_le L A i t X w hw
+    have hdist := freeTrajectory_dist_le L ht hR w X i hw' u
+    dsimp [R,d] at hdist
+    linarith
+  have he (j : Fin 3) : coordinateWiener n {w | R≤‖w (i,j)‖} = wiener {w | R≤‖w‖} :=
+    (measurePreserving_eval (fun _ : Direction n ↦ wiener) (i,j)).measure_preimage
+      (measurableSet_le measurable_const measurable_norm).nullMeasurableSet
+  calc
+    _ ≤ coordinateWiener n (⋃ j : Fin 3, {w | R≤‖w (i,j)‖}) := measure_mono hsub
+    _ ≤ ∑' j : Fin 3, coordinateWiener n {w | R≤‖w (i,j)‖} := measure_iUnion_le _
+    _ = 3*wiener {w | R≤‖w‖} := by simp [he,tsum_fintype]
+    _ ≤ 3*(M*ENNReal.ofReal (Real.exp (-c*R^2))) := mul_le_mul_right (htail R hR) _
+    _ = _ := by
+      have he : -c*R^2 = -c*(visitStartDistance L A i X)^2/576 := by dsimp [R,d]; ring
+      rw [he]; ac_rfl
+
+theorem free_visit_travel : ∃ H : ℝ≥0∞, H<⊤ ∧
+    ∀ {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+      (t : ℝ), t≤2 → ∀ X : Configuration n L,
+      coordinateWiener n {w | 0<visitCount L A i t X w} ≤
+        H*ENNReal.ofReal (Real.exp (-3*visitStartDistance L A i X)) := by
+  obtain ⟨c,M,hc,hM,htail⟩ := wiener_norm_gaussian_tail
+  let H := ENNReal.ofReal (Real.exp 72)+3*M*ENNReal.ofReal (Real.exp (1296/c))
+  have hH : H<⊤ := by dsimp [H]; finiteness
+  refine ⟨H,hH,?_⟩
+  intro n K L A i t ht X
+  let d := visitStartDistance L A i X
+  by_cases hd : 24≤d
+  · apply (free_visit_travel_gaussian htail L A i ht X hd).trans
+    have hexp : -c*d^2/576 ≤ 1296/c+(-3*d) := by
+      have hs := sq_nonneg (c*d-864)
+      apply (mul_le_mul_iff_left₀ hc).mp
+      have he : c*(1296/c)=1296 := mul_div_cancel₀ _ (ne_of_gt hc)
+      nlinarith
+    have hbound := ENNReal.ofReal_le_ofReal (Real.exp_le_exp.mpr hexp)
+    rw [Real.exp_add,ENNReal.ofReal_mul (Real.exp_nonneg _)] at hbound
+    calc
+      _ ≤ (3*M*ENNReal.ofReal (Real.exp (1296/c)))*ENNReal.ofReal (Real.exp (-3*d)) := by
+        exact (mul_le_mul_right hbound (3*M)).trans_eq (by ring)
+      _ ≤ _ := by gcongr; exact le_add_self
+  · have he : 1≤ENNReal.ofReal (Real.exp 72)*ENNReal.ofReal (Real.exp (-3*d)) := by
+      rw [← ENNReal.ofReal_mul (Real.exp_nonneg _),←Real.exp_add]
+      exact ENNReal.one_le_ofReal.mpr (Real.one_le_exp_iff.mpr (by linarith))
+    exact (prob_le_one).trans (he.trans (by gcongr; exact le_self_add))
+
+end HardSphere.FreeVisits
+
+namespace HardSphere.FreeVisits
+open HardSphere.Wiener HardSphere.Lattice HardSphere.CellOrbital HardSphere.BathSlice
+attribute [local irreducible] freeTrajectory pathVisitedSites torusDistance
+
+lemma lintegral_three_thirds {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω)
+    {f g h : Ω → ℝ≥0∞} (hf : Measurable f) (hg : Measurable g) (hh : Measurable h) :
+    (∫⁻ w, f w^(1/3:ℝ)*g w^(1/3:ℝ)*h w^(1/3:ℝ) ∂μ) ≤
+    (∫⁻ w,f w ∂μ)^(1/3:ℝ)*(∫⁻ w,g w ∂μ)^(1/3:ℝ)*(∫⁻ w,h w ∂μ)^(1/3:ℝ) := by
+  let F : Fin 3 → Ω → ℝ≥0∞ := ![f,g,h]
+  have hF : ∀ i ∈ (Finset.univ : Finset (Fin 3)), AEMeasurable (F i) μ := by
+    intro i _; fin_cases i <;> simp only [F] <;>
+      first | exact hf.aemeasurable | exact hg.aemeasurable | exact hh.aemeasurable
+  have H := ENNReal.lintegral_prod_norm_pow_le (μ:=μ) Finset.univ hF
+    (p:=fun _ ↦ (1/3:ℝ)) (by norm_num) (by intros; norm_num)
+  simpa [Fin.prod_univ_three,F] using H
+
+lemma ofReal_exp_rpow {x p : ℝ} (hp : 0≤p) :
+    ENNReal.ofReal (Real.exp x)^p = ENNReal.ofReal (Real.exp (x*p)) := by
+  rw [ENNReal.ofReal_rpow_of_nonneg (Real.exp_nonneg _) hp,Real.exp_mul]
+
+lemma indicator_one_third {Ω : Type*} (D : Set Ω) (w : Ω) :
+    (D.indicator (fun _ ↦ (1:ℝ≥0∞)) w)^(1/3:ℝ) = D.indicator (fun _ ↦ 1) w := by
+  classical
+  by_cases hw : w∈D <;> simp [hw]
+
+lemma exp_sub_one_le_mul_exp (x : ℝ) : Real.exp x-1≤x*Real.exp x := by
+  have h := mul_le_mul_of_nonneg_right (Real.add_one_le_exp (-x)) (Real.exp_nonneg x)
+  rw [←Real.exp_add] at h
+  simp only [neg_add_cancel,Real.exp_zero] at h
+  nlinarith
+
+def visitDefect {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+    (t η : ℝ) (X : Configuration n L) (D : Set (CoordinatePaths n)) (w : CoordinatePaths n) : ℝ≥0∞ := by
+  classical
+  exact ENNReal.ofReal (Real.exp (η*(if w∈D then (visitCount L A i t X w:ℝ) else 0))-1)
+
+lemma visitDefect_le {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K)) (i : Fin n)
+    (t : ℝ) {η η₀ : ℝ} (hη : 0≤η) (hηη : η≤η₀) (X : Configuration n L)
+    (D : Set (CoordinatePaths n)) (w : CoordinatePaths n) :
+    visitDefect L A i t η X D w ≤ ENNReal.ofReal η *
+      (visitWeight L A i t (3*(η₀+1)) X w ^ (1/3:ℝ) *
+      (D.indicator (fun _ ↦ (1:ℝ≥0∞)) w)^(1/3:ℝ) *
+      ({w | 0<visitCount L A i t X w}.indicator (fun _ ↦ (1:ℝ≥0∞)) w) ^ (1/3:ℝ)) := by
+  classical
+  rw [indicator_one_third,indicator_one_third]
+  by_cases hw : w∈D
+  · by_cases hJ : 0<visitCount L A i t X w
+    · have hJmem : w∈{w | 0<visitCount L A i t X w} := hJ
+      simp only [Set.indicator_of_mem hw,Set.indicator_of_mem hJmem,mul_one]
+      rw [visitWeight,ofReal_exp_rpow (by norm_num),←ENNReal.ofReal_mul hη]
+      apply ENNReal.ofReal_le_ofReal
+      simp only [ite_eq_left hw]
+      set J : ℝ := (visitCount L A i t X w:ℝ)
+      have hJe : J≤Real.exp J := by linarith [Real.add_one_le_exp J]
+      have hJ0 : 0≤J := Nat.cast_nonneg _
+      calc
+        Real.exp (η*J)-1 ≤ (η*J)*Real.exp (η*J) := exp_sub_one_le_mul_exp _
+        _ ≤ η*Real.exp J*Real.exp (η*J) := by gcongr
+        _ = η*Real.exp ((η+1)*J) := by rw [mul_assoc,←Real.exp_add]; congr 2; ring
+        _ ≤ η*Real.exp (3*(η₀+1)*J*(1/3)) := by
+          apply mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr ?_) hη
+          nlinarith
+    · have hJ0 : visitCount L A i t X w=0 := Nat.eq_zero_of_not_pos hJ
+      simp [visitDefect,hw,hJ0]
+  · simp [visitDefect,hw]
+
+theorem free_visit_bound {η₀ : ℝ} (hη₀ : 0≤η₀) : ∃ C : ℝ≥0∞, C<⊤ ∧
+    ∀ {n K : ℕ} [NeZero K] (L : Length), L.val=(K:ℝ) →
+      ∀ (A : Finset (DiscreteTorus K)) (i : Fin n) {t η : ℝ}, 0<t → t≤2 →
+      0≤η → η≤η₀ → ∀ (X : Configuration n L) (D : Set (CoordinatePaths n)),
+      MeasurableSet D → ∀ ε : ℝ≥0∞, coordinateWiener n D≤ε →
+      ∫⁻ w,visitDefect L A i t η X D w ∂coordinateWiener n ≤
+        C*ENNReal.ofReal η*ε^(1/3:ℝ)*ENNReal.ofReal (Real.exp (-visitStartDistance L A i X)) := by
+  obtain ⟨B,hB,hBM⟩ := free_visit_moment (3*(η₀+1)) (show 0≤3*(η₀+1) by positivity)
+  obtain ⟨H,hH,hHT⟩ := free_visit_travel
+  let C := B^(1/3:ℝ)*H^(1/3:ℝ)
+  have hC : C<⊤ := ENNReal.mul_lt_top
+    (ENNReal.rpow_lt_top_of_nonneg (by norm_num) hB.ne)
+    (ENNReal.rpow_lt_top_of_nonneg (by norm_num) hH.ne)
+  refine ⟨C,hC,?_⟩
+  intro n K _ L hL A i t η ht ht2 hη hηη X D hD ε hε
+  let V := {w | 0<visitCount L A i t X w}
+  have hV : MeasurableSet V := measurableSet_lt measurable_const (visitCount_measurable L A i t X)
+  let f := visitWeight L A i t (3*(η₀+1)) X
+  let g := D.indicator (fun _ ↦ (1:ℝ≥0∞))
+  let h := V.indicator (fun _ ↦ (1:ℝ≥0∞))
+  have hf : Measurable f := visitWeight_measurable L A i t _ X
+  have hg : Measurable g := measurable_const.indicator hD
+  have hh : Measurable h := measurable_const.indicator hV
+  have hm : Measurable (fun w ↦ f w^(1/3:ℝ)*g w^(1/3:ℝ)*h w^(1/3:ℝ)) :=
+    ((hf.pow_const _).mul (hg.pow_const _)).mul (hh.pow_const _)
+  have hfb : (∫⁻ w,f w ∂coordinateWiener n)≤B := hBM L hL A i t (3*(η₀+1)) ht ht2 le_rfl X
+  have hgb : (∫⁻ w,g w ∂coordinateWiener n)≤ε := by
+    change (∫⁻ w,D.indicator 1 w ∂coordinateWiener n)≤ε
+    rw [lintegral_indicator_one hD]; exact hε
+  have hhb : (∫⁻ w,h w ∂coordinateWiener n)≤H*ENNReal.ofReal (Real.exp (-3*visitStartDistance L A i X)) := by
+    change (∫⁻ w,V.indicator 1 w ∂coordinateWiener n)≤_
+    rw [lintegral_indicator_one hV]; exact hHT L A i t ht2 X
+  calc
+    _ ≤ ∫⁻ w,ENNReal.ofReal η*(f w^(1/3:ℝ)*g w^(1/3:ℝ)*h w^(1/3:ℝ)) ∂coordinateWiener n :=
+      lintegral_mono (visitDefect_le L A i t hη hηη X D)
+    _ = ENNReal.ofReal η*(∫⁻ w,f w^(1/3:ℝ)*g w^(1/3:ℝ)*h w^(1/3:ℝ) ∂coordinateWiener n) :=
+      lintegral_const_mul _ hm
+    _ ≤ ENNReal.ofReal η*((∫⁻ w,f w ∂coordinateWiener n)^(1/3:ℝ)*
+        (∫⁻ w,g w ∂coordinateWiener n)^(1/3:ℝ)*(∫⁻ w,h w ∂coordinateWiener n)^(1/3:ℝ)) :=
+      mul_le_mul_right (lintegral_three_thirds _ hf hg hh) _
+    _ ≤ ENNReal.ofReal η*(B^(1/3:ℝ)*ε^(1/3:ℝ)*
+        (H*ENNReal.ofReal (Real.exp (-3*visitStartDistance L A i X)))^(1/3:ℝ)) := by
+      gcongr
+    _ = _ := by
+      rw [ENNReal.mul_rpow_of_nonneg _ _ (by norm_num),ofReal_exp_rpow (by norm_num)]
+      have he : -3*visitStartDistance L A i X*(1/3) = -visitStartDistance L A i X := by ring
+      rw [he]; dsimp [C]; ring
+
+end HardSphere.FreeVisits
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/GridTailTransfer.lean

@@ -0,0 +1,100 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.GridAlignment
+import OAI.Analysis.HardSphere.PathBounds.VisitCounts
+import OAI.Analysis.HardSphere.Thermodynamics.ShiftCloseTail
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.Groups
+open Wiener PathCutoff CellOrbital BathSlice HardSphere.Lattice
+
+lemma joint_event_image {W V U : Type*} [MeasurableSpace W] [DecidableEq U]
+    (μ : Measure W) (f : V→U) (P : U→W→Prop) (A : Finset V) :
+    μ {ω | ∀v∈A,P (f v) ω}=μ {ω | ∀u∈A.image f,P u ω} := by
+  congr 1
+  ext ω
+  simp only [Set.mem_ofPred_eq,Finset.mem_image,forall_exists_index,and_imp,forall_apply_eq_imp_iff₂]
+
+lemma grid_visitors_eq {n K : ℕ} [NeZero K] (L : Length)
+    (v : Fin 3→Fin K) (ω : ConfigurationPath n L) :
+    ShiftVisits.visitorCount L (gridShift L) Set.univ (gridSite v) ω=(visitors (gridCenter L v) ω).card := by
+  classical
+  rw [grid_visitorCount]
+  apply congrArg Finset.card
+  ext i
+  simp [visitors]
+
+lemma grid_longVisitors_eq {n K : ℕ} [NeZero K] (L : Length)
+    (v : Fin 3→Fin K) (ω : ConfigurationPath n L) :
+    ShiftVisits.visitorCount L (gridShift L) {p | 1 < intervalDiameter 0 1 p} (gridSite v) ω=
+      (longVisitors (gridCenter L v) ω).card := by
+  classical
+  rw [grid_visitorCount]
+  apply congrArg Finset.card
+  ext i
+  simp [longVisitors,and_comm]
+
+lemma grid_nonregular_iff {n K : ℕ} [NeZero K] (L : Length)
+    (m : ℕ) (r R C S : ℝ) (u : Time) (v : Fin 3→Fin K) (ω : ConfigurationPath n L) :
+    (¬∀i,pathVisitsBall L 12 (gridCenter L v) i ω→Regular m r R C u S (onePathAt i ω)) ↔
+    1≤(ShiftVisits.visitorCount L (gridShift L) {p | ¬Regular m r R C u S p} (gridSite v) ω:ℝ) := by
+  classical
+  rw [grid_visitorCount]
+  have hcast (k : ℕ) : (1:ℝ)≤(k:ℝ) ↔ 1≤k := by exact_mod_cast Iff.rfl
+  rw [hcast,Finset.one_le_card]
+  change (¬∀i, _ → _) ↔ ∃i, i∈_
+  simp only [Finset.mem_filter,Finset.mem_univ,true_and,Set.mem_ofPred_eq]
+  push Not
+  exact exists_congr (fun i ↦ and_comm)
+
+lemma ofReal_power_tail {x q : ℝ} (hx : 0≤x) (hq : 0≤q) (h : x≤q^6) (n : ℕ) :
+    ENNReal.ofReal (x^n)≤(ENNReal.ofReal q)^(6*n) := by
+  rw [pow_mul,←ENNReal.ofReal_pow hq,←ENNReal.ofReal_pow (pow_nonneg hq _)]
+  exact ENNReal.ofReal_le_ofReal (pow_le_pow_left₀ hx h n)
+
+lemma exp_power_tail {x q : ℝ} (hq : 0≤q) (h : Real.exp x≤q^6) (n : ℕ) :
+    ENNReal.ofReal (Real.exp (x*(n:ℝ)))≤(ENNReal.ofReal q)^(6*n) := by
+  rw [mul_comm x (n:ℝ),Real.exp_nat_mul]
+  exact ofReal_power_tail (Real.exp_pos x).le hq h n
+
+lemma grid_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 : ℕ) [Nontrivial (Fin n)] (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 (Fin 3→Fin K)),
+      groundPathLaw n L (α/D) T g {ω | ∀ v∈A,
+        θ*D≤((localCloseLabels L (spatialCloseScale D b) (gridCenter L v) (ω q)).card:ℝ)}≤
+        ENNReal.ofReal (((((Gθ/b^2)*D^(-(4/3):ℝ))^(1/(Q:ℝ)))^A.card)) := by
+  obtain ⟨Q,hQ,htail⟩ := spatial_translated_stationary_close_tail
+  refine ⟨Q,hQ,?_⟩
+  intro θ hθ
+  obtain ⟨b,G,hb,hb1,hG,hl,ht⟩ := htail θ hθ
+  refine ⟨b,G,hb,hb1,hG,hl,?_⟩
+  intro αmax
+  obtain ⟨D₀,hD₀,hh⟩ := ht αmax
+  refine ⟨D₀,hD₀,?_⟩
+  intro n K inst L hL D α hL100 hDeq hD hα hαmax g hg T hT q A
+  have h := hh n K L hL D α hL100 hDeq hD hα hαmax g hg T hT q (gridShift L) (A.image gridCube)
+  rw [Finset.card_image_of_injective _ gridCube_injective] at h
+  convert h using 1
+  congr 1
+  ext ω
+  simp only [Set.mem_ofPred_eq,Finset.mem_image,forall_exists_index,and_imp,forall_apply_eq_imp_iff₂,shifted_unitCenter]
+
+end HardSphere.Groups
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/InteractingVisits.lean

@@ -0,0 +1,285 @@
+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

lean/OAI/Analysis/HardSphere/PathBounds/LatticeExponentialSum.lean

@@ -0,0 +1,214 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.UnitCenter
+
+namespace OAI
+
+section
+section
+noncomputable section
+open MeasureTheory Filter Set
+open scoped ENNReal Topology BigOperators
+noncomputable section
+open scoped BigOperators ComplexConjugate
+noncomputable section
+open MeasureTheory ProbabilityTheory Filter Set
+open scoped ENNReal NNReal Topology BigOperators
+noncomputable section
+open MeasureTheory ProbabilityTheory Real Complex
+open scoped ENNReal ComplexConjugate
+open ProbabilityTheory
+noncomputable section
+open MeasureTheory Filter Set
+open scoped ENNReal Topology
+noncomputable section
+open MeasureTheory Set
+open scoped ENNReal
+namespace HardSphere
+open MeasureTheory Set Filter SphericalCoordinates
+open scoped ENNReal
+noncomputable section
+
+def latticeExponentialSum : ℝ := ∑' z : ℤ, Real.exp (-|(z:ℝ)|/3)
+
+lemma latticeExponential_summable : Summable (fun z : ℤ ↦ Real.exp (-|(z:ℝ)|/3)) := by
+  have h : Summable (fun n : ℕ ↦ Real.exp (-(n:ℝ)/3)) := by
+    have hg := summable_geometric_of_abs_lt_one (r:=Real.exp (-1/3)) (by
+      rw [abs_of_pos (Real.exp_pos _),Real.exp_lt_one_iff]; norm_num)
+    convert hg using 1
+    funext n
+    rw [←Real.exp_nat_mul]
+    congr 1
+    ring
+  apply Summable.of_nat_of_neg
+  · simpa using h
+  · simpa using h
+
+lemma latticeExponentialSum_pos : 0<latticeExponentialSum := by
+  have h := latticeExponential_summable.le_tsum 0 (fun _ _ ↦ (Real.exp_pos _).le)
+  simp only [Int.cast_zero,abs_zero,neg_zero,zero_div,Real.exp_zero] at h
+  exact lt_of_lt_of_le zero_lt_one h
+
+def periodicLatticeIndex {K : ℕ} (L : Length) (x : AddCircle L.val) (v : Fin K) : ℤ :=
+  (v.val:ℤ)-round (L.val⁻¹*((v.val:ℝ)+1/2-((AddCircle.equivIco L.val 0) x).val))*(K:ℤ)-
+    ⌊((AddCircle.equivIco L.val 0) x).val-1/2⌋
+
+lemma periodicLatticeIndex_injective {K : ℕ} {L : Length} (x : AddCircle L.val) :
+    Function.Injective (periodicLatticeIndex (K:=K) L x) := by
+  intro v w hvw
+  have h := congrArg (fun z : ℤ ↦ (z+⌊((AddCircle.equivIco L.val 0) x).val-1/2⌋)%(K:ℤ)) hvw
+  simp only [periodicLatticeIndex,sub_add_cancel,Int.sub_mul_emod_self_right] at h
+  rw [Int.emod_eq_of_lt (by omega) (by exact_mod_cast v.isLt),
+    Int.emod_eq_of_lt (by omega) (by exact_mod_cast w.isLt)] at h
+  exact Fin.ext (by exact_mod_cast h)
+
+lemma periodicLatticeIndex_bound {K : ℕ} {L : Length} (hL : L.val=(K:ℝ))
+    (x : AddCircle L.val) (v : Fin K) :
+    |(periodicLatticeIndex L x v:ℝ)|≤dist (((v.val:ℝ)+1/2:ℝ):AddCircle L.val) x+1 := by
+  let t := ((AddCircle.equivIco L.val 0) x).val
+  let δ := t-1/2-(⌊t-1/2⌋:ℝ)
+  have hδ0 : 0≤δ := Int.fract_nonneg (t-1/2)
+  have hδ1 : δ<1 := Int.fract_lt_one (t-1/2)
+  have hδ : |δ|≤1 := by rw [abs_of_nonneg hδ0]; exact hδ1.le
+  have hd : dist (((v.val:ℝ)+1/2:ℝ):AddCircle L.val) x=
+      |(periodicLatticeIndex L x v:ℝ)-δ| := by
+    conv_lhs => rw [←(show (t:AddCircle L.val)=x from AddCircle.coe_equivIco)]
+    rw [dist_eq_norm,←QuotientAddGroup.mk_sub,AddCircle.norm_eq]
+    congr 1
+    dsimp [periodicLatticeIndex,δ,t]
+    push_cast
+    rw [←hL]
+    simp only [Int.fract]
+    ring
+  rw [hd]
+  calc
+    _ = |((periodicLatticeIndex L x v:ℝ)-δ)+δ| := by congr 1; ring
+    _ ≤ |(periodicLatticeIndex L x v:ℝ)-δ|+|δ| := abs_add_le _ _
+    _ ≤ _ := add_le_add le_rfl hδ
+
+lemma circle_lattice_exponential_bound {K : ℕ} {L : Length} (hL : L.val=(K:ℝ))
+    (x : AddCircle L.val) :
+    (∑ v : Fin K, Real.exp (-dist (((v.val:ℝ)+1/2:ℝ):AddCircle L.val) x/3))≤
+      Real.exp (1/3)*latticeExponentialSum := by
+  classical
+  calc
+    _ ≤ ∑ v : Fin K, Real.exp (1/3)*Real.exp (-|(periodicLatticeIndex L x v:ℝ)|/3) := by
+      apply Finset.sum_le_sum
+      intro v _
+      rw [←Real.exp_add]
+      apply Real.exp_le_exp.mpr
+      have h := periodicLatticeIndex_bound hL x v
+      linarith only [h]
+    _ = Real.exp (1/3)*∑ v : Fin K, Real.exp (-|(periodicLatticeIndex L x v:ℝ)|/3) := (Finset.mul_sum ..).symm
+    _ ≤ _ := by
+      apply mul_le_mul_of_nonneg_left _ (Real.exp_pos _).le
+      rw [←Finset.sum_image (f:=fun z : ℤ ↦ Real.exp (-|(z:ℝ)|/3)) (s:=Finset.univ) (periodicLatticeIndex_injective x).injOn]
+      exact latticeExponential_summable.sum_le_tsum _ (fun _ _ ↦ (Real.exp_pos _).le)
+
+lemma torus_exp_le_coordinate_exp (L : Length) (x y : Torus L) :
+    Real.exp (-torusDistance L x y)≤Real.exp (-dist (x 0) (y 0)/3)*
+      Real.exp (-dist (x 1) (y 1)/3)*Real.exp (-dist (x 2) (y 2)/3) := by
+  rw [←Real.exp_add,←Real.exp_add]
+  apply Real.exp_le_exp.mpr
+  have h0 := coordinate_distance_le L x y 0
+  have h1 := coordinate_distance_le L x y 1
+  have h2 := coordinate_distance_le L x y 2
+  linarith only [h0,h1,h2]
+
+theorem unitGrid_exponential_bound : ∃ C : ℝ, 0<C ∧
+    ∀ (K : ℕ) (L : Length), L.val=(K:ℝ) → ∀ x : Torus L,
+      (∑ v : CubeCell K, Real.exp (-torusDistance L (unitCenter L v) x))≤C := by
+  let B := Real.exp (1/3)*latticeExponentialSum
+  have hB : 0<B := mul_pos (Real.exp_pos _) latticeExponentialSum_pos
+  refine ⟨B^3,pow_pos hB _,?_⟩
+  intro K L hL x
+  let f := fun (j : Fin 3) (v : Fin K) ↦ Real.exp (-dist (((v.val:ℝ)+1/2:ℝ):AddCircle L.val) (x j)/3)
+  have hb (j : Fin 3) : (∑ v, f j v)≤B := circle_lattice_exponential_bound hL (x j)
+  have hn (j : Fin 3) : 0≤∑ v, f j v := Finset.sum_nonneg (fun _ _ ↦ (Real.exp_pos _).le)
+  calc
+    _ ≤ ∑ v : CubeCell K, f 0 v.1*f 1 v.2.1*f 2 v.2.2 := by
+      apply Finset.sum_le_sum
+      intro v _
+      exact torus_exp_le_coordinate_exp L (unitCenter L v) x
+    _ = (∑ v, f 0 v)*(∑ v, f 1 v)*(∑ v, f 2 v) := by
+      simp_rw [Fintype.sum_prod_type,←Finset.mul_sum,←Finset.sum_mul]
+      rw [←Fintype.sum_mul_sum]
+    _ ≤ B*B*B := mul_le_mul (mul_le_mul (hb 0) (hb 1) (hn 1) hB.le) (hb 2) (hn 2) (mul_nonneg hB.le hB.le)
+    _ = B^3 := by ring
+
+end
+end HardSphere
+
+namespace HardSphere
+open MeasureTheory Set Filter SphericalCoordinates
+open scoped ENNReal
+noncomputable section
+
+lemma unitGrid_site_exponential_bound : ∃ C : ℝ, 0<C ∧
+    ∀ (K : ℕ) (L : Length), L.val=(K:ℝ) → ∀ (A : Finset (Torus L)), A.Nonempty →
+      (∑ v : CubeCell K, Real.exp (-spatialSiteDistance L A (unitCenter L v)))≤C*(A.card:ℝ) := by
+  obtain ⟨C,hC,h⟩ := unitGrid_exponential_bound
+  refine ⟨C,hC,?_⟩
+  intro K L hL A hA
+  calc
+    _ ≤ ∑ v : CubeCell K, ∑ w∈A, Real.exp (-torusDistance L (unitCenter L v) w) := by
+      apply Finset.sum_le_sum
+      intro v _
+      obtain ⟨w,hw,he⟩ := spatialSiteDistance_attained L A hA (unitCenter L v)
+      rw [he]
+      exact Finset.single_le_sum (f:=fun w ↦ Real.exp (-torusDistance L (unitCenter L v) w)) (fun _ _ ↦ (Real.exp_pos _).le) hw
+    _ = ∑ w∈A, ∑ v : CubeCell K, Real.exp (-torusDistance L (unitCenter L v) w) := Finset.sum_comm
+    _ ≤ ∑ _w∈A, C := Finset.sum_le_sum (fun w _ ↦ h K L hL w)
+    _ = _ := by rw [Finset.sum_const, nsmul_eq_mul,mul_comm]
+
+lemma unitOccupation_full_card {n K : ℕ} {L : Length} (hL : L.val=(K:ℝ))
+    (v : CubeCell K) (X : Configuration n L) :
+    unitOccupation hL (fun _ ↦ True) v X=Fintype.card {i : Fin n // unitSite hL (X i)=v} := by
+  classical
+  apply Fintype.card_congr
+  exact {
+    toFun := fun i ↦ ⟨i.val.val,i.property⟩
+    invFun := fun i ↦ ⟨⟨i.val,trivial⟩,i.property⟩
+    left_inv := fun _ ↦ rfl
+    right_inv := fun _ ↦ rfl }
+
+lemma unitOccupation_sum_weight {n K : ℕ} {L : Length} (hL : L.val=(K:ℝ))
+    (a : CubeCell K → ℝ) (X : Configuration n L) :
+    (∑ v : CubeCell K, a v*(unitOccupation hL (fun _ ↦ True) v X:ℝ))=
+      ∑ i : Fin n, a (unitSite hL (X i)) := by
+  classical
+  rw [←Fintype.sum_fiberwise (fun i : Fin n ↦ unitSite hL (X i)) (fun i ↦ a (unitSite hL (X i)))]
+  apply Finset.sum_congr rfl
+  intro v _
+  simp only [unitOccupation_full_card]
+  have he : (fun i : {i : Fin n // unitSite hL (X i)=v} ↦ a (unitSite hL (X i.val)))=fun _ ↦ a v := by
+    funext i
+    rw [i.property]
+  rw [he,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_comm]
+
+lemma weightedSiteCount_le_cell {n K : ℕ} {L : Length} (hL : L.val=(K:ℝ))
+    (A : Finset (Torus L)) (hA : A.Nonempty) (X : Configuration n L) :
+    weightedSiteCount L A X≤Real.exp 1*(∑ v : CubeCell K,
+      Real.exp (-spatialSiteDistance L A (unitCenter L v))*(unitOccupation hL (fun _ ↦ True) v X:ℝ)) := by
+  rw [unitOccupation_sum_weight,Finset.mul_sum,weightedSiteCount,ite_eq_left hA]
+  apply Finset.sum_le_sum
+  intro i _
+  rw [←Real.exp_add]
+  apply Real.exp_le_exp.mpr
+  have hd := spatialSiteDistance_triangle L A (unitCenter L (unitSite hL (X i))) (X i)
+  have hc := unitSite_dist_center hL (X i)
+  rw [torusDistance_comm] at hd
+  linarith only [hd,hc]
+
+end
+end HardSphere
+
+end
+end
+end
+end
+end
+end
+end
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/PathTailConstant.lean

@@ -0,0 +1,257 @@
+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

lean/OAI/Analysis/HardSphere/PathBounds/PhysicalVisitTails.lean

@@ -0,0 +1,174 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Bridges.EndpointTail
+import OAI.Analysis.HardSphere.PathBounds.VisitCounts
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.FreeVisits
+open Wiener PathCutoff BathSlice HardSphere.Lattice CellOrbital
+
+theorem ground_excessVisitors_tail :
+    ∃ αstar : ℝ, 0<αstar ∧ ∀ αmax : ℝ, 0<αmax →
+    ∃ H : ℝ, 0<H ∧ ∀ (n K : ℕ) [NeZero K] (L : Length), L.val=(K:ℝ) →
+    ∀ r D : ℝ, D=(n:ℝ)/L.val^3 → 1≤D → αstar≤D*r → D*r≤αmax → 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 →
+      groundPathLaw n L r t g {ω | ∀v∈A,H*D≤(visitorCount L Set.univ v ω:ℝ)}≤
+        ENNReal.ofReal (Real.exp (-(D*(A.card:ℝ)))) := by
+  obtain ⟨Cd,Cf,Cs,α,hCd,hCf,hCs,hα,hm⟩ := interacting_visit_mgf (η₀:=1) (by norm_num)
+  refine ⟨α,hα,?_⟩
+  intro αmax hαmax
+  let B := Real.exp (2*Cd*αmax)*Cf
+  have hB : 0<B := by dsimp [B]; positivity
+  let η := min 1 B⁻¹
+  have hη : 0<η := lt_min (by norm_num) (inv_pos.mpr hB)
+  have hη1 : η≤1 := min_le_left _ _
+  have hb : B*η≤1 := by
+    calc
+      B*η≤B*B⁻¹ := mul_le_mul_of_nonneg_left (min_le_right _ _) hB.le
+      _ = 1 := mul_inv_cancel₀ hB.ne'
+  let H := (Cs+1)/η
+  have hH : 0<H := div_pos (by linarith) hη
+  refine ⟨H,hH,?_⟩
+  intro n K inst L hL r D hDeq hD hαr hαup hr hs g hg A t ht ht2
+  have hD0 : 0≤D := by linarith
+  have hxp : t*Cd*D*r≤2*Cd*αmax := by
+    calc
+      t*Cd*D*r = (t*Cd)*(D*r) := by ring
+      _ ≤ (t*Cd)*αmax := mul_le_mul_of_nonneg_left hαup (by positivity)
+      _ ≤ (2*Cd)*αmax := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right ht2 hCd.le) hαmax.le
+  have hz : Real.exp (t*Cd*D*r)*(Cf*η*(1:ℝ)^(1/3:ℝ))≤1 := by
+    simp only [Real.one_rpow,mul_one]
+    calc
+      _ ≤ Real.exp (2*Cd*αmax)*(Cf*η) := mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr hxp) (by positivity)
+      _ = B*η := by dsimp [B]; ring
+      _ ≤ 1 := hb
+  have hp (y : Torus L) : coordinateWiener 1 {w | freeTrajectory 1 L t w (oneConfiguration y)∈(Set.univ : Set (ConfigurationPath 1 L))}≤ENNReal.ofReal 1 := by simp
+  have hh := hm n K L hL r D hDeq hD hαr hr hs g hg A ht ht2 hη.le hη1
+    (by norm_num : (0:ℝ)≤1) Set.univ MeasurableSet.univ (fun _ ↦ Iff.rfl) hp hz
+  have hj := joint_visitors_markov L A MeasurableSet.univ (groundPathLaw n L r t g) hη.le hh (H:=H*D)
+  apply hj.trans
+  apply ENNReal.ofReal_le_ofReal
+  apply Real.exp_le_exp.mpr
+  rw [←neg_mul]
+  apply mul_le_mul_of_nonneg_right _ (Nat.cast_nonneg A.card)
+  have hhH : η*H=Cs+1 := by dsimp [H]; field_simp
+  have he : Cs*(Real.exp (t*Cd*D*r)*(Cf*η*(1:ℝ)^(1/3:ℝ)))*D≤Cs*D := by
+    exact (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hz hCs.le) hD0).trans_eq (by ring)
+  change _≤ -D
+  nlinarith
+
+end HardSphere.FreeVisits
+
+end
+end
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.FreeVisits
+open Wiener PathCutoff HardSphere.Lattice
+
+theorem free_long_probability_small {ε : ℝ} (hε : 0<ε) :
+    ∃ t₀ : ℝ, 0<t₀ ∧ ∀ (L : Length) {t : ℝ},0<t→t≤t₀→∀y : Torus L,
+      coordinateWiener 1 {w | 1 < intervalDiameter 0 1 (freeTrajectory 1 L t w (oneConfiguration y))}≤
+        ENNReal.ofReal ε := by
+  obtain ⟨c,M,hc,hM,htail⟩ := wiener_norm_gaussian_tail
+  have hlim : Tendsto (fun q:ℝ ↦ (3*M.toReal)*Real.exp (-q)) atTop (𝓝 0) := by
+    simpa using Real.tendsto_exp_neg_atTop_nhds_zero.const_mul (3*M.toReal)
+  obtain ⟨T,hT,hsmall⟩ := ((eventually_gt_atTop (0:ℝ)).and
+    (hlim.eventually (gt_mem_nhds hε))).exists
+  refine ⟨c/(1296*T),by positivity,?_⟩
+  intro L t ht htt y
+  apply (free_diameter_tail htail ht (by norm_num : (0:ℝ)≤1) (oneConfiguration y)).trans
+  have hsq : c*(1/(36*Real.sqrt t))^2=c/(1296*t) := by
+    rw [div_pow,mul_pow,Real.sq_sqrt ht.le]
+    norm_num
+    ring
+  have hcT : T≤c/(1296*t) := by
+    apply (le_div_iff₀ (by positivity : 0<(1296:ℝ)*t)).mpr
+    have hh := (le_div_iff₀ (by positivity : 0<(1296:ℝ)*T)).mp htt
+    nlinarith
+  have hm : (3:ℝ≥0∞)*M=ENNReal.ofReal (3*M.toReal) := by
+    rw [ENNReal.ofReal_mul (by norm_num : (0:ℝ)≤3),ENNReal.ofReal_toReal hM.ne]
+    norm_num
+  rw [hm,←ENNReal.ofReal_mul (by positivity : (0:ℝ)≤3*M.toReal)]
+  apply ENNReal.ofReal_le_ofReal
+  apply le_trans _ hsmall.le
+  apply mul_le_mul_of_nonneg_left _ (by positivity)
+  apply Real.exp_le_exp.mpr
+  nlinarith [hsq]
+
+theorem ground_longVisitors_tail :
+    ∃ αstar : ℝ, 0<αstar ∧ ∀ αmax θ : ℝ, 0<αmax → 0<θ →
+    ∃ t₀ : ℝ, 0<t₀ ∧ ∀ (n K : ℕ) [NeZero K] (L : Length), L.val=(K:ℝ) →
+    ∀ r D : ��, D=(n:ℝ)/L.val^3 → 1≤D → αstar≤D*r → D*r≤αmax → 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 ≤ min 2 t₀ →
+      groundPathLaw n L r t g {ω | ∀v∈A,θ*D≤
+        (visitorCount L {p | 1 < intervalDiameter 0 1 p} v ω:ℝ)}≤
+        ENNReal.ofReal (Real.exp (-(θ*D/2)*(A.card:ℝ))) := by
+  obtain ⟨Cd,Cf,Cs,α,hCd,hCf,hCs,hα,hm⟩ := interacting_visit_mgf (η₀:=1) (by norm_num)
+  refine ⟨α,hα,?_⟩
+  intro αmax θ hαmax hθ
+  let B := Real.exp (2*Cd*αmax)*Cf
+  have hB : 0<B := by dsimp [B]; positivity
+  let δ := min 1 (θ/(2*Cs))
+  have hδ : 0<δ := lt_min (by norm_num) (by positivity)
+  let ε := (δ/B)^3
+  have hε : 0<ε := by dsimp [ε]; positivity
+  have hrp : ε^(1/3:ℝ)=δ/B := by
+    simpa [ε] using Real.pow_rpow_inv_natCast (n:=3) (div_pos hδ hB).le (by norm_num : (3:ℕ)≠0)
+  obtain ⟨t₀,ht₀,hsmall⟩ := free_long_probability_small hε
+  refine ⟨t₀,ht₀,?_⟩
+  intro n K inst L hL r D hDeq hD hαr hαup hr hs g hg A t ht htt
+  have ht2 := (le_min_iff.mp htt).1
+  have hD0 : 0≤D := by linarith
+  have hxp : t*Cd*D*r≤2*Cd*αmax := by
+    calc
+      t*Cd*D*r = (t*Cd)*(D*r) := by ring
+      _ ≤ (t*Cd)*αmax := mul_le_mul_of_nonneg_left hαup (by positivity)
+      _ ≤ (2*Cd)*αmax := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right ht2 hCd.le) hαmax.le
+  have hzδ : Real.exp (t*Cd*D*r)*(Cf*1*ε^(1/3:ℝ))≤δ := by
+    rw [hrp,mul_one]
+    calc
+      _ ≤ Real.exp (2*Cd*αmax)*(Cf*(δ/B)) := mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr hxp) (by positivity)
+      _ = δ := by dsimp [B]; field_simp
+  have hz1 := hzδ.trans (min_le_left 1 (θ/(2*Cs)))
+  let E : Set (ConfigurationPath 1 L) := {p | 1 < intervalDiameter 0 1 p}
+  have hE : MeasurableSet E := measurableSet_lt measurable_const (intervalDiameter_continuous L 0 1).measurable
+  have hrev (p : ConfigurationPath 1 L) : reverseConfigurationPath 1 L p∈E↔p∈E := by
+    simp only [E,Set.mem_ofPred_eq,intervalDiameter_reverse,reverseTime_zero,reverseTime_one]
+  have hp (y : Torus L) : coordinateWiener 1 {w | freeTrajectory 1 L t w (oneConfiguration y)∈E}≤ENNReal.ofReal ε :=
+    hsmall L ht (le_min_iff.mp htt).2 y
+  have hh := hm n K L hL r D hDeq hD hαr hr hs g hg A ht ht2 (by norm_num : (0:ℝ)≤1)
+    (le_refl 1) hε.le E hE hrev hp hz1
+  have hj := joint_visitors_markov L A hE (groundPathLaw n L r t g) (by norm_num : (0:ℝ)≤1) hh (H:=θ*D)
+  apply hj.trans
+  apply ENNReal.ofReal_le_ofReal
+  apply Real.exp_le_exp.mpr
+  apply mul_le_mul_of_nonneg_right _ (Nat.cast_nonneg A.card)
+  have hδθ : Cs*δ≤θ/2 := by
+    have hh := (le_div_iff₀ (by positivity : 0<(2:ℝ)*Cs)).mp (min_le_right 1 (θ/(2*Cs)))
+    dsimp [δ]
+    linarith
+  have hc := mul_le_mul_of_nonneg_right ((mul_le_mul_of_nonneg_left hzδ hCs.le).trans hδθ) hD0
+  nlinarith
+
+end HardSphere.FreeVisits
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/RegularVisitors.lean

@@ -0,0 +1,94 @@
+import Mathlib
+import OAI.Analysis.HardSphere.PathBounds.VisitCounts
+import OAI.Analysis.HardSphere.Cutoffs.StandardRegular
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.FreeVisits
+open Wiener PathCutoff HardSphere.Lattice
+
+theorem ground_regularVisitors_tail (η : ℝ) (hη : 0 < η) :
+    ∃ αstar : ℝ, 0 < αstar ∧ ∀ αmax C a b : ℝ,
+      0 < αmax → 0 < C → 0 < a → 0 < b →
+    ∃ D₀ : ℝ, 1 ≤ D₀ ∧ ∀ (n K : ℕ) [NeZero K] (L : Length), L.val=(K:ℝ) →
+    ∀ r D : ℝ, D=(n:ℝ)/L.val^3 → D₀ ≤ D → αstar ≤ D*r → D*r ≤ αmax → 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))
+    (m : ℕ) (τ : ℝ), 0 < m → 0 < τ → τ ≤ r^2 →
+      a*D^2 ≤ (m:ℝ) → (m:ℝ) ≤ C*D^2 → (m:ℝ)*τ ≤ 2 →
+    ∀ (hD : 0 < D) (hhT : D⁻¹ < (m:ℝ)*τ),
+      groundPathLaw n L r ((m:ℝ)*τ) g {ω | ∀v∈A,1 ≤
+        (visitorCount L {p | ¬Regular m r (D^(1/12:ℝ)) (meanCost+1)
+          (splitTime D⁻¹ ((m:ℝ)*τ-D⁻¹) (inv_pos.mpr hD) (sub_pos.mpr hhT))
+          (b*D^(-(1/3:ℝ))/8) p} v ω:ℝ)} ≤
+        ENNReal.ofReal (Real.exp (-(η/2)*(A.card:ℝ))) := by
+  obtain ⟨c,M,hc,hM,htail⟩ := wiener_norm_gaussian_tail
+  obtain ⟨Cd,Cf,Cs,α,hCd,hCf,hCs,hα,hm⟩ := interacting_visit_mgf (η₀:=η) hη.le
+  refine ⟨α,hα,?_⟩
+  intro αmax C a b hαmax hC ha hb
+  let ε := fun D : ℝ ↦ scalarRegularBound C (3*M.toReal) c a b D
+  let B := Real.exp (2*Cd*αmax)*Cf*η
+  have hB : 0 < B := by dsimp [B]; positivity
+  let δ := min 1 (η/(2*Cs))
+  have hδ : 0 < δ := lt_min (by norm_num) (by positivity)
+  have hlim : Tendsto (fun D : ℝ ↦ B*(D*(ε D)^(1/3:ℝ))) atTop (𝓝 0) := by
+    simpa using (regular_root_decay hC.le (by positivity : 0 ≤ 3*M.toReal) hc ha hb).const_mul B
+  obtain ⟨D₀,hsmall⟩ := (eventually_atTop.1
+    ((eventually_ge_atTop (1:ℝ)).and (hlim.eventually (gt_mem_nhds hδ))))
+  refine ⟨max 1 D₀,le_max_left _ _,?_⟩
+  intro n K inst L hL r D hDeq hDD hαr hαup hr hs g hg A m τ hmpos hτ hτr hmlo hmhi ht2 hD hhT
+  have hD1 : 1 ≤ D := (le_max_left _ _).trans hDD
+  have hsmallD : B*(D*(ε D)^(1/3:ℝ)) ≤ δ := ((hsmall D ((le_max_right _ _).trans hDD)).2).le
+  have hε : 0 ≤ ε D := scalarRegularBound_nonneg hC.le (by positivity) c a b D
+  have ht : 0 < (m:ℝ)*τ := mul_pos (Nat.cast_pos.mpr hmpos) hτ
+  have hxp : ((m:ℝ)*τ)*Cd*D*r ≤ 2*Cd*αmax := by
+    calc
+      _ = (((m:ℝ)*τ)*Cd)*(D*r) := by ring
+      _ ≤ (((m:ℝ)*τ)*Cd)*αmax := mul_le_mul_of_nonneg_left hαup (by positivity)
+      _ ≤ (2*Cd)*αmax := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right ht2 hCd.le) hαmax.le
+  let z := Real.exp (((m:ℝ)*τ)*Cd*D*r)*(Cf*η*(ε D)^(1/3:ℝ))
+  have hz : 0 ≤ z := by dsimp [z]; positivity
+  have hzD : z*D ≤ δ := by
+    apply le_trans _ hsmallD
+    calc
+      _ ≤ Real.exp (2*Cd*αmax)*(Cf*η*(ε D)^(1/3:ℝ))*D := by
+        dsimp [z]
+        exact mul_le_mul_of_nonneg_right
+          (mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr hxp) (by positivity)) hD.le
+      _ = B*(D*(ε D)^(1/3:ℝ)) := by dsimp [B]; ring
+  have hz1 : z ≤ 1 := (by nlinarith : z ≤ z*D).trans (hzD.trans (min_le_left _ _))
+  let E : Set (ConfigurationPath 1 L) := {p | ¬Regular m r (D^(1/12:ℝ)) (meanCost+1)
+    (splitTime D⁻¹ ((m:ℝ)*τ-D⁻¹) (inv_pos.mpr hD) (sub_pos.mpr hhT)) (b*D^(-(1/3:ℝ))/8) p}
+  have hE : MeasurableSet E := (regular_measurable _ _ _ _ _ _).compl
+  have hrev (p : ConfigurationPath 1 L) : reverseConfigurationPath 1 L p∈E ↔ p∈E :=
+    (regular_reverse _ _ _ _ _ _ p).not
+  have hp (y : Torus L) : coordinateWiener 1 {w | freeTrajectory 1 L ((m:ℝ)*τ) w (oneConfiguration y)∈E} ≤ ENNReal.ofReal (ε D) :=
+    free_regular_standard_tail hM.ne htail hr hτ hτr hc.le hD1 hC.le ha.le hb.le m hmpos hmlo hmhi hhT (oneConfiguration y)
+  have hh := hm n K L hL r D hDeq hD1 hαr hr hs g hg A ht ht2 hη.le (le_refl η) hε E hE hrev hp hz1
+  have hj := joint_visitors_markov L A hE (groundPathLaw n L r ((m:ℝ)*τ) g) hη.le hh (H:=1)
+  apply hj.trans
+  apply ENNReal.ofReal_le_ofReal
+  apply Real.exp_le_exp.mpr
+  apply mul_le_mul_of_nonneg_right _ (Nat.cast_nonneg A.card)
+  have hδη : Cs*δ ≤ η/2 := by
+    have hh := (le_div_iff₀ (by positivity : 0 < (2:ℝ)*Cs)).mp (min_le_right 1 (η/(2*Cs)))
+    dsimp [δ]
+    linarith
+  have hcost := (mul_le_mul_of_nonneg_left hzD hCs.le).trans hδη
+  change Cs*z*D-η*1 ≤ -(η/2)
+  nlinarith
+
+end HardSphere.FreeVisits
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/ShiftInteracting.lean

@@ -0,0 +1,190 @@
+import Mathlib
+import OAI.Analysis.HardSphere.PathBounds.InteractingVisits
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.ShiftVisits
+open HardSphere.Wiener HardSphere.Lattice HardSphere.CellOrbital HardSphere.BathSlice HardSphere.FreeVisits
+attribute [local irreducible] freeTrajectory
+def defectiveTotalVisits {n K : ℕ} (L : Length) (c : Torus L) (A : Finset (DiscreteTorus K))
+    (D : Set (ConfigurationPath 1 L)) (ω : ConfigurationPath n L) : ℕ := by
+  classical
+  exact ∑ i, if onePathAt i ω∈D then (pathVisitedSites L (center L c) A i ω).card else 0
+
+lemma pathVisitedSites_onePathAt {n K : ℕ} (L : Length) (c : Torus L) (A : Finset (DiscreteTorus K))
+    (i : Fin n) (ω : ConfigurationPath n L) :
+    pathVisitedSites L (center L c) A 0 (onePathAt i ω)=pathVisitedSites L (center L c) A i ω := by
+  simp only [pathVisitedSites,pathVisitsBall,onePathAt,oneConfiguration,ContinuousMap.coe_mk]
+  rfl
+
+lemma exp_defectiveTotalVisits {n K : ℕ} (L : Length) (c : Torus L) (A : Finset (DiscreteTorus K))
+    (D : Set (ConfigurationPath 1 L)) {η : ℝ} (hη : 0≤η) (ω : ConfigurationPath n L) :
+    ENNReal.ofReal (Real.exp (η*(defectiveTotalVisits L c A D ω : ℝ)))=
+      ∏ i, (1+singleDefect L c 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 [singleDefect,pathVisitedSites_onePathAt]
+  have hx : 0≤η*(if onePathAt i ω∈D then ((pathVisitedSites L (center L c) A i ω).card:ℝ) else 0) := by positivity
+  have he : 0≤Real.exp (η*(if onePathAt i ω∈D then ((pathVisitedSites L (center L c) 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
+
+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 →
+    ∀ (c : Torus L) (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 c 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 c 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 (center L c)
+    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+singleDefect L c A η E (onePathAt i ω)) ∂groundPathLaw n L r t g :=
+        lintegral_congr (exp_defectiveTotalVisits L c A E hη)
+      _ ≤ ∫⁻ X,∏i,(1+ENNReal.ofReal (Real.exp (t*Cdel*(n:ℝ)*r/L.val^3))*
+          oneFreeExpectation t (singleDefect L c A η E) (X i)) ∂groundPositionLaw n L g :=
+        hdel n L r t hr ht hs g hg _ (singleDefect_measurable L c A η hE) (singleDefect_reverse L c 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 c 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 HardSphere.ShiftVisits
+
+end
+end
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.ShiftVisits
+open HardSphere.Wiener HardSphere.BathSlice HardSphere.Lattice HardSphere.CellOrbital HardSphere.FreeVisits
+
+def visitorCount {n K : ℕ} (L : Length) (c : Torus L) (E : Set (ConfigurationPath 1 L))
+    (v : DiscreteTorus K) (ω : ConfigurationPath n L) : ℕ := by
+  classical
+  exact (Finset.univ.filter (fun i : Fin n ↦ onePathAt i ω∈E ∧ pathVisitsBall L 12 (center L c v) i ω)).card
+
+lemma visitorCount_sum {n K : ℕ} (L : Length) (c : Torus L) (A : Finset (DiscreteTorus K))
+    (E : Set (ConfigurationPath 1 L)) (ω : ConfigurationPath n L) :
+    (∑v∈A,visitorCount L c E v ω)=defectiveTotalVisits L c A E ω := by
+  classical
+  simp only [visitorCount,Finset.card_filter]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro i _
+  by_cases hi : onePathAt i ω∈E
+  · simp only [hi,true_and,pathVisitedSites,ite_eq_left,Finset.card_filter]
+  · simp only [hi,false_and,ite_false,Finset.sum_const_zero,pathVisitedSites]
+
+lemma visitorCount_measurable {n K : ℕ} (L : Length) (c : Torus L) {E : Set (ConfigurationPath 1 L)}
+    (hE : MeasurableSet E) (v : DiscreteTorus K) : Measurable (visitorCount (n:=n) L c E v) := by
+  classical
+  have he : visitorCount (n:=n) L c E v=(fun ω ↦ ∑i : Fin n, if onePathAt i ω∈E ∧ pathVisitsBall L 12 (center L c v) i ω then (1:ℕ) else 0) := by
+    funext ω
+    simp only [visitorCount,Finset.card_filter]
+  rw [he]
+  apply Finset.measurable_fun_sum
+  intro i _
+  have hi : MeasurableSet {ω : ConfigurationPath n L | onePathAt i ω∈E} := hE.preimage (onePathAt_continuous i).measurable
+  exact measurable_const.ite (hi.inter (pathVisitsBall_isClosed L 12 (center L c v) i).measurableSet) measurable_const
+
+lemma defectiveTotalVisits_measurable {n K : ℕ} (L : Length) (c : Torus L) (A : Finset (DiscreteTorus K))
+    {E : Set (ConfigurationPath 1 L)} (hE : MeasurableSet E) : Measurable (defectiveTotalVisits (n:=n) L c A E) := by
+  have he : defectiveTotalVisits (n:=n) L c A E=fun ω ↦ ∑v∈A,visitorCount L c E v ω := by
+    funext ω; exact (visitorCount_sum L c A E ω).symm
+  rw [he]
+  exact Finset.measurable_fun_sum _ (fun v _ ↦ visitorCount_measurable L c hE v)
+
+lemma joint_visitor_sum {n K : ℕ} (L : Length) (c : Torus L) (A : Finset (DiscreteTorus K))
+    (E : Set (ConfigurationPath 1 L)) {H : ℝ} {ω : ConfigurationPath n L}
+    (h : ∀v∈A,H≤(visitorCount L c E v ω:ℝ)) :
+    H*(A.card:ℝ)≤(defectiveTotalVisits L c A E ω:ℝ) := by
+  rw [←visitorCount_sum L c A E ω,Nat.cast_sum]
+  have hs := Finset.sum_le_sum h
+  simpa only [Finset.sum_const,nsmul_eq_mul,mul_comm] using hs
+
+lemma joint_visitors_markov {n K : ℕ} (L : Length) (c : Torus L) (A : Finset (DiscreteTorus K))
+    {E : Set (ConfigurationPath 1 L)} (hE : MeasurableSet E)
+    (μ : Measure (ConfigurationPath n L)) {η H Q : ℝ} (hη : 0≤η)
+    (hmgf : (∫⁻ω,ENNReal.ofReal (Real.exp (η*(defectiveTotalVisits L c A E ω:ℝ))) ∂μ)≤
+      ENNReal.ofReal (Real.exp (Q*(A.card:ℝ)))) :
+    μ {ω | ∀v∈A,H≤(visitorCount L c E v ω:ℝ)}≤ENNReal.ofReal (Real.exp ((Q-η*H)*(A.card:ℝ))) := by
+  let F := fun ω : ConfigurationPath n L ↦ ENNReal.ofReal (Real.exp (η*(defectiveTotalVisits L c A E ω:ℝ)))
+  have hc : Measurable (fun k : ℕ ↦ (k:ℝ)) := measurable_of_countable _
+  have hF : Measurable F := ((measurable_const.mul (hc.comp (defectiveTotalVisits_measurable L c A hE))).exp).ennreal_ofReal
+  have hp : ENNReal.ofReal (Real.exp (η*(H*(A.card:ℝ))))≠0 := ne_of_gt (ENNReal.ofReal_pos.mpr (Real.exp_pos _))
+  have hm := meas_ge_le_lintegral_div (μ:=μ) hF.aemeasurable hp ENNReal.ofReal_ne_top
+  calc
+    _ ≤ μ {ω | ENNReal.ofReal (Real.exp (η*(H*(A.card:ℝ))))≤F ω} := by
+      apply measure_mono
+      intro ω hω
+      apply ENNReal.ofReal_le_ofReal
+      apply Real.exp_le_exp.mpr
+      exact mul_le_mul_of_nonneg_left (joint_visitor_sum L c A E hω) hη
+    _ ≤ _ := hm
+    _ ≤ ENNReal.ofReal (Real.exp (Q*(A.card:ℝ)))/ENNReal.ofReal (Real.exp (η*(H*(A.card:ℝ)))) := ENNReal.div_le_div_right hmgf _
+    _ = _ := by
+      rw [←ENNReal.ofReal_div_of_pos (Real.exp_pos _),←Real.exp_sub]
+      congr 2
+      ring
+
+end HardSphere.ShiftVisits
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/ShiftTails.lean

@@ -0,0 +1,133 @@
+import Mathlib
+import OAI.Analysis.HardSphere.PathBounds.ShiftInteracting
+import OAI.Analysis.HardSphere.PathBounds.PhysicalVisitTails
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.ShiftVisits
+open Wiener PathCutoff BathSlice HardSphere.Lattice CellOrbital HardSphere.FreeVisits
+
+theorem ground_excessVisitors_tail :
+    ∃ αstar : ℝ, 0<αstar ∧ ∀ αmax : ℝ, 0<αmax →
+    ∃ H : ℝ, 0<H ∧ ∀ (n K : ℕ) [NeZero K] (L : Length), L.val=(K:ℝ) →
+    ∀ r D : ℝ, D=(n:ℝ)/L.val^3 → 1≤D → αstar≤D*r → D*r≤αmax → 0<r →
+      (n:ℝ)*(2*Real.pi*r)^3≤L.val^3/2 →
+    ∀ (g : Jet n L), IsGroundVector n L r g → ∀ (x₀ : Torus L) (A : Finset (DiscreteTorus K)) {t : ℝ},
+      0<t → t≤2 →
+      groundPathLaw n L r t g {ω | ∀v∈A,H*D≤(visitorCount L x₀ Set.univ v ω:ℝ)}≤
+        ENNReal.ofReal (Real.exp (-(D*(A.card:ℝ)))) := by
+  obtain ⟨Cd,Cf,Cs,α,hCd,hCf,hCs,hα,hm⟩ := interacting_visit_mgf (η₀:=1) (by norm_num)
+  refine ⟨α,hα,?_⟩
+  intro αmax hαmax
+  let B := Real.exp (2*Cd*αmax)*Cf
+  have hB : 0<B := by dsimp [B]; positivity
+  let η := min 1 B⁻¹
+  have hη : 0<η := lt_min (by norm_num) (inv_pos.mpr hB)
+  have hη1 : η≤1 := min_le_left _ _
+  have hb : B*η≤1 := by
+    calc
+      B*η≤B*B⁻¹ := mul_le_mul_of_nonneg_left (min_le_right _ _) hB.le
+      _ = 1 := mul_inv_cancel₀ hB.ne'
+  let H := (Cs+1)/η
+  have hH : 0<H := div_pos (by linarith) hη
+  refine ⟨H,hH,?_⟩
+  intro n K inst L hL r D hDeq hD hαr hαup hr hs g hg x₀ A t ht ht2
+  have hD0 : 0≤D := by linarith
+  have hxp : t*Cd*D*r≤2*Cd*αmax := by
+    calc
+      t*Cd*D*r = (t*Cd)*(D*r) := by ring
+      _ ≤ (t*Cd)*αmax := mul_le_mul_of_nonneg_left hαup (by positivity)
+      _ ≤ (2*Cd)*αmax := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right ht2 hCd.le) hαmax.le
+  have hz : Real.exp (t*Cd*D*r)*(Cf*η*(1:ℝ)^(1/3:ℝ))≤1 := by
+    simp only [Real.one_rpow,mul_one]
+    calc
+      _ ≤ Real.exp (2*Cd*αmax)*(Cf*η) := mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr hxp) (by positivity)
+      _ = B*η := by dsimp [B]; ring
+      _ ≤ 1 := hb
+  have hp (y : Torus L) : coordinateWiener 1 {w | freeTrajectory 1 L t w (oneConfiguration y)∈(Set.univ : Set (ConfigurationPath 1 L))}≤ENNReal.ofReal 1 := by simp
+  have hh := hm n K L hL r D hDeq hD hαr hr hs g hg x₀ A ht ht2 hη.le hη1
+    (by norm_num : (0:ℝ)≤1) Set.univ MeasurableSet.univ (fun _ ↦ Iff.rfl) hp hz
+  have hj := joint_visitors_markov L x₀ A MeasurableSet.univ (groundPathLaw n L r t g) hη.le hh (H:=H*D)
+  apply hj.trans
+  apply ENNReal.ofReal_le_ofReal
+  apply Real.exp_le_exp.mpr
+  rw [←neg_mul]
+  apply mul_le_mul_of_nonneg_right _ (Nat.cast_nonneg A.card)
+  have hhH : η*H=Cs+1 := mul_div_cancel₀ _ hη.ne'
+  have he : Cs*(Real.exp (t*Cd*D*r)*(Cf*η*(1:ℝ)^(1/3:ℝ)))*D≤Cs*D := by
+    exact (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hz hCs.le) hD0).trans_eq (by ring)
+  change _≤ -D
+  nlinarith
+
+theorem ground_longVisitors_tail :
+    ∃ αstar : ℝ, 0<αstar ∧ ∀ αmax θ : ℝ, 0<αmax → 0<θ →
+    ∃ t₀ : ℝ, 0<t₀ ∧ ∀ (n K : ℕ) [NeZero K] (L : Length), L.val=(K:ℝ) →
+    ∀ r D : ℝ, D=(n:ℝ)/L.val^3 → 1≤D → αstar≤D*r → D*r≤αmax → 0<r →
+      (n:ℝ)*(2*Real.pi*r)^3≤L.val^3/2 →
+    ∀ (g : Jet n L), IsGroundVector n L r g → ∀ (x₀ : Torus L) (A : Finset (DiscreteTorus K)) {t : ℝ},
+      0<t → t ≤ min 2 t₀ →
+      groundPathLaw n L r t g {ω | ∀v∈A,θ*D≤
+        (visitorCount L x₀ {p | 1 < intervalDiameter 0 1 p} v ω:ℝ)}≤
+        ENNReal.ofReal (Real.exp (-(θ*D/2)*(A.card:ℝ))) := by
+  obtain ⟨Cd,Cf,Cs,α,hCd,hCf,hCs,hα,hm⟩ := interacting_visit_mgf (η₀:=1) (by norm_num)
+  refine ⟨α,hα,?_⟩
+  intro αmax θ hαmax hθ
+  let B := Real.exp (2*Cd*αmax)*Cf
+  have hB : 0<B := by dsimp [B]; positivity
+  let δ := min 1 (θ/(2*Cs))
+  have hδ : 0<δ := lt_min (by norm_num) (by positivity)
+  let ε := (δ/B)^3
+  have hε : 0<ε := by dsimp [ε]; positivity
+  have hrp : ε^(1/3:ℝ)=δ/B := by
+    simpa [ε] using Real.pow_rpow_inv_natCast (n:=3) (div_pos hδ hB).le (by norm_num : (3:ℕ)≠0)
+  obtain ⟨t₀,ht₀,hsmall⟩ := free_long_probability_small hε
+  refine ⟨t₀,ht₀,?_⟩
+  intro n K inst L hL r D hDeq hD hαr hαup hr hs g hg x₀ A t ht htt
+  have ht2 := (le_min_iff.mp htt).1
+  have hD0 : 0≤D := by linarith
+  have hxp : t*Cd*D*r≤2*Cd*αmax := by
+    calc
+      t*Cd*D*r = (t*Cd)*(D*r) := by ring
+      _ ≤ (t*Cd)*αmax := mul_le_mul_of_nonneg_left hαup (by positivity)
+      _ ≤ (2*Cd)*αmax := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right ht2 hCd.le) hαmax.le
+  have hzδ : Real.exp (t*Cd*D*r)*(Cf*1*ε^(1/3:ℝ))≤δ := by
+    rw [hrp,mul_one]
+    calc
+      _ ≤ Real.exp (2*Cd*αmax)*(Cf*(δ/B)) := mul_le_mul_of_nonneg_right (Real.exp_le_exp.mpr hxp) (by positivity)
+      _ = B*(δ/B) := by dsimp [B]; ring
+      _ = δ := mul_div_cancel₀ _ hB.ne'
+  have hz1 := hzδ.trans (min_le_left 1 (θ/(2*Cs)))
+  let E : Set (ConfigurationPath 1 L) := {p | 1 < intervalDiameter 0 1 p}
+  have hE : MeasurableSet E := measurableSet_lt measurable_const (intervalDiameter_continuous L 0 1).measurable
+  have hrev (p : ConfigurationPath 1 L) : reverseConfigurationPath 1 L p∈E↔p∈E := by
+    simp only [E,Set.mem_ofPred_eq,intervalDiameter_reverse,reverseTime_zero,reverseTime_one]
+  have hp (y : Torus L) : coordinateWiener 1 {w | freeTrajectory 1 L t w (oneConfiguration y)∈E}≤ENNReal.ofReal ε :=
+    hsmall L ht (le_min_iff.mp htt).2 y
+  have hh := hm n K L hL r D hDeq hD hαr hr hs g hg x₀ A ht ht2 (by norm_num : (0:ℝ)≤1)
+    (le_refl 1) hε.le E hE hrev hp hz1
+  have hj := joint_visitors_markov L x₀ A hE (groundPathLaw n L r t g) (by norm_num : (0:ℝ)≤1) hh (H:=θ*D)
+  apply hj.trans
+  apply ENNReal.ofReal_le_ofReal
+  apply Real.exp_le_exp.mpr
+  apply mul_le_mul_of_nonneg_right _ (Nat.cast_nonneg A.card)
+  have hδθ : Cs*δ≤θ/2 := by
+    have hh := (le_div_iff₀ (by positivity : 0<(2:ℝ)*Cs)).mp (min_le_right 1 (θ/(2*Cs)))
+    dsimp [δ]
+    linarith
+  have hc := mul_le_mul_of_nonneg_right ((mul_le_mul_of_nonneg_left hzδ hCs.le).trans hδθ) hD0
+  nlinarith
+
+end HardSphere.ShiftVisits
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/ShiftUniformMGF.lean

@@ -0,0 +1,168 @@
+import Mathlib
+import OAI.Analysis.HardSphere.PathBounds.ShiftInteracting
+import OAI.Analysis.HardSphere.PathBounds.VisitCounts
+import OAI.Analysis.HardSphere.Cutoffs.StandardRegular
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.ShiftVisits
+open HardSphere.Wiener HardSphere.Lattice HardSphere.CellOrbital HardSphere.BathSlice HardSphere.FreeVisits
+attribute [local irreducible] freeTrajectory
+theorem interacting_visit_mgf_uniform :
+    ∃ Cdel Csp αstar : ℝ, 0<Cdel ∧ 0<Csp ∧ 0<αstar ∧
+    ∀ η₀ : ℝ, 0≤η₀ → ∃ Cfree : ℝ, 0<Cfree ∧
+    ∀ (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 →
+    ∀ (c : Torus L) (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 c 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 ⟨Csp,αstar,hCsp,hα,hsp⟩ := spatial_count_mgf_enn
+  refine ⟨Cdel,Csp,αstar,hCdel,hCsp,hα,?_⟩
+  intro η₀ hη₀
+  obtain ⟨Cfree,hCfree,hfree⟩ := free_single_defect_bound hη₀
+  refine ⟨Cfree,hCfree,?_⟩
+  intro n K inst L hL r D hDeq hD hαr hr hs g hg c 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 (center L c)
+    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+singleDefect L c A η E (onePathAt i ω)) ∂groundPathLaw n L r t g :=
+        lintegral_congr (exp_defectiveTotalVisits L c A E hη)
+      _ ≤ ∫⁻ X,∏i,(1+ENNReal.ofReal (Real.exp (t*Cdel*(n:ℝ)*r/L.val^3))*
+          oneFreeExpectation t (singleDefect L c A η E) (X i)) ∂groundPositionLaw n L g :=
+        hdel n L r t hr ht hs g hg _ (singleDefect_measurable L c A η hE) (singleDefect_reverse L c 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 c 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 HardSphere.ShiftVisits
+
+end
+end
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.ShiftVisits
+open Wiener PathCutoff HardSphere.Lattice HardSphere.FreeVisits
+
+theorem ground_regularVisitors_uniform :
+    ∃ αstar : ℝ, 0 < αstar ∧ ∀ (η : ℝ), 0 < η → ∀ αmax C a b : ℝ,
+      0 < αmax → 0 < C → 0 < a → 0 < b →
+    ∃ D₀ : ℝ, 1 ≤ D₀ ∧ ∀ (n K : ℕ) [NeZero K] (L : Length), L.val=(K:ℝ) →
+    ∀ r D : ℝ, D=(n:ℝ)/L.val^3 → D₀ ≤ D → αstar ≤ D*r → D*r ≤ αmax → 0 < r →
+      (n:ℝ)*(2*Real.pi*r)^3 ≤ L.val^3/2 →
+    ∀ (g : Jet n L), IsGroundVector n L r g → ∀ (x₀ : Torus L) (A : Finset (DiscreteTorus K))
+    (m : ℕ) (τ : ℝ) (_hm : 0 < m) (_hτ : 0 < τ), τ ≤ r^2 →
+      a*D^2 ≤ (m:ℝ) → (m:ℝ) ≤ C*D^2 → (m:ℝ)*τ ≤ 2 →
+    ∀ (hD : 0 < D) (hhT : D⁻¹ < (m:ℝ)*τ),
+      groundPathLaw n L r ((m:ℝ)*τ) g {ω | ∀v���A,1 ≤
+        (visitorCount L x₀ {p | ¬Regular m r (D^(1/12:ℝ)) (meanCost+1)
+          (splitTime D⁻¹ ((m:ℝ)*τ-D⁻¹) (inv_pos.mpr hD) (sub_pos.mpr hhT))
+          (b*D^(-(1/3:ℝ))/8) p} v ω:ℝ)} ≤
+        ENNReal.ofReal (Real.exp (-(η/2)*(A.card:ℝ))) := by
+  obtain ⟨c,M,hc,hM,htail⟩ := wiener_norm_gaussian_tail
+  obtain ⟨Cd,Cs,α,hCd,hCs,hα,hmgf⟩ := interacting_visit_mgf_uniform
+  refine ⟨α,hα,?_⟩
+  intro η hη αmax C a b hαmax hC ha hb
+  obtain ⟨Cf,hCf,hm⟩ := hmgf η hη.le
+  let ε := fun D : ℝ ↦ scalarRegularBound C (3*M.toReal) c a b D
+  let B := Real.exp (2*Cd*αmax)*Cf*η
+  have hB : 0 < B := by dsimp [B]; positivity
+  let δ := min 1 (η/(2*Cs))
+  have hδ : 0 < δ := lt_min (by norm_num) (by positivity)
+  have hlim : Tendsto (fun D : ℝ ↦ B*(D*(ε D)^(1/3:ℝ))) atTop (𝓝 0) := by
+    simpa using (regular_root_decay hC.le (by positivity : 0 ≤ 3*M.toReal) hc ha hb).const_mul B
+  obtain ⟨D₀,hsmall⟩ := (eventually_atTop.1
+    ((eventually_ge_atTop (1:ℝ)).and (hlim.eventually (gt_mem_nhds hδ))))
+  refine ⟨max 1 D₀,le_max_left _ _,?_⟩
+  intro n K inst L hL r D hDeq hDD hαr hαup hr hs g hg x₀ A m τ hmpos hτ hτr hmlo hmhi ht2 hD hhT
+  have hD1 : 1 ≤ D := (le_max_left _ _).trans hDD
+  have hsmallD : B*(D*(ε D)^(1/3:ℝ)) ≤ δ := ((hsmall D ((le_max_right _ _).trans hDD)).2).le
+  have hε : 0 ≤ ε D := scalarRegularBound_nonneg hC.le (by positivity) c a b D
+  have ht : 0 < (m:ℝ)*τ := mul_pos (Nat.cast_pos.mpr hmpos) hτ
+  have hxp : ((m:ℝ)*τ)*Cd*D*r ≤ 2*Cd*αmax := by
+    calc
+      _ = (((m:ℝ)*τ)*Cd)*(D*r) := by ring
+      _ ≤ (((m:ℝ)*τ)*Cd)*αmax := mul_le_mul_of_nonneg_left hαup (by positivity)
+      _ ≤ (2*Cd)*αmax := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right ht2 hCd.le) hαmax.le
+  let z := Real.exp (((m:ℝ)*τ)*Cd*D*r)*(Cf*η*(ε D)^(1/3:ℝ))
+  have hz : 0 ≤ z := by dsimp [z]; positivity
+  have hzD : z*D ≤ δ := by
+    apply le_trans _ hsmallD
+    calc
+      _ ≤ Real.exp (2*Cd*αmax)*(Cf*η*(ε D)^(1/3:ℝ))*D := by
+        dsimp [z]
+        gcongr
+      _ = B*(D*(ε D)^(1/3:ℝ)) := by dsimp [B]; ring
+  have hz1 : z ≤ 1 := (by nlinarith : z ≤ z*D).trans (hzD.trans (min_le_left _ _))
+  let E : Set (ConfigurationPath 1 L) := {p | ¬Regular m r (D^(1/12:ℝ)) (meanCost+1)
+    (splitTime D⁻¹ ((m:ℝ)*τ-D⁻¹) (inv_pos.mpr hD) (sub_pos.mpr hhT)) (b*D^(-(1/3:ℝ))/8) p}
+  have hE : MeasurableSet E := (regular_measurable _ _ _ _ _ _).compl
+  have hrev (p : ConfigurationPath 1 L) : reverseConfigurationPath 1 L p∈E ↔ p∈E :=
+    (regular_reverse _ _ _ _ _ _ p).not
+  have hp (y : Torus L) : coordinateWiener 1 {w | freeTrajectory 1 L ((m:ℝ)*τ) w (oneConfiguration y)∈E} ≤ ENNReal.ofReal (ε D) :=
+    free_regular_standard_tail hM.ne htail hr hτ hτr hc.le hD1 hC.le ha.le hb.le m hmpos hmlo hmhi hhT (oneConfiguration y)
+  have hh := hm n K L hL r D hDeq hD1 hαr hr hs g hg x₀ A ht ht2 hη.le (le_refl η) hε E hE hrev hp hz1
+  have hj := joint_visitors_markov L x₀ A hE (groundPathLaw n L r ((m:ℝ)*τ) g) hη.le hh (H:=1)
+  apply hj.trans
+  apply ENNReal.ofReal_le_ofReal
+  apply Real.exp_le_exp.mpr
+  apply mul_le_mul_of_nonneg_right _ (Nat.cast_nonneg A.card)
+  have hδη : Cs*δ ≤ η/2 := by
+    have hh := (le_div_iff₀ (by positivity : 0 < (2:ℝ)*Cs)).mp (min_le_right 1 (η/(2*Cs)))
+    dsimp [δ]
+    linarith
+  have hcost := (mul_le_mul_of_nonneg_left hzD hCs.le).trans hδη
+  change Cs*z*D-η*1 ≤ -(η/2)
+  nlinarith
+
+end HardSphere.ShiftVisits
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/SingleVisitDefect.lean

@@ -0,0 +1,80 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Geometry.FreePathExpectation
+import OAI.Analysis.HardSphere.PathBounds.FreeVisitTravel
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.FreeVisits
+open HardSphere.Wiener HardSphere.BathSlice HardSphere.Lattice HardSphere.CellOrbital
+attribute [local irreducible] freeTrajectory pathVisitedSites torusDistance
+
+def singleVisitDefect {K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
+    (η : ℝ) (D : Set (ConfigurationPath 1 L)) (ω : ConfigurationPath 1 L) : ℝ≥0∞ := by
+  classical
+  exact ENNReal.ofReal (Real.exp (η*(if ω∈D then ((pathVisitedSites L (siteCenter L) A 0 ω).card:ℝ) else 0))-1)
+
+lemma singleVisitDefect_measurable {K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
+    (η : ℝ) {D : Set (ConfigurationPath 1 L)} (hD : MeasurableSet D) :
+    Measurable (singleVisitDefect L A η D) := by
+  classical
+  exact ((measurable_const.mul ((pathVisitedSites_measurable L (siteCenter L) A 0).ite hD measurable_const)).exp.sub
+    measurable_const).ennreal_ofReal
+
+lemma singleVisitDefect_reverse {K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
+    (η : ℝ) {D : Set (ConfigurationPath 1 L)}
+    (hD : ∀ω,reverseConfigurationPath 1 L ω∈D ↔ ω∈D) (ω : ConfigurationPath 1 L) :
+    singleVisitDefect L A η D (reverseConfigurationPath 1 L ω)=singleVisitDefect L A η D ω := by
+  classical
+  simp only [singleVisitDefect,hD,pathVisitedSites_reverse]
+
+lemma free_single_defect_bound {η₀ : ℝ} (hη₀ : 0≤η₀) : ∃ C : ℝ, 0<C ∧
+    ∀ {K : ℕ} [NeZero K] (L : Length), L.val=(K:ℝ) → ∀ 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 (singleVisitDefect L A η D) y ≤
+      ENNReal.ofReal (C*η*ε^(1/3:ℝ)*Real.exp (-spatialSiteDistance L (A.image (siteCenter L)) y)) := by
+  classical
+  obtain ⟨C,hC,hbound⟩ := free_visit_bound hη₀
+  refine ⟨C.toReal+1,by positivity,?_⟩
+  intro K _ L hL A t η ε ht ht2 hη hηη hε D hD hprob y
+  let E := {w : CoordinatePaths 1 | freeTrajectory 1 L t w (oneConfiguration y)∈D}
+  have hE : MeasurableSet E := hD.preimage
+    ((freeTrajectory_continuous 1 L t).measurable.comp (measurable_id.prodMk measurable_const))
+  have H := hbound L hL A 0 ht ht2 hη hηη (oneConfiguration y) E hE (ENNReal.ofReal ε) (hprob y)
+  have heq : oneFreeExpectation t (singleVisitDefect L A η D) y =
+      ∫⁻ w,visitDefect L A 0 t η (oneConfiguration y) E w ∂coordinateWiener 1 := by
+    rfl
+  rw [heq]
+  apply H.trans
+  have hC' : C≤ENNReal.ofReal (C.toReal+1) := by
+    calc
+      C = ENNReal.ofReal C.toReal := (ENNReal.ofReal_toReal hC.ne).symm
+      _ ≤ ENNReal.ofReal (C.toReal+1) := ENNReal.ofReal_le_ofReal (by linarith)
+  calc
+    C*ENNReal.ofReal η*ENNReal.ofReal ε^(1/3:ℝ)*
+        ENNReal.ofReal (Real.exp (-visitStartDistance L A 0 (oneConfiguration y))) ≤
+      ENNReal.ofReal (C.toReal+1)*ENNReal.ofReal η*ENNReal.ofReal ε^(1/3:ℝ)*
+        ENNReal.ofReal (Real.exp (-visitStartDistance L A 0 (oneConfiguration y))) := by gcongr
+    _ = _ := by
+      rw [ENNReal.ofReal_rpow_of_nonneg hε (show 0≤(1/3:ℝ) by norm_num),
+        ←ENNReal.ofReal_mul (show 0≤C.toReal+1 by positivity),
+        ←ENNReal.ofReal_mul (show 0≤(C.toReal+1)*η by positivity),
+        ←ENNReal.ofReal_mul (show 0≤(C.toReal+1)*η*ε^(1/3:ℝ) by positivity)]
+      rfl
+
+end HardSphere.FreeVisits
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/UniformVisitMGF.lean

@@ -0,0 +1,168 @@
+import Mathlib
+import OAI.Analysis.HardSphere.PathBounds.VisitCounts
+import OAI.Analysis.HardSphere.Cutoffs.StandardRegular
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.FreeVisits
+open Wiener HardSphere.BathSlice HardSphere.Lattice HardSphere.CellOrbital
+attribute [local irreducible] freeTrajectory pathVisitedSites torusDistance
+
+theorem interacting_visit_mgf_uniform :
+    ∃ Cdel Csp αstar : ℝ, 0<Cdel ∧ 0<Csp ∧ 0<αstar ∧
+    ∀ η₀ : ℝ, 0≤η₀ → ∃ Cfree : ℝ, 0<Cfree ∧
+    ∀ (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 ⟨Csp,αstar,hCsp,hα,hsp⟩ := spatial_count_mgf_enn
+  refine ⟨Cdel,Csp,αstar,hCdel,hCsp,hα,?_⟩
+  intro η₀ hη₀
+  obtain ⟨Cfree,hCfree,hfree⟩ := free_single_defect_bound hη₀
+  refine ⟨Cfree,hCfree,?_⟩
+  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 HardSphere.FreeVisits
+
+end
+end
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.FreeVisits
+open Wiener PathCutoff HardSphere.Lattice
+
+theorem ground_regularVisitors_uniform :
+    ∃ αstar : ℝ, 0 < αstar ∧ ∀ (η : ℝ), 0 < η → ∀ αmax C a b : ℝ,
+      0 < αmax → 0 < C → 0 < a → 0 < b →
+    ∃ D₀ : ℝ, 1 ≤ D₀ ∧ ∀ (n K : ℕ) [NeZero K] (L : Length), L.val=(K:ℝ) →
+    ∀ r D : ℝ, D=(n:ℝ)/L.val^3 → D₀ ≤ D → αstar ≤ D*r → D*r ≤ αmax → 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))
+    (m : ℕ) (τ : ℝ), 0 < m → 0 < τ → τ ≤ r^2 →
+      a*D^2 ≤ (m:ℝ) → (m:ℝ) ≤ C*D^2 → (m:ℝ)*τ ≤ 2 →
+    ∀ (hD : 0 < D) (hhT : D⁻¹ < (m:ℝ)*τ),
+      groundPathLaw n L r ((m:ℝ)*τ) g {ω | ∀v∈A,1 ≤
+        (visitorCount L {p | ¬Regular m r (D^(1/12:ℝ)) (meanCost+1)
+          (splitTime D⁻¹ ((m:ℝ)*τ-D⁻¹) (inv_pos.mpr hD) (sub_pos.mpr hhT))
+          (b*D^(-(1/3:ℝ))/8) p} v ω:ℝ)} ≤
+        ENNReal.ofReal (Real.exp (-(η/2)*(A.card:ℝ))) := by
+  obtain ⟨c,M,hc,hM,htail⟩ := wiener_norm_gaussian_tail
+  obtain ⟨Cd,Cs,α,hCd,hCs,hα,hmgf⟩ := interacting_visit_mgf_uniform
+  refine ⟨α,hα,?_⟩
+  intro η hη αmax C a b hαmax hC ha hb
+  obtain ⟨Cf,hCf,hm⟩ := hmgf η hη.le
+  let ε := fun D : ℝ ↦ scalarRegularBound C (3*M.toReal) c a b D
+  let B := Real.exp (2*Cd*αmax)*Cf*η
+  have hB : 0 < B := by dsimp [B]; positivity
+  let δ := min 1 (η/(2*Cs))
+  have hδ : 0 < δ := lt_min (by norm_num) (by positivity)
+  have hlim : Tendsto (fun D : ℝ ↦ B*(D*(ε D)^(1/3:ℝ))) atTop (𝓝 0) := by
+    simpa using (regular_root_decay hC.le (by positivity : 0 ≤ 3*M.toReal) hc ha hb).const_mul B
+  obtain ⟨D₀,hsmall⟩ := (eventually_atTop.1
+    ((eventually_ge_atTop (1:ℝ)).and (hlim.eventually (gt_mem_nhds hδ))))
+  refine ⟨max 1 D₀,le_max_left _ _,?_⟩
+  intro n K inst L hL r D hDeq hDD hαr hαup hr hs g hg A m τ hmpos hτ hτr hmlo hmhi ht2 hD hhT
+  have hD1 : 1 ≤ D := (le_max_left _ _).trans hDD
+  have hsmallD : B*(D*(ε D)^(1/3:ℝ)) ≤ δ := ((hsmall D ((le_max_right _ _).trans hDD)).2).le
+  have hε : 0 ≤ ε D := scalarRegularBound_nonneg hC.le (by positivity) c a b D
+  have ht : 0 < (m:ℝ)*τ := mul_pos (Nat.cast_pos.mpr hmpos) hτ
+  have hxp : ((m:ℝ)*τ)*Cd*D*r ≤ 2*Cd*αmax := by
+    calc
+      _ = (((m:ℝ)*τ)*Cd)*(D*r) := by ring
+      _ ≤ (((m:ℝ)*τ)*Cd)*αmax := mul_le_mul_of_nonneg_left hαup (by positivity)
+      _ ≤ (2*Cd)*αmax := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right ht2 hCd.le) hαmax.le
+  let z := Real.exp (((m:ℝ)*τ)*Cd*D*r)*(Cf*η*(ε D)^(1/3:ℝ))
+  have hz : 0 ≤ z := by dsimp [z]; positivity
+  have hzD : z*D ≤ δ := by
+    apply le_trans _ hsmallD
+    calc
+      _ ≤ Real.exp (2*Cd*αmax)*(Cf*η*(ε D)^(1/3:ℝ))*D := by
+        dsimp [z]
+        gcongr
+      _ = B*(D*(ε D)^(1/3:ℝ)) := by dsimp [B]; ring
+  have hz1 : z ≤ 1 := (by nlinarith : z ≤ z*D).trans (hzD.trans (min_le_left _ _))
+  let E : Set (ConfigurationPath 1 L) := {p | ¬Regular m r (D^(1/12:ℝ)) (meanCost+1)
+    (splitTime D⁻¹ ((m:ℝ)*τ-D⁻¹) (inv_pos.mpr hD) (sub_pos.mpr hhT)) (b*D^(-(1/3:ℝ))/8) p}
+  have hE : MeasurableSet E := (regular_measurable _ _ _ _ _ _).compl
+  have hrev (p : ConfigurationPath 1 L) : reverseConfigurationPath 1 L p∈E ↔ p∈E :=
+    (regular_reverse _ _ _ _ _ _ p).not
+  have hp (y : Torus L) : coordinateWiener 1 {w | freeTrajectory 1 L ((m:ℝ)*τ) w (oneConfiguration y)∈E} ≤ ENNReal.ofReal (ε D) :=
+    free_regular_standard_tail hM.ne htail hr hτ hτr hc.le hD1 hC.le ha.le hb.le m hmpos hmlo hmhi hhT (oneConfiguration y)
+  have hh := hm n K L hL r D hDeq hD1 hαr hr hs g hg A ht ht2 hη.le (le_refl η) hε E hE hrev hp hz1
+  have hj := joint_visitors_markov L A hE (groundPathLaw n L r ((m:ℝ)*τ) g) hη.le hh (H:=1)
+  apply hj.trans
+  apply ENNReal.ofReal_le_ofReal
+  apply Real.exp_le_exp.mpr
+  apply mul_le_mul_of_nonneg_right _ (Nat.cast_nonneg A.card)
+  have hδη : Cs*δ ≤ η/2 := by
+    have hh := (le_div_iff₀ (by positivity : 0 < (2:ℝ)*Cs)).mp (min_le_right 1 (η/(2*Cs)))
+    dsimp [δ]
+    linarith
+  have hcost := (mul_le_mul_of_nonneg_left hzD hCs.le).trans hδη
+  change Cs*z*D-η*1 ≤ -(η/2)
+  nlinarith
+
+end HardSphere.FreeVisits
+
+end
+end
+
+end
+
+end OAI

lean/OAI/Analysis/HardSphere/PathBounds/VisitCounts.lean

@@ -0,0 +1,208 @@
+import Mathlib
+import OAI.Analysis.HardSphere.Allocation.Allocation
+import OAI.Analysis.HardSphere.PathBounds.InteractingVisits
+
+namespace OAI
+
+section
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set Filter
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.FreeVisits
+open HardSphere.Wiener HardSphere.BathSlice HardSphere.Lattice HardSphere.CellOrbital
+
+def visitorCount {n K : ℕ} (L : Length) (E : Set (ConfigurationPath 1 L))
+    (v : DiscreteTorus K) (ω : ConfigurationPath n L) : ℕ := by
+  classical
+  exact (Finset.univ.filter (fun i : Fin n ↦ onePathAt i ω∈E ∧ pathVisitsBall L 12 (siteCenter L v) i ω)).card
+
+lemma visitorCount_sum {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
+    (E : Set (ConfigurationPath 1 L)) (ω : ConfigurationPath n L) :
+    (∑v∈A,visitorCount L E v ω)=defectiveTotalVisits L A E ω := by
+  classical
+  simp only [visitorCount,Finset.card_filter]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro i _
+  by_cases hi : onePathAt i ω∈E
+  · simp only [hi,true_and,pathVisitedSites,ite_eq_left,Finset.card_filter]
+  · simp only [hi,false_and,ite_false,Finset.sum_const_zero,pathVisitedSites]
+
+lemma visitorCount_measurable {n K : ℕ} (L : Length) {E : Set (ConfigurationPath 1 L)}
+    (hE : MeasurableSet E) (v : DiscreteTorus K) : Measurable (visitorCount (n:=n) L E v) := by
+  classical
+  have he : visitorCount (n:=n) L E v=(fun ω ↦ ∑i : Fin n, if onePathAt i ω∈E ∧ pathVisitsBall L 12 (siteCenter L v) i ω then (1:ℕ) else 0) := by
+    funext ω
+    simp only [visitorCount,Finset.card_filter]
+  rw [he]
+  apply Finset.measurable_fun_sum
+  intro i _
+  have hi : MeasurableSet {ω : ConfigurationPath n L | onePathAt i ω∈E} := hE.preimage (onePathAt_continuous i).measurable
+  exact measurable_const.ite (hi.inter (pathVisitsBall_isClosed L 12 (siteCenter L v) i).measurableSet) measurable_const
+
+lemma defectiveTotalVisits_measurable {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
+    {E : Set (ConfigurationPath 1 L)} (hE : MeasurableSet E) : Measurable (defectiveTotalVisits (n:=n) L A E) := by
+  have he : defectiveTotalVisits (n:=n) L A E=fun ω ↦ ∑v∈A,visitorCount L E v ω := by
+    funext ω; exact (visitorCount_sum L A E ω).symm
+  rw [he]
+  exact Finset.measurable_fun_sum _ (fun v _ ↦ visitorCount_measurable L hE v)
+
+lemma joint_visitor_sum {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
+    (E : Set (ConfigurationPath 1 L)) {H : ℝ} {ω : ConfigurationPath n L}
+    (h : ∀v∈A,H≤(visitorCount L E v ω:ℝ)) :
+    H*(A.card:ℝ)≤(defectiveTotalVisits L A E ω:ℝ) := by
+  rw [←visitorCount_sum L A E ω,Nat.cast_sum]
+  have hs := Finset.sum_le_sum h
+  simpa only [Finset.sum_const,nsmul_eq_mul,mul_comm] using hs
+
+lemma joint_visitors_markov {n K : ℕ} (L : Length) (A : Finset (DiscreteTorus K))
+    {E : Set (ConfigurationPath 1 L)} (hE : MeasurableSet E)
+    (μ : Measure (ConfigurationPath n L)) {η H Q : ℝ} (hη : 0≤η)
+    (hmgf : (∫⁻ω,ENNReal.ofReal (Real.exp (η*(defectiveTotalVisits L A E ω:ℝ))) ∂μ)≤
+      ENNReal.ofReal (Real.exp (Q*(A.card:ℝ)))) :
+    μ {ω | ∀v∈A,H≤(visitorCount L E v ω:ℝ)}≤ENNReal.ofReal (Real.exp ((Q-η*H)*(A.card:ℝ))) := by
+  let F := fun ω : ConfigurationPath n L ↦ ENNReal.ofReal (Real.exp (η*(defectiveTotalVisits L A E ω:ℝ)))
+  have hc : Measurable (fun k : ℕ ↦ (k:ℝ)) := measurable_of_countable _
+  have hF : Measurable F := ((measurable_const.mul (hc.comp (defectiveTotalVisits_measurable L A hE))).exp).ennreal_ofReal
+  have hp : ENNReal.ofReal (Real.exp (η*(H*(A.card:ℝ))))≠0 := ne_of_gt (ENNReal.ofReal_pos.mpr (Real.exp_pos _))
+  have hm := meas_ge_le_lintegral_div (μ:=μ) hF.aemeasurable hp ENNReal.ofReal_ne_top
+  calc
+    _ ≤ μ {ω | ENNReal.ofReal (Real.exp (η*(H*(A.card:ℝ))))≤F ω} := by
+      apply measure_mono
+      intro ω hω
+      apply ENNReal.ofReal_le_ofReal
+      apply Real.exp_le_exp.mpr
+      exact mul_le_mul_of_nonneg_left (joint_visitor_sum L A E hω) hη
+    _ ≤ _ := hm
+    _ ≤ ENNReal.ofReal (Real.exp (Q*(A.card:ℝ)))/ENNReal.ofReal (Real.exp (η*(H*(A.card:ℝ)))) := ENNReal.div_le_div_right hmgf _
+    _ = _ := by
+      rw [←ENNReal.ofReal_div_of_pos (Real.exp_pos _),←Real.exp_sub]
+      congr 2
+      ring
+
+end HardSphere.FreeVisits
+
+end
+end
+
+section
+noncomputable section
+open MeasureTheory ProbabilityTheory Set
+open scoped ENNReal NNReal Topology BigOperators
+namespace HardSphere.Groups
+open Wiener CellOrbital PathCutoff FreeVisits
+attribute [local instance] Classical.propDecidable
+
+lemma centeredCell_distance {L : Length} {c x : Torus L} (hx : x∈centeredCell L c) :
+    torusDistance L x c≤1 := by
+  have hd (j : Fin 3) : dist (x j) (c j)≤(1/2:ℝ) := by
+    rw [dist_eq_norm,←centered_rep_abs]
+    exact abs_le.mpr ⟨by linarith [(hx j).1], (hx j).2.le⟩
+  unfold torusDistance
+  apply Real.sqrt_le_one.mpr
+  calc
+    _ ≤ ∑ _j : Fin 3,(1/4:ℝ) := Finset.sum_le_sum (fun j _ ↦ by nlinarith [dist_nonneg (x:=x j) (y:=c j),hd j])
+    _ ≤ 1 := by norm_num
+
+@[simp] lemma intervalTime_zero_one (s : Time) : intervalTime 0 1 s=s := by
+  apply Subtype.ext
+  simp [intervalTime]
+
+lemma smallDiameter_distance {L : Length} (ω : ConfigurationPath 1 L)
+    (h : intervalDiameter 0 1 ω≤1) (s q : Time) : torusDistance L (ω s 0) (ω q 0)≤1 := by
+  have hh := (intervalDistance_le 0 1 s q ω).trans h
+  simpa only [intervalTime_zero_one] using hh
+
+def longVisitors {N : ℕ} {L : Length} (c : Torus L) (ω : ConfigurationPath N L) : Finset (Fin N) :=
+  Finset.univ.filter (fun i ↦ pathVisitsBall L 12 c i ω ∧ 1 < intervalDiameter 0 1 (onePathAt i ω))
+
+def visitors {N : ℕ} {L : Length} (c : Torus L) (ω : ConfigurationPath N L) : Finset (Fin N) :=
+  Finset.univ.filter (fun i ↦ pathVisitsBall L 12 c i ω)
+
+structure Certificate {N K : ℕ} [Nontrivial (Fin N)] {L : Length}
+    (m : ℕ) (r R C S s₀ ell θ H D : ℝ) (u : Time) (v : Fin 3→Fin K)
+    (ω : ConfigurationPath N L) : Prop where
+  low : ell*D≤(centeredCount L (gridCenter L v) (ω 0):ℝ)
+  closeY : ((localCloseLabels L s₀ (gridCenter L v) (ω 0)).card:ℝ)<θ*D
+  closeZ : ((localCloseLabels L s₀ (gridCenter L v) (ω 1)).card:ℝ)<θ*D
+  visit : ((visitors (gridCenter L v) ω).card:ℝ)≤H*D
+  regular : ∀i,pathVisitsBall L 12 (gridCenter L v) i ω→Regular m r R C u S (onePathAt i ω)
+  long : ((longVisitors (gridCenter L v) ω).card:ℝ)<θ*D
+
+lemma eligible_of_not_discarded {N K : ℕ} [Nontrivial (Fin N)] {L : Length}
+    (m : ℕ) (r R C S s₀ : ℝ) (u : Time) (v : Fin 3→Fin K) (ω : ConfigurationPath N L)
+    (hreg : ∀i,pathVisitsBall L 12 (gridCenter L v) i ω→Regular m r R C u S (onePathAt i ω))
+    (i : Fin N) (hy : ω 0 i∈centeredCell L (gridCenter L v))
+    (hY : i∉localCloseLabels L s₀ (gridCenter L v) (ω 0))
+    (hZ : i∉localCloseLabels L s₀ (gridCenter L v) (ω 1))
+    (hshort : i∉longVisitors (gridCenter L v) ω) : Eligible m r R C S s₀ u v i ω := by
+  have hyc := centeredCell_distance hy
+  have hv : pathVisitsBall L 12 (gridCenter L v) i ω := ⟨0,by linarith⟩
+  have hsmall : intervalDiameter 0 1 (onePathAt i ω)≤1 := by
+    by_contra! h
+    exact hshort (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hv,h⟩)
+  have hd (s : Time) : torusDistance L (ω s i) (ω 0 i)≤1 := smallDiameter_distance (onePathAt i ω) hsmall s 0
+  have hc (s : Time) : torusDistance L (ω s i) (gridCenter L v)≤2 := by
+    have hh := torusDistance_triangle' L (ω s i) (ω 0 i) (gridCenter L v)
+    linarith [hd s]
+  have hNY : s₀<nearestParticleDistance L (ω 0) i := by
+    by_contra! hh
+    apply hY
+    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,by linarith,hh⟩
+  have hNZ : s₀<nearestParticleDistance L (ω 1) i := by
+    by_contra! hh
+    apply hZ
+    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,by linarith [hc 1],hh⟩
+  refine ⟨⟨hy,by linarith [hc 1],?_⟩,hreg i hv,?_⟩
+  · intro j hji
+    exact ⟨hNY.trans_le (nearestParticleDistance_le L (ω 0) i j hji),
+      hNZ.trans_le (nearestParticleDistance_le L (ω 1) i j hji)⟩
+  · intro s
+    exact (hc s).trans (by norm_num)
+
+lemma certificate_eligible_count {N K : ℕ} [Nontrivial (Fin N)] {L : Length}
+    (m : ℕ) (r R C S s₀ ell θ H D : ℝ) (u : Time) (v : Fin 3→Fin K)
+    (ω : ConfigurationPath N L) (h : Certificate m r R C S s₀ ell θ H D u v ω) :
+    (ell-3*θ)*D≤((eligibleList m r R C S s₀ u v ω).card:ℝ) := by
+  let E := eligibleList m r R C S s₀ u v ω
+  let A := localCloseLabels L s₀ (gridCenter L v) (ω 0)
+  let B := localCloseLabels L s₀ (gridCenter L v) (ω 1)
+  let T := longVisitors (gridCenter L v) ω
+  have hsub : Finset.univ.filter (fun i ↦ ω 0 i∈centeredCell L (gridCenter L v))⊆((E∪A)∪B)∪T := by
+    intro i hi
+    by_cases he : i∈E
+    · simp [he]
+    by_cases ha : i∈A
+    · simp [ha]
+    by_cases hb : i∈B
+    · simp [hb]
+    by_cases ht : i∈T
+    · simp [ht]
+    exfalso
+    exact he (Finset.mem_filter.mpr ⟨Finset.mem_univ _,eligible_of_not_discarded m r R C S s₀ u v ω
+      h.regular i (Finset.mem_filter.mp hi).2 ha hb ht⟩)
+  have hcard : centeredCount L (gridCenter L v) (ω 0)≤E.card+A.card+B.card+T.card := by
+    apply (Finset.card_le_card hsub).trans
+    exact (Finset.card_union_le _ _).trans (Nat.add_le_add_right
+      ((Finset.card_union_le _ _).trans (Nat.add_le_add_right (Finset.card_union_le _ _) _)) _)
+  have hc : (centeredCount L (gridCenter L v) (ω 0):ℝ)≤(E.card:ℝ)+(A.card:ℝ)+(B.card:ℝ)+(T.card:ℝ) := by exact_mod_cast hcard
+  have h1 := h.low
+  have h2 := h.closeY
+  have h3 := h.closeZ
+  have h4 := h.long
+  change _≤(E.card:ℝ)
+  change (A.card:ℝ)<θ*D at h2
+  change (B.card:ℝ)<θ*D at h3
+  change (T.card:ℝ)<θ*D at h4
+  nlinarith
+
+end HardSphere.Groups
+
+end
+end
+
+end
+
+end OAI