| import Mathlib |
| import OAI.Analysis.HardSphere.Geometry.ConfigurationPath |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open MeasureTheory Filter Set |
| open scoped Topology ENNReal BigOperators |
| open scoped RealInnerProductSpace |
| namespace HardSphere |
| open MeasureTheory Wiener Set Filter |
| noncomputable section |
|
|
| def joinConfiguration (m n : ℕ) (L : Length) |
| (p : Configuration m L × Configuration n L) : Configuration (m+n) L := |
| Fin.addCases p.1 p.2 |
|
|
| def splitConfiguration (m n : ℕ) (L : Length) (X : Configuration (m+n) L) : |
| Configuration m L × Configuration n L := |
| (fun i ↦ X (Fin.castAdd n i),fun i ↦ X (Fin.natAdd m i)) |
|
|
| lemma joinConfiguration_continuous (m n : ℕ) (L : Length) : |
| Continuous (joinConfiguration m n L) := by |
| apply continuous_pi |
| intro i |
| induction i using Fin.addCases with |
| | left i => simpa only [joinConfiguration,Fin.addCases_left,Function.comp_def] using |
| ((continuous_apply i).comp continuous_fst) |
| | right i => simpa only [joinConfiguration,Fin.addCases_right,Function.comp_def] using |
| ((continuous_apply i).comp continuous_snd) |
|
|
| lemma splitConfiguration_continuous (m n : ℕ) (L : Length) : |
| Continuous (splitConfiguration m n L) := by unfold splitConfiguration; fun_prop |
|
|
| @[simp] lemma split_joinConfiguration (m n : ℕ) (L : Length) |
| (p : Configuration m L × Configuration n L) : |
| splitConfiguration m n L (joinConfiguration m n L p)=p := by |
| ext <;> simp [splitConfiguration,joinConfiguration] |
|
|
| @[simp] lemma join_splitConfiguration (m n : ℕ) (L : Length) (X : Configuration (m+n) L) : |
| joinConfiguration m n L (splitConfiguration m n L X)=X := by |
| ext i j |
| induction i using Fin.addCases <;> simp [splitConfiguration,joinConfiguration] |
|
|
| lemma joinConfiguration_preserving (m n : ℕ) (L : Length) : |
| MeasurePreserving (joinConfiguration m n L) |
| ((volume : Measure (Configuration m L)).prod volume) volume := by |
| have h := (volume_measurePreserving_piCongrLeft (fun _ : Fin (m+n) ↦ Torus L) |
| (finSumFinEquiv (m:=m) (n:=n))).comp |
| (volume_measurePreserving_sumPiEquivProdPi_symm (fun _ : Fin m ⊕ Fin n ↦ Torus L)) |
| convert h using 1 |
| try rfl |
| funext p i |
| induction i using Fin.addCases <;> simp [joinConfiguration,MeasurableEquiv.coe_piCongrLeft, |
| MeasurableEquiv.coe_sumPiEquivProdPi_symm,Equiv.piCongrLeft_apply,Equiv.sumPiEquivProdPi_symm_apply] |
|
|
| lemma splitConfiguration_preserving (m n : ℕ) (L : Length) : |
| MeasurePreserving (splitConfiguration m n L) volume |
| ((volume : Measure (Configuration m L)).prod volume) := by |
| refine ⟨(splitConfiguration_continuous m n L).measurable,?_⟩ |
| rw [← (joinConfiguration_preserving m n L).map_eq, |
| Measure.map_map (splitConfiguration_continuous m n L).measurable |
| (joinConfiguration_continuous m n L).measurable] |
| simp only [Function.comp_def,split_joinConfiguration,Measure.map_id'] |
| |
| def joinConfigurationPath (m n : ℕ) (L : Length) |
| (p : ConfigurationPath m L × ConfigurationPath n L) : ConfigurationPath (m+n) L := |
| ⟨fun t ↦ joinConfiguration m n L (p.1 t,p.2 t), |
| (joinConfiguration_continuous m n L).comp (p.1.continuous.prodMk p.2.continuous)⟩ |
| |
| def splitConfigurationPath (m n : ℕ) (L : Length) (ω : ConfigurationPath (m+n) L) : |
| ConfigurationPath m L × ConfigurationPath n L := |
| (⟨fun t i ↦ ω t (Fin.castAdd n i),by fun_prop⟩, |
| ⟨fun t i ↦ ω t (Fin.natAdd m i),by fun_prop⟩) |
| |
| lemma joinConfigurationPath_continuous (m n : ℕ) (L : Length) : |
| Continuous (joinConfigurationPath m n L) := by |
| apply ContinuousMap.continuous_of_continuous_uncurry |
| exact (joinConfiguration_continuous m n L).comp |
| ((continuous_fst.fst.eval continuous_snd).prodMk |
| (continuous_fst.snd.eval continuous_snd)) |
| |
| lemma splitConfigurationPath_continuous (m n : ℕ) (L : Length) : |
| Continuous (splitConfigurationPath m n L) := by |
| apply Continuous.prodMk |
| all_goals |
| apply ContinuousMap.continuous_of_continuous_uncurry |
| apply continuous_pi |
| intro i |
| change Continuous (fun p : ConfigurationPath (m+n) L × Time ↦ p.1 p.2 _) |
| exact (continuous_apply _).comp (continuous_fst.eval continuous_snd) |
| |
| @[simp] lemma split_joinConfigurationPath (m n : ℕ) (L : Length) |
| (p : ConfigurationPath m L × ConfigurationPath n L) : |
| splitConfigurationPath m n L (joinConfigurationPath m n L p)=p := by |
| ext <;> simp [splitConfigurationPath,joinConfigurationPath,joinConfiguration] |
| |
| @[simp] lemma join_splitConfigurationPath (m n : ℕ) (L : Length) |
| (ω : ConfigurationPath (m+n) L) : |
| joinConfigurationPath m n L (splitConfigurationPath m n L ω)=ω := by |
| apply ContinuousMap.ext |
| intro t |
| exact join_splitConfiguration m n L (ω t) |
| |
| lemma measurePreserving_shuffle {A B C D : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| [MeasurableSpace C] [MeasurableSpace D] (μ : Measure A) (ν : Measure B) |
| (ξ : Measure C) (ζ : Measure D) [SFinite μ] [SFinite ν] [SFinite ξ] [SFinite ζ] : |
| MeasurePreserving (fun p : (A×B)×(C×D) ↦ ((p.1.1,p.2.1),(p.1.2,p.2.2))) |
| ((μ.prod ν).prod (ξ.prod ζ)) ((μ.prod ξ).prod (ν.prod ζ)) := by |
| have h1 := measurePreserving_prodAssoc μ ν (ξ.prod ζ) |
| have h2 := (MeasurePreserving.id μ).prod (measurePreserving_prodAssoc ν ξ ζ).symm |
| have h3 := (MeasurePreserving.id μ).prod |
| ((Measure.measurePreserving_swap (μ:=ν) (ν:=ξ)).prod (MeasurePreserving.id ζ)) |
| have h4 := (MeasurePreserving.id μ).prod (measurePreserving_prodAssoc ξ ν ζ) |
| have h5 := (measurePreserving_prodAssoc μ ξ (ν.prod ζ)).symm |
| exact h5.comp (h4.comp (h3.comp (h2.comp h1))) |
| |
| def directionSumEquiv (m n : ℕ) : Direction m ⊕ Direction n ≃ Direction (m+n) := |
| (Equiv.sumProdDistrib (Fin m) (Fin n) (Fin 3)).symm.trans |
| ((finSumFinEquiv (m:=m) (n:=n)).prodCongr (Equiv.refl (Fin 3))) |
| |
| def joinCoordinatePaths (m n : ℕ) (p : CoordinatePaths m × CoordinatePaths n) : CoordinatePaths (m+n) := |
| fun d ↦ Sum.elim p.1 p.2 ((directionSumEquiv m n).symm d) |
| |
| lemma joinCoordinatePaths_preserving (m n : ℕ) : |
| MeasurePreserving (joinCoordinatePaths m n) |
| ((coordinateWiener m).prod (coordinateWiener n)) (coordinateWiener (m+n)) := by |
| convert (measurePreserving_piCongrLeft (fun _ : Direction (m+n) ↦ wiener) |
| (directionSumEquiv m n)).comp |
| (measurePreserving_sumPiEquivProdPi_symm (fun _ : Direction m ⊕ Direction n ↦ wiener)) using 1 <;> try rfl |
| funext p d |
| simp [joinCoordinatePaths,MeasurableEquiv.coe_piCongrLeft, |
| MeasurableEquiv.coe_sumPiEquivProdPi_symm,Equiv.piCongrLeft_apply,Equiv.sumPiEquivProdPi_symm_apply] |
| cases (directionSumEquiv m n).symm d <;> rfl |
| |
| lemma freeTrajectory_join (m n : ℕ) (L : Length) (t : ℝ) |
| (w : CoordinatePaths m × CoordinatePaths n) (X : Configuration m L × Configuration n L) : |
| freeTrajectory (m+n) L t (joinCoordinatePaths m n w) (joinConfiguration m n L X)= |
| joinConfigurationPath m n L (freeTrajectory m L t w.1 X.1,freeTrajectory n L t w.2 X.2) := by |
| ext s i j |
| induction i using Fin.addCases <;> |
| simp [freeTrajectory,joinConfigurationPath,joinConfiguration,joinCoordinatePaths,directionSumEquiv] |
| |
| lemma joinConfigurationPath_preserving (m n : ℕ) (L : Length) (t : ℝ) : |
| MeasurePreserving (joinConfigurationPath m n L) |
| ((freePathLaw m L t).prod (freePathLaw n L t)) (freePathLaw (m+n) L t) := by |
| refine ⟨(joinConfigurationPath_continuous m n L).measurable,?_⟩ |
| have hj := ((joinCoordinatePaths_preserving m n).prod (joinConfiguration_preserving m n L)).comp |
| (measurePreserving_shuffle (coordinateWiener m) (volume : Measure (Configuration m L)) |
| (coordinateWiener n) (volume : Measure (Configuration n L))) |
| simp only [freePathLaw,Measure.map_prod_map _ _ (freeTrajectory_continuous m L t).measurable |
| (freeTrajectory_continuous n L t).measurable] |
| rw [Measure.map_map (joinConfigurationPath_continuous m n L).measurable |
| ((freeTrajectory_continuous m L t).measurable.prodMap (freeTrajectory_continuous n L t).measurable)] |
| rw [← hj.map_eq,Measure.map_map (freeTrajectory_continuous (m+n) L t).measurable hj.measurable] |
| congr 1 |
| funext p |
| exact (freeTrajectory_join m n L t (p.1.1,p.2.1) (p.1.2,p.2.2)).symm |
| |
| lemma splitConfigurationPath_preserving (m n : ℕ) (L : Length) (t : ℝ) : |
| MeasurePreserving (splitConfigurationPath m n L) (freePathLaw (m+n) L t) |
| ((freePathLaw m L t).prod (freePathLaw n L t)) := by |
| refine ⟨(splitConfigurationPath_continuous m n L).measurable,?_⟩ |
| rw [← (joinConfigurationPath_preserving m n L t).map_eq, |
| Measure.map_map (splitConfigurationPath_continuous m n L).measurable |
| (joinConfigurationPath_continuous m n L).measurable] |
| simp only [Function.comp_def,split_joinConfigurationPath,Measure.map_id'] |
|
|
| lemma staysAllowed_join_subset_bath (m n : ℕ) (L : Length) (a : ℝ) : |
| joinConfigurationPath m n L ⁻¹' staysAllowed (m+n) L a ⊆ |
| Prod.snd ⁻¹' staysAllowed n L a := by |
| rintro ⟨ω,η⟩ h x ⟨s,rfl⟩ i j hij |
| have hh := h ⟨s,rfl⟩ (Fin.natAdd m i) (Fin.natAdd m j) (by simpa using hij) |
| simpa [joinConfigurationPath,joinConfiguration] using hh |
| end |
| end HardSphere |
|
|
| end |
| end |
| end |
|
|
| end OAI |
|
|
