| import Mathlib |
| import OAI.Analysis.HardSphere.Cutoffs.DiameterTail |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
| noncomputable section |
| open MeasureTheory Set Filter ProbabilityTheory |
| open scoped ENNReal NNReal Topology BigOperators |
| namespace HardSphere.PathCutoff |
| open Wiener FreeVisits |
| attribute [local irreducible] torusDistance freeTrajectory |
|
|
| abbrev EuclideanPath := Fin 3 → C(Time,ℝ) |
| def IsPathLift {L : Length} (ω : ConfigurationPath 1 L) (ζ : EuclideanPath) : Prop := |
| ∀ j s, (ζ j s : AddCircle L.val)=ω s 0 j |
|
|
| lemma exists_pathLift {L : Length} (ω : ConfigurationPath 1 L) : ∃ ζ, IsPathLift ω ζ := by |
| have hx (j : Fin 3) : ∃ ζ : C(Time,ℝ), ∀ s, (ζ s : AddCircle L.val)=ω s 0 j := by |
| let γ : C(Time,AddCircle L.val) := ⟨fun s ↦ ω s 0 j, by fun_prop⟩ |
| let x : ℝ := ((AddCircle.equivIco L.val 0) (γ 0)).val |
| have h0 : γ 0=(x : AddCircle L.val) := AddCircle.coe_equivIco.symm |
| obtain ⟨ζ,hζ,_⟩ := (AddCircle.isCoveringMap_coe L.val).exists_path_lifts γ x h0 |
| exact ⟨ζ,fun s ↦ congrFun hζ s⟩ |
| choose ζ hζ using hx |
| exact ⟨ζ,hζ⟩ |
|
|
| lemma liftDiff_coe {L : Length} {ω : ConfigurationPath 1 L} {ζ : EuclideanPath} |
| (hζ : IsPathLift ω ζ) (j : Fin 3) (s q : Time) : |
| ((ζ j s-ζ j q : ℝ) : AddCircle L.val)=ω s 0 j-ω q 0 j := by |
| rw [AddCircle.coe_sub,hζ j s,hζ j q] |
|
|
| lemma liftDiff_lt_half_period {L : Length} {ω : ConfigurationPath 1 L} {ζ : EuclideanPath} |
| (hζ : IsPathLift ω ζ) (a b : Time) (hsmall : intervalDiameter a b ω < L.val/2) |
| (j : Fin 3) (s q : Time) : |
| |ζ j (intervalTime a b s)-ζ j (intervalTime a b q)| < L.val/2 := by |
| by_contra h |
| have hf : Continuous (fun v ↦ |ζ j (intervalTime a b v)-ζ j (intervalTime a b q)|) := |
| (((ζ j).continuous.comp (intervalTime_continuous a b)).sub continuous_const).abs |
| obtain ⟨v,hv⟩ := intermediate_value_univ q s hf ⟨by simp; exact div_nonneg L.property.le (by norm_num), |
| le_of_not_gt h⟩ |
| dsimp only at hv |
| have ha : |ζ j (intervalTime a b v)-ζ j (intervalTime a b q)| ≤ |L.val|/2 := by |
| rw [hv,abs_of_pos L.property] |
| have he := (AddCircle.norm_coe_eq_abs_iff L.val L.property.ne').mpr ha |
| rw [liftDiff_coe hζ,← dist_eq_norm,hv] at he |
| have hb := (CellOrbital.dist_coord_le_torusDistance L (ω (intervalTime a b v) 0) |
| (ω (intervalTime a b q) 0) j).trans (intervalDistance_le a b v q ω) |
| linarith |
|
|
| lemma liftDiff_norm_eq {L : Length} {ω : ConfigurationPath 1 L} {ζ : EuclideanPath} |
| (hζ : IsPathLift ω ζ) (a b : Time) (hsmall : intervalDiameter a b ω < L.val/2) |
| (j : Fin 3) (s q : Time) : |
| dist (ω (intervalTime a b s) 0 j) (ω (intervalTime a b q) 0 j)= |
| |ζ j (intervalTime a b s)-ζ j (intervalTime a b q)| := by |
| have hle := (liftDiff_lt_half_period hζ a b hsmall j s q).le |
| rw [← abs_of_pos L.property] at hle |
| have he := (AddCircle.norm_coe_eq_abs_iff L.val L.property.ne').mpr hle |
| simpa only [liftDiff_coe hζ,←dist_eq_norm] using he |
|
|
| def liftedDiameterMap (a b : Time) (ζ : EuclideanPath) : C(Time×Time,ℝ) := |
| ⟨fun p ↦ Real.sqrt (∑j, (ζ j (intervalTime a b p.1)-ζ j (intervalTime a b p.2))^2), by |
| apply Real.continuous_sqrt.comp |
| apply continuous_finsetSum |
| intro j _ |
| exact (((ζ j).continuous.comp ((intervalTime_continuous a b).comp continuous_fst)).sub |
| ((ζ j).continuous.comp ((intervalTime_continuous a b).comp continuous_snd))).pow 2⟩ |
|
|
| def liftedDiameter (a b : Time) (ζ : EuclideanPath) : ℝ := ‖liftedDiameterMap a b ζ‖ |
|
|
| lemma liftedDiameter_eq {L : Length} {ω : ConfigurationPath 1 L} {ζ : EuclideanPath} |
| (hζ : IsPathLift ω ζ) (a b : Time) (hsmall : intervalDiameter a b ω < L.val/2) : |
| liftedDiameter a b ζ=intervalDiameter a b ω := by |
| unfold liftedDiameter intervalDiameter |
| congr 1 |
| ext p |
| change Real.sqrt (∑j, (ζ j (intervalTime a b p.1)-ζ j (intervalTime a b p.2))^2)= |
| torusDistance L _ _ |
| simp only [torusDistance,liftDiff_norm_eq hζ a b hsmall,sq_abs] |
|
|
| end HardSphere.PathCutoff |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| open MeasureTheory Set Filter ProbabilityTheory |
| open scoped ENNReal NNReal Topology BigOperators |
| namespace HardSphere.PathCutoff |
| open Wiener FreeVisits |
| attribute [local irreducible] torusDistance freeTrajectory |
|
|
| lemma intervalDiameter_le_lifted {L : Length} {ω : ConfigurationPath 1 L} {ζ : EuclideanPath} |
| (hζ : IsPathLift ω ζ) (a b : Time) : intervalDiameter a b ω ≤ liftedDiameter a b ζ := by |
| apply intervalDiameter_le a b ω (norm_nonneg _) |
| intro s q |
| have hfirst : torusDistance L (ω (intervalTime a b s) 0) (ω (intervalTime a b q) 0) ≤ |
| liftedDiameterMap a b ζ (s,q) := by |
| unfold torusDistance liftedDiameterMap |
| apply Real.sqrt_le_sqrt |
| apply Finset.sum_le_sum |
| intro j _ |
| have hle : dist (ω (intervalTime a b s) 0 j) (ω (intervalTime a b q) 0 j) ≤ |
| |ζ j (intervalTime a b s)-ζ j (intervalTime a b q)| := by |
| rw [dist_eq_norm,←liftDiff_coe hζ] |
| exact QuotientAddGroup.norm_mk_le_norm |
| have hh := pow_le_pow_left₀ dist_nonneg hle 2 |
| simpa only [sq_abs] using hh |
| exact hfirst.trans ((le_abs_self _).trans (ContinuousMap.norm_coe_le_norm (liftedDiameterMap a b ζ) (s,q))) |
|
|
| lemma interval_small_iff_lifted_small {L : Length} {ω : ConfigurationPath 1 L} {ζ : EuclideanPath} |
| (hζ : IsPathLift ω ζ) (a b : Time) {R : ℝ} (hR : R < L.val/2) : |
| intervalDiameter a b ω ≤ R ↔ liftedDiameter a b ζ ≤ R := by |
| constructor |
| · intro h |
| rw [liftedDiameter_eq hζ a b (h.trans_lt hR)] |
| exact h |
| · exact fun h ↦ (intervalDiameter_le_lifted hζ a b).trans h |
|
|
| lemma intervalTime_assoc (a b c d s : Time) : |
| intervalTime a b (intervalTime c d s)=intervalTime (intervalTime a b c) (intervalTime a b d) s := by |
| apply Subtype.ext |
| dsimp [intervalTime] |
| ring |
|
|
| lemma meshSegment_lift {L : Length} {m : ℕ} {ω : ConfigurationPath 1 L} {ζ : EuclideanPath} |
| (hζ : IsPathLift ω ζ) (j : Fin m) : |
| IsPathLift (meshSegment j ω) (fun k ↦ (ζ k).comp ⟨meshTime j,meshTime_continuous j⟩) := by |
| intro k s |
| exact hζ k _ |
|
|
| end HardSphere.PathCutoff |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| open MeasureTheory Set Filter ProbabilityTheory |
| open scoped ENNReal NNReal Topology BigOperators |
| namespace HardSphere.PathCutoff |
| open Wiener FreeVisits |
| attribute [local irreducible] torusDistance freeTrajectory |
|
|
| lemma diameterRatio_reverse {L : Length} (r : ℝ) (ω : ConfigurationPath 1 L) : |
| diameterRatio r (reverseConfigurationPath 1 L ω)=diameterRatio r ω := by |
| unfold diameterRatio |
| rw [intervalDiameter_reverse] |
| simp [reverseTime] |
|
|
| lemma meshRegular_reverse {L : Length} (m : ℕ) (r R C : ℝ) (ω : ConfigurationPath 1 L) : |
| MeshRegular m r R C (reverseConfigurationPath 1 L ω) ↔ MeshRegular m r R C ω := by |
| unfold MeshRegular |
| rw [mesh_sum_reverse _ (cubicCost_reverse r)] |
| simp only [meshSegment_reverse,diameterRatio_reverse] |
| constructor |
| · rintro ⟨h,h'⟩ |
| exact ⟨fun j ↦ by simpa using h j.rev,h'⟩ |
| · rintro ⟨h,h'⟩ |
| exact ⟨fun j ↦ h j.rev,h'⟩ |
|
|
| def EndpointRegular {L : Length} (u : Time) (S : ℝ) (ω : ConfigurationPath 1 L) : Prop := |
| intervalDiameter 0 u ω ≤ S ∧ intervalDiameter (reverseTime u) 1 ω ≤ S |
|
|
| def Regular {L : Length} (m : ℕ) (r R C : ℝ) (u : Time) (S : ℝ) (ω : ConfigurationPath 1 L) : Prop := |
| MeshRegular m r R C ω ∧ EndpointRegular u S ω |
|
|
| lemma regular_measurable {L : Length} (m : ℕ) (r R C : ℝ) (u : Time) (S : ℝ) : |
| MeasurableSet {ω : ConfigurationPath 1 L | Regular m r R C u S ω} := by |
| change MeasurableSet ({ω | MeshRegular m r R C ω} ∩ |
| ({ω | intervalDiameter 0 u ω ≤ S} ∩ {ω | intervalDiameter (reverseTime u) 1 ω ≤ S})) |
| exact (meshRegular_measurable m r R C).inter |
| ((measurableSet_le (intervalDiameter_continuous L 0 u).measurable measurable_const).inter |
| (measurableSet_le (intervalDiameter_continuous L (reverseTime u) 1).measurable measurable_const)) |
|
|
| lemma endpointRegular_reverse {L : Length} (u : Time) (S : ℝ) (ω : ConfigurationPath 1 L) : |
| EndpointRegular u S (reverseConfigurationPath 1 L ω) ↔ EndpointRegular u S ω := by |
| unfold EndpointRegular |
| rw [intervalDiameter_reverse,intervalDiameter_reverse,reverseTime_reverse] |
| simpa only [reverseTime_zero,reverseTime_one] using (and_comm : (_ ∧ _) ↔ (_ ∧ _)) |
|
|
| lemma regular_reverse {L : Length} (m : ℕ) (r R C : ℝ) (u : Time) (S : ℝ) (ω : ConfigurationPath 1 L) : |
| Regular m r R C u S (reverseConfigurationPath 1 L ω) ↔ Regular m r R C u S ω := by |
| exact and_congr (meshRegular_reverse m r R C ω) (endpointRegular_reverse u S ω) |
|
|
| lemma mesh_lift_diameter {L : Length} {m : ℕ} {ω : ConfigurationPath 1 L} {ζ : EuclideanPath} |
| (hζ : IsPathLift ω ζ) {r R : ℝ} (hr : 0 < r) (hR : R*r < L.val/2) |
| (hmax : ∀j : Fin m,diameterRatio r (meshSegment j ω) ≤ R) (j : Fin m) : |
| liftedDiameter 0 1 (fun k ↦ (ζ k).comp ⟨meshTime j,meshTime_continuous j⟩)= |
| intervalDiameter 0 1 (meshSegment j ω) := by |
| apply liftedDiameter_eq (meshSegment_lift hζ j) |
| exact ((div_le_iff₀ hr).mp (hmax j)).trans_lt hR |
|
|
| lemma regular_lifted_iff {L : Length} {m : ℕ} {ω : ConfigurationPath 1 L} {ζ : EuclideanPath} |
| (hζ : IsPathLift ω ζ) {r R C S : ℝ} (u : Time) (hr : 0 < r) |
| (hR : R*r < L.val/2) (hS : S < L.val/2) : |
| Regular m r R C u S ω ↔ |
| ((∀j : Fin m,liftedDiameter 0 1 (fun k ↦ (ζ k).comp ⟨meshTime j,meshTime_continuous j⟩)/r ≤ R) ∧ |
| (∑j : Fin m,(1+liftedDiameter 0 1 (fun k ↦ (ζ k).comp ⟨meshTime j,meshTime_continuous j⟩)/r)^3) ≤ C*(m:ℝ)) ∧ |
| (liftedDiameter 0 u ζ ≤ S ∧ liftedDiameter (reverseTime u) 1 ζ ≤ S) := by |
| constructor |
| · rintro ⟨⟨hm,ha⟩,hb⟩ |
| have he := mesh_lift_diameter hζ hr hR hm |
| refine ⟨⟨?_,?_⟩,?_,?_⟩ |
| · simpa only [he,diameterRatio] using hm |
| · simpa only [he,cubicCost,diameterRatio] using ha |
| · exact (interval_small_iff_lifted_small hζ 0 u hS).mp hb.1 |
| · exact (interval_small_iff_lifted_small hζ (reverseTime u) 1 hS).mp hb.2 |
| · rintro ⟨⟨hm,ha⟩,hb⟩ |
| have ht : ∀j : Fin m,diameterRatio r (meshSegment j ω) ≤ R := fun j ↦ |
| (div_le_div_of_nonneg_right (intervalDiameter_le_lifted (meshSegment_lift hζ j) 0 1) hr.le).trans (hm j) |
| have he := mesh_lift_diameter hζ hr hR ht |
| refine ⟨⟨ht,?_⟩,?_,?_⟩ |
| · simpa only [he,cubicCost,diameterRatio] using ha |
| · exact (interval_small_iff_lifted_small hζ 0 u hS).mpr hb.1 |
| · exact (interval_small_iff_lifted_small hζ (reverseTime u) 1 hS).mpr hb.2 |
|
|
| lemma interval_prefix {L : Length} (u : Time) (ω : ConfigurationPath 1 L) : |
| intervalDiameter 0 u ω=intervalDiameter 0 1 (configurationPrefix 1 L u ω) := by |
| apply congrArg norm |
| apply ContinuousMap.ext |
| intro p |
| change torusDistance L (ω (intervalTime 0 u p.1) 0) (ω (intervalTime 0 u p.2) 0)= |
| torusDistance L (ω (prefixTime u (intervalTime 0 1 p.1)) 0) (ω (prefixTime u (intervalTime 0 1 p.2)) 0) |
| have he (s : Time) : intervalTime 0 u s=prefixTime u (intervalTime 0 1 s) := by |
| apply Subtype.ext |
| simp [intervalTime,prefixTime,mul_comm] |
| rw [he,he] |
|
|
| lemma interval_suffix {L : Length} (u : Time) (ω : ConfigurationPath 1 L) : |
| intervalDiameter u 1 ω=intervalDiameter 0 1 (configurationSuffix 1 L u ω) := by |
| apply congrArg norm |
| apply ContinuousMap.ext |
| intro p |
| change torusDistance L (ω (intervalTime u 1 p.1) 0) (ω (intervalTime u 1 p.2) 0)= |
| torusDistance L (ω (suffixTime u (intervalTime 0 1 p.1)) 0) (ω (suffixTime u (intervalTime 0 1 p.2)) 0) |
| have he (s : Time) : intervalTime u 1 s=suffixTime u (intervalTime 0 1 s) := by |
| apply Subtype.ext |
| change (1-(s:ℝ))*(u:ℝ)+(s:ℝ)*1 = (u:ℝ)+(1-(u:ℝ))*((1-(s:ℝ))*0+(s:ℝ)*1) |
| ring |
| rw [he,he] |
|
|
| end HardSphere.PathCutoff |
|
|
| end |
| end |
|
|
| end |
|
|
| end OAI |
|
|
