Download data/lean/OAI/Analysis/HardSphere/Conditioning/ReverseConfigurationPath.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 6.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/HardSphere/Conditioning/ReverseConfigurationPath.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/HardSphere/Conditioning/ReverseConfigurationPath.lean
-
curl -L -o ReverseConfigurationPath.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/HardSphere/Conditioning/ReverseConfigurationPath.lean
6.6 kB
| import Mathlib | |
| import OAI.Analysis.HardSphere.Geometry.ConfigurationPath | |
| import OAI.Analysis.HardSphere.Bridges.ReverseTime | |
| 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 | |
| def reverseConfigurationPath (N : β) (L : Length) (Ο : ConfigurationPath N L) : | |
| ConfigurationPath N L := Ο.comp reverseTime | |
| lemma reverseConfigurationPath_continuous (N : β) (L : Length) : | |
| Continuous (reverseConfigurationPath N L) := by | |
| apply ContinuousMap.continuous_of_continuous_uncurry | |
| change Continuous (fun p : ConfigurationPath N L Γ Time β¦ p.1 (reverseTime p.2)) | |
| fun_prop | |
| @[simp] lemma reverseConfigurationPath_apply (N : β) (L : Length) | |
| (Ο : ConfigurationPath N L) (s : Time) : | |
| reverseConfigurationPath N L Ο s = Ο (reverseTime s) := rfl | |
| @[simp] lemma reverseConfigurationPath_reverse (N : β) (L : Length) | |
| (Ο : ConfigurationPath N L) : | |
| reverseConfigurationPath N L (reverseConfigurationPath N L Ο) = Ο := by | |
| ext s i j | |
| simp only [reverseConfigurationPath_apply,reverseTime_reverse] | |
| lemma staysAllowed_reverse (N : β) (L : Length) (a : β) : | |
| reverseConfigurationPath N L β»ΒΉ' staysAllowed N L a = staysAllowed N L a := by | |
| ext Ο | |
| change (Set.range (reverseConfigurationPath N L Ο) β allowed N L a) β | |
| (Set.range Ο β allowed N L a) | |
| have hr : Set.range (reverseConfigurationPath N L Ο) = Set.range Ο := by | |
| change Set.range (Ο β reverseTime) = Set.range Ο | |
| exact (Function.Involutive.surjective reverseTime_reverse).range_comp Ο | |
| rw [hr] | |
| lemma coordinateReverse_preserving (N : β) : | |
| MeasurePreserving (fun w : CoordinatePaths N β¦ fun p β¦ reverseIncrements (w p)) | |
| (coordinateWiener N) (coordinateWiener N) := by | |
| refine β¨Measurable.of_eval fun p β¦ reverseIncrements.continuous.measurable.comp (measurable_pi_apply p), ?_β© | |
| unfold coordinateWiener | |
| rw [Measure.pi_map_pi (fun _ β¦ reverseIncrements.continuous.measurable.aemeasurable)] | |
| simp_rw [reverseIncrements_preserving.map_eq] | |
| lemma reverse_freeTrajectory (N : β) (L : Length) (t : β) (w : CoordinatePaths N) | |
| (X : Configuration N L) : | |
| reverseConfigurationPath N L (freeTrajectory N L t w X) = | |
| freeTrajectory N L t (fun p β¦ reverseIncrements (w p)) | |
| (freeTrajectory N L t w X 1) := by | |
| ext s i j | |
| change X i j + ((Real.sqrt (2*t)*w (i,j) (reverseTime s) : β) : AddCircle L.val) = | |
| (X i j + ((Real.sqrt (2*t)*w (i,j) 1 : β) : AddCircle L.val)) + | |
| ((Real.sqrt (2*t)*(w (i,j) (reverseTime s)-w (i,j) 1) : β) : AddCircle L.val) | |
| rw [mul_sub,AddCircle.coe_sub] | |
| abel | |
| lemma reverse_freePath_preserving (N : β) (L : Length) (t : β) : | |
| MeasurePreserving (reverseConfigurationPath N L) (freePathLaw N L t) (freePathLaw N L t) := by | |
| let : (volume : Measure (Torus L)).IsAddLeftInvariant := by | |
| rw [volume_pi] | |
| exact Measure.pi.isAddLeftInvariant _ | |
| let : (volume : Measure (Configuration N L)).IsAddLeftInvariant := by | |
| rw [volume_pi] | |
| exact Measure.pi.isAddLeftInvariant _ | |
| let : (volume : Measure (Configuration N L)).IsAddRightInvariant := | |
| IsAddLeftInvariant.isAddRightInvariant | |
| have hm : Measurable (fun p : CoordinatePaths N Γ Configuration N L β¦ | |
| freeTrajectory N L t p.1 p.2 1) := | |
| ((freeTrajectory_continuous N L t).eval continuous_const).measurable | |
| have hskew := (coordinateReverse_preserving N).skew_product hm | |
| (Filter.Eventually.of_forall (fun w : CoordinatePaths N β¦ | |
| map_add_right_eq_self (volume : Measure (Configuration N L)) | |
| (fun i j β¦ ((Real.sqrt (2*t) * w (i,j) 1 : β) : AddCircle L.val)))) | |
| refine β¨(reverseConfigurationPath_continuous N L).measurable, ?_β© | |
| unfold freePathLaw | |
| rw [Measure.map_map (reverseConfigurationPath_continuous N L).measurable | |
| (freeTrajectory_continuous N L t).measurable] | |
| have heq : (reverseConfigurationPath N L β | |
| (fun p : CoordinatePaths N Γ Configuration N L β¦ freeTrajectory N L t p.1 p.2)) = | |
| (fun p : CoordinatePaths N Γ Configuration N L β¦ freeTrajectory N L t p.1 p.2) β | |
| (fun p β¦ (fun q β¦ reverseIncrements (p.1 q), freeTrajectory N L t p.1 p.2 1)) := by | |
| funext p | |
| exact reverse_freeTrajectory N L t p.1 p.2 | |
| change MeasurePreserving | |
| (fun p : CoordinatePaths N Γ Configuration N L β¦ | |
| (fun q β¦ reverseIncrements (p.1 q), freeTrajectory N L t p.1 p.2 1)) | |
| ((coordinateWiener N).prod volume) ((coordinateWiener N).prod volume) at hskew | |
| rw [heq, β Measure.map_map (freeTrajectory_continuous N L t).measurable hskew.measurable, | |
| hskew.map_eq] | |
| lemma reverse_killedPath_preserving (N : β) (L : Length) (a t : β) : | |
| MeasurePreserving (reverseConfigurationPath N L) (killedPathLaw N L a t) | |
| (killedPathLaw N L a t) := by | |
| refine β¨(reverseConfigurationPath_continuous N L).measurable,?_β© | |
| unfold killedPathLaw | |
| conv_rhs => rw [β (reverse_freePath_preserving N L t).map_eq] | |
| rw [Measure.restrict_map (reverseConfigurationPath_continuous N L).measurable | |
| (staysAllowed_open N L a).measurableSet, staysAllowed_reverse] | |
| def reversePathEquiv (N : β) (L : Length) : ConfigurationPath N L βα΅ ConfigurationPath N L where | |
| toFun := reverseConfigurationPath N L | |
| invFun := reverseConfigurationPath N L | |
| left_inv := reverseConfigurationPath_reverse N L | |
| right_inv := reverseConfigurationPath_reverse N L | |
| measurable_toFun := (reverseConfigurationPath_continuous N L).measurable | |
| measurable_invFun := (reverseConfigurationPath_continuous N L).measurable | |
| lemma killedTransition_selfAdjoint (N : β) (L : Length) (a t : β) : | |
| IsSelfAdjoint (killedTransition N L a t) := by | |
| apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr | |
| intro f g | |
| change inner β (killedTransition N L a t f) g = inner β f (killedTransition N L a t g) | |
| rw [β inner_conj_symm, killedTransition_pairing, β integral_conj, killedTransition_pairing] | |
| have h := (reverse_killedPath_preserving N L a t).integral_comp | |
| (reversePathEquiv N L).measurableEmbedding | |
| (fun Ο : ConfigurationPath N L β¦ conj (f (Ο 0)) * g (Ο 1)) | |
| rw [β h] | |
| apply integral_congr_ae | |
| filter_upwards [] with Ο | |
| simp only [map_mul,starRingEnd_self_apply,reverseConfigurationPath_apply,reverseTime_zero, | |
| reverseTime_one] | |
| ring | |
| end HardSphere | |
| end | |
| end OAI | |