| import Mathlib |
| import OAI.Analysis.HardSphere.Operators.FormResolventNormEnergy |
| import OAI.Analysis.HardSphere.Orbitals.FreePathLawFiniteDeletion |
|
|
| 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 |
|
|
| def freePathExpectation {m : ℕ} {L : Length} (t : ℝ) |
| (h : ConfigurationPath m L → ℝ≥0∞) (X : Configuration m L) : ℝ≥0∞ := |
| ∫⁻ w : CoordinatePaths m, h (freeTrajectory m L t w X) ∂coordinateWiener m |
|
|
| lemma freePathExpectation_measurable {m : ℕ} {L : Length} (t : ℝ) |
| {h : ConfigurationPath m L → ℝ≥0∞} (hh : Measurable h) : |
| Measurable (freePathExpectation t h) := |
| (hh.comp (freeTrajectory_continuous m L t).measurable).lintegral_prod_left' |
|
|
| lemma selected_start_integral {m n : ℕ} {L : Length} (u : ScalarL2 (m+n) L) (t : ℝ) |
| {h : ConfigurationPath m L → ℝ≥0∞} (hh : Measurable h) : |
| (∫⁻ ω : ConfigurationPath m L, h ω*ENNReal.ofReal (sliceNormSq u (ω 0)) ∂freePathLaw m L t)= |
| ∫⁻ y : Configuration m L, freePathExpectation t h y*ENNReal.ofReal (sliceNormSq u y) ∂volume := 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) |
| rw [freePathLaw,lintegral_map hmeas (freeTrajectory_continuous m L t).measurable] |
| have heq : (fun p : CoordinatePaths m × Configuration m L ↦ |
| h (freeTrajectory m L t p.1 p.2)*ENNReal.ofReal (sliceNormSq u (freeTrajectory m L t p.1 p.2 0))) |
| =ᵐ[(coordinateWiener m).prod volume] (fun p ↦ |
| h (freeTrajectory m L t p.1 p.2)*ENNReal.ofReal (sliceNormSq u p.2)) := by |
| filter_upwards [Measure.quasiMeasurePreserving_fst.ae (freeTrajectory_initial_ae m L t)] with p hp |
| rw [hp p.2] |
| have hp : Measurable (fun p : CoordinatePaths m × Configuration m L ↦ |
| h (freeTrajectory m L t p.1 p.2)*ENNReal.ofReal (sliceNormSq u p.2)) := |
| (hh.comp (freeTrajectory_continuous m L t).measurable).mul |
| ((sliceNormSq_measurable u).comp measurable_snd).ennreal_ofReal |
| rw [lintegral_congr_ae heq,lintegral_prod_symm _ hp.aemeasurable] |
| apply lintegral_congr |
| intro y |
| simpa only [freePathExpectation] using lintegral_mul_const (μ:=coordinateWiener m) |
| (ENNReal.ofReal (sliceNormSq u y)) (show Measurable (fun w : CoordinatePaths m ↦ |
| h (freeTrajectory m L t w y)) from hh.comp ((freeTrajectory_continuous m L t).measurable.comp |
| (measurable_id.prodMk measurable_const))) |
|
|
| lemma slice_mass_integral {m n : ℕ} {L : Length} (u : Jet (m+n) L) |
| {H : Configuration m L → ℝ≥0∞} (hH : Measurable H) : |
| (∫⁻ y : Configuration m L, H y*ENNReal.ofReal (sliceNormSq u.1 y) ∂volume)= |
| ∫⁻ X : Configuration (m+n) L, H (splitConfiguration m n L X).1 ∂groundPositionLaw (m+n) L u := by |
| have hu := (Lp.stronglyMeasurable u.1).measurable |
| have hmH : Measurable (fun X : Configuration (m+n) L ↦ H (splitConfiguration m n L X).1) := |
| hH.comp (splitConfiguration_continuous m n L).measurable.fst |
| rw [groundPositionLaw,lintegral_withDensity_eq_lintegral_mul volume |
| (hu.norm.pow_const 2).ennreal_ofReal hmH] |
| have hD : Measurable (fun X : Configuration (m+n) L ↦ |
| ENNReal.ofReal (‖u.1 X‖^2)*H (splitConfiguration m n L X).1) := |
| (hu.norm.pow_const 2).ennreal_ofReal.mul hmH |
| have hJ : Measurable (fun p : Configuration m L × Configuration n L ↦ |
| ENNReal.ofReal (‖u.1 (joinConfiguration m n L p)‖^2)*H p.1) := |
| (((hu.comp (joinConfiguration_continuous m n L).measurable).norm.pow_const 2).ennreal_ofReal).mul |
| (hH.comp measurable_fst) |
| have hj := (joinConfiguration_preserving m n L).lintegral_comp hD |
| simp only [split_joinConfiguration] at hj |
| simp only [Pi.mul_apply] |
| rw [← hj,lintegral_prod _ hJ.aemeasurable] |
| apply lintegral_congr_ae |
| filter_upwards [memLp_slice_ae u.1] with y hy |
| have hyM : Measurable (fun x : Configuration n L ↦ |
| ENNReal.ofReal (‖u.1 (joinConfiguration m n L (y,x))‖^2)) := |
| (((hu.comp (joinConfiguration_continuous m n L).measurable).comp |
| (measurable_const.prodMk measurable_id)).norm.pow_const 2).ennreal_ofReal |
| rw [sliceNormSq,ofReal_integral_eq_lintegral_ofReal |
| (hy.integrable_norm_pow (show (2:ℕ)≠0 by norm_num)) (Eventually.of_forall fun _ ↦ sq_nonneg _)] |
| rw [← lintegral_const_mul _ hyM] |
| apply lintegral_congr |
| intro x |
| exact mul_comm _ _ |
|
|
| lemma selected_start_ground_integral {m n : ℕ} {L : Length} (u : Jet (m+n) L) (t : ℝ) |
| {h : ConfigurationPath m L → ℝ≥0∞} (hh : Measurable h) : |
| (∫⁻ ω : ConfigurationPath m L, h ω*ENNReal.ofReal (sliceNormSq u.1 (ω 0)) ∂freePathLaw m L t)= |
| ∫⁻ X : Configuration (m+n) L, |
| freePathExpectation t h (splitConfiguration m n L X).1 ∂groundPositionLaw (m+n) L u := by |
| rw [selected_start_integral u.1 t hh] |
| exact slice_mass_integral u (freePathExpectation_measurable t hh) |
|
|
| lemma groundPathLaw_deletion : ∃ C : ℝ, 0<C ∧ |
| ∀ (m n : ℕ) (L : Length) (r t : ℝ), 0<r → 0<t → |
| ((m+n:ℕ):ℝ)*(2*Real.pi*r)^3≤L.val^3/2 → |
| ∀ u : Jet (m+n) L, IsGroundVector (m+n) L r u → |
| ∀ h : ConfigurationPath m L → ℝ≥0∞, Measurable h → |
| (∀ ω, h (reverseConfigurationPath m L ω)=h ω) → |
| (∫⁻ ω : ConfigurationPath (m+n) L, h (splitConfigurationPath m n L ω).1 |
| ∂groundPathLaw (m+n) L r t u) ≤ |
| ENNReal.ofReal (Real.exp (t*C*(m:ℝ)*((m+n:ℕ):ℝ)*r/L.val^3))* |
| ∫⁻ X : Configuration (m+n) L, |
| freePathExpectation t h (splitConfiguration m n L X).1 ∂groundPositionLaw (m+n) L u := by |
| obtain ⟨C,hC,hbath⟩ := bath_heat_bound |
| refine ⟨C,hC,?_⟩ |
| intro m n L r t hr ht hs u hu h hh hrev |
| have hb := hbath n m |
| rw [Nat.add_comm n m] at hb |
| have hb' := hb L r t hr ht hs u hu |
| have hm := deleted_path_integral_le u.1 r t hh hrev |
| rw [selected_start_ground_integral u t hh] at hm |
| have hmH : Measurable (fun ω : ConfigurationPath (m+n) L ↦ h (splitConfigurationPath m n L ω).1) := |
| hh.comp (splitConfigurationPath_continuous m n L).measurable.fst |
| have hend : Measurable (fun ω : ConfigurationPath (m+n) L ↦ |
| ENNReal.ofReal (‖u.1 (ω 0)‖*‖u.1 (ω 1)‖)) := by |
| have hu := (Lp.stronglyMeasurable u.1).measurable |
| exact ((hu.comp (continuous_eval_const (0:Time)).measurable).norm.mul |
| (hu.comp (continuous_eval_const (1:Time)).measurable).norm).ennreal_ofReal |
| rw [groundPathLaw,lintegral_withDensity_eq_lintegral_mul _ |
| (groundPathWeight_measurable u t).ennreal_ofReal hmH] |
| simp only [Pi.mul_apply,groundPathWeight,ENNReal.ofReal_mul (Real.exp_pos _).le] |
| calc |
| _ = ENNReal.ofReal (Real.exp (t*energy u))* |
| ∫⁻ ω : ConfigurationPath (m+n) L, |
| h (splitConfigurationPath m n L ω).1*ENNReal.ofReal (‖u.1 (ω 0)‖*‖u.1 (ω 1)‖) |
| ∂killedPathLaw (m+n) L r t := by |
| rw [← lintegral_const_mul _ (show Measurable (fun ω : ConfigurationPath (m+n) L ↦ |
| h (splitConfigurationPath m n L ω).1*ENNReal.ofReal (‖u.1 (ω 0)‖*‖u.1 (ω 1)‖)) from hmH.mul hend)] |
| apply lintegral_congr |
| intro ω |
| ac_rfl |
| _ ≤ ENNReal.ofReal (Real.exp (t*energy u))*(ENNReal.ofReal ‖killedTransition n L r t‖* |
| ∫⁻ X : Configuration (m+n) L, |
| freePathExpectation t h (splitConfiguration m n L X).1 ∂groundPositionLaw (m+n) L u) := |
| mul_le_mul_right hm _ |
| _ ≤ ENNReal.ofReal (Real.exp (t*energy u))*ENNReal.ofReal |
| (Real.exp (-t*(energy u-C*(m:ℝ)*((m+n:ℕ):ℝ)*r/L.val^3)))* |
| ∫⁻ X : Configuration (m+n) L, |
| freePathExpectation t h (splitConfiguration m n L X).1 ∂groundPositionLaw (m+n) L u := by |
| rw [← mul_assoc] |
| exact mul_le_mul_left (mul_le_mul_right (ENNReal.ofReal_le_ofReal hb') _) _ |
| _ = _ := by |
| rw [← ENNReal.ofReal_mul (Real.exp_pos _).le,← Real.exp_add] |
| congr 3 |
| ring |
| end |
| end HardSphere |
|
|
| end |
| end |
| end |
|
|
| section |
| noncomputable section |
| open MeasureTheory Set Filter |
| open scoped ENNReal NNReal Topology BigOperators |
| namespace HardSphere |
| open Wiener |
|
|
| def oneConfiguration {L : Length} (y : Torus L) : Configuration 1 L := fun _ ↦ y |
|
|
| def onePathAt {n : ℕ} {L : Length} (i : Fin n) (ω : ConfigurationPath n L) : ConfigurationPath 1 L := |
| ⟨fun s ↦ oneConfiguration (ω s i), by unfold oneConfiguration; fun_prop⟩ |
|
|
| lemma onePathAt_continuous {n : ℕ} {L : Length} (i : Fin n) : |
| Continuous (onePathAt (L:=L) i) := by |
| apply ContinuousMap.continuous_of_continuous_uncurry |
| change Continuous (fun p : ConfigurationPath n L × Time ↦ fun _ : Fin 1 ↦ p.1 p.2 i) |
| fun_prop |
|
|
| @[simp] lemma onePathAt_reverse {n : ℕ} {L : Length} (i : Fin n) (ω : ConfigurationPath n L) : |
| onePathAt i (reverseConfigurationPath n L ω)=reverseConfigurationPath 1 L (onePathAt i ω) := rfl |
|
|
| @[simp] lemma onePathAt_single {L : Length} (ω : ConfigurationPath 1 L) : onePathAt 0 ω=ω := by |
| ext s i j |
| have hi : i=0 := Subsingleton.elim _ _ |
| subst i |
| rfl |
|
|
| @[simp] lemma onePathAt_join_left {m n : ℕ} {L : Length} (i : Fin m) |
| (p : ConfigurationPath m L × ConfigurationPath n L) : |
| onePathAt (Fin.castAdd n i) (joinConfigurationPath m n L p)=onePathAt i p.1 := by |
| ext s j k |
| simp [onePathAt,oneConfiguration,joinConfigurationPath,joinConfiguration] |
|
|
| @[simp] lemma onePathAt_join_right {m n : ℕ} {L : Length} (i : Fin n) |
| (p : ConfigurationPath m L × ConfigurationPath n L) : |
| onePathAt (Fin.natAdd m i) (joinConfigurationPath m n L p)=onePathAt i p.2 := by |
| ext s j k |
| simp [onePathAt,oneConfiguration,joinConfigurationPath,joinConfiguration] |
|
|
| def oneFreeExpectation {L : Length} (t : ℝ) (h : ConfigurationPath 1 L → ℝ≥0∞) |
| (y : Torus L) : ℝ≥0∞ := freePathExpectation t h (oneConfiguration y) |
|
|
| lemma oneFreeExpectation_measurable {L : Length} (t : ℝ) |
| {h : ConfigurationPath 1 L → ℝ≥0∞} (hh : Measurable h) : Measurable (oneFreeExpectation t h) := by |
| exact (freePathExpectation_measurable t hh).comp (by unfold oneConfiguration; fun_prop) |
|
|
| lemma pathProduct_measurable {n : ℕ} {L : Length} (S : Finset (Fin n)) |
| {h : ConfigurationPath 1 L → ℝ≥0∞} (hh : Measurable h) : |
| Measurable (fun ω : ConfigurationPath n L ↦ ∏ i∈S, h (onePathAt i ω)) := by |
| exact Finset.measurable_prod S fun i _ ↦ hh.comp (onePathAt_continuous i).measurable |
|
|
| lemma free_product_expectation {n : ℕ} {L : Length} (t : ℝ) |
| {h : ConfigurationPath 1 L → ℝ≥0∞} (hh : Measurable h) (X : Configuration n L) : |
| freePathExpectation t (fun ω : ConfigurationPath n L ↦ ∏ i, h (onePathAt i ω)) X= |
| ∏ i,oneFreeExpectation t h (X i) := by |
| induction n with |
| | zero => simp [freePathExpectation] |
| | succ n ih => |
| change (∫⁻ w : CoordinatePaths (n+1), ∏ i, h (onePathAt i (freeTrajectory (n+1) L t w X)) |
| ∂coordinateWiener (n+1))=_ |
| let Xm := (splitConfiguration n 1 L X).1 |
| let X1 := (splitConfiguration n 1 L X).2 |
| have hXm : Measurable (fun w : CoordinatePaths n ↦ |
| ∏ i, h (onePathAt i (freeTrajectory n L t w Xm))) := |
| (pathProduct_measurable Finset.univ hh).comp |
| ((freeTrajectory_continuous n L t).measurable.comp (measurable_id.prodMk measurable_const)) |
| have hX1 : Measurable (fun w : CoordinatePaths 1 ↦ h (freeTrajectory 1 L t w X1)) := |
| hh.comp ((freeTrajectory_continuous 1 L t).measurable.comp (measurable_id.prodMk measurable_const)) |
| have hfull : Measurable (fun w : CoordinatePaths (n+1) ↦ |
| ∏ i, h (onePathAt i (freeTrajectory (n+1) L t w X))) := |
| (pathProduct_measurable Finset.univ hh).comp |
| ((freeTrajectory_continuous (n+1) L t).measurable.comp (measurable_id.prodMk measurable_const)) |
| rw [←(joinCoordinatePaths_preserving n 1).lintegral_comp hfull] |
| have he (w : CoordinatePaths n × CoordinatePaths 1) : |
| freeTrajectory (n+1) L t (joinCoordinatePaths n 1 w) X= |
| joinConfigurationPath n 1 L (freeTrajectory n L t w.1 Xm,freeTrajectory 1 L t w.2 X1) := by |
| rw [←freeTrajectory_join,join_splitConfiguration] |
| simp only [he,Fin.prod_univ_add,onePathAt_join_left,onePathAt_join_right, |
| Fin.prod_univ_one,onePathAt_single] |
| rw [lintegral_prod_mul hXm.aemeasurable hX1.aemeasurable] |
| change freePathExpectation t (fun ω : ConfigurationPath n L ↦ ∏ i,h (onePathAt i ω)) Xm * |
| freePathExpectation t h X1 = _ |
| rw [ih] |
| congr 1 |
| change freePathExpectation t h X1 = freePathExpectation t h (oneConfiguration (X (Fin.natAdd n 0))) |
| congr 1 |
| funext i |
| have hi : i=0 := Subsingleton.elim _ _ |
| subst i |
| rfl |
|
|
| end HardSphere |
|
|
| end |
| end |
|
|
| end |
|
|
| end OAI |
|
|
