Download data/lean/OAI/Analysis/BiholderTransport/Calculus/PathCalculus.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 5.88 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/BiholderTransport/Calculus/PathCalculus.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/BiholderTransport/Calculus/PathCalculus.lean
-
curl -L -o PathCalculus.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/BiholderTransport/Calculus/PathCalculus.lean
5.88 kB
| import Mathlib | |
| namespace OAI | |
| noncomputable section | |
| open Set MeasureTheory Manifold Bundle | |
| open scoped ContDiff Manifold ENNReal NNReal Topology | |
| open Set Filter | |
| open scoped Topology NNReal | |
| open Set Filter | |
| open scoped Topology | |
| open Set Manifold MeasureTheory Bundle | |
| open scoped ENNReal ContDiff Topology | |
| open Set | |
| open scoped Topology | |
| open Set Filter Manifold Bundle ContinuousLinearMap | |
| open scoped Topology ContDiff Manifold Bundle | |
| open Set Filter ContinuousLinearMap InnerProductSpace | |
| open scoped Topology ContDiff | |
| open Set Filter ContinuousLinearMap | |
| open scoped Topology ContDiff | |
| namespace WeakMTWTransport | |
| universe u w | |
| variable {K : Type w} {E F : Type u} [TopologicalSpace K] [CompactSpace K] | |
| [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| local instance pathCalculusNormedAddCommGroupContinuousLinearMap : | |
| NormedAddCommGroup (E βL[β] F) := ContinuousLinearMap.toNormedAddCommGroup | |
| local instance pathCalculusNormedSpaceContinuousLinearMap : | |
| NormedSpace β (E βL[β] F) := ContinuousLinearMap.toNormedSpace | |
| local instance pathCalculusNormedAddCommGroupContinuousMap : | |
| NormedAddCommGroup C(K,E βL[β] F) := ContinuousMap.instNormedAddCommGroup | |
| def pathLinearApply (A : C(K,E βL[β] F)) : C(K,E) βL[β] C(K,F) := by | |
| let L : C(K,E) ββ[β] C(K,F) := | |
| { toFun := fun u => β¨fun t => A t (u t),A.continuous.clm_apply u.continuousβ© | |
| map_add' := by intro u v; ext t; exact map_add (A t) (u t) (v t) | |
| map_smul' := by intro c u; ext t; exact map_smul (A t) c (u t) } | |
| exact L.mkContinuous βAβ (by | |
| intro u | |
| change β(β¨fun t => A t (u t),A.continuous.clm_apply u.continuousβ© : C(K,F))β β€ βAβ * βuβ | |
| apply (ContinuousMap.norm_le _ (mul_nonneg (norm_nonneg A) (norm_nonneg u))).mpr | |
| intro t | |
| exact (A t).le_opNorm (u t) |>.trans | |
| (mul_le_mul (A.norm_coe_le_norm t) (u.norm_coe_le_norm t) | |
| (norm_nonneg _) (norm_nonneg _))) | |
| @[simp] lemma pathLinearApply_apply (A : C(K,E βL[β] F)) (u : C(K,E)) (t : K) : | |
| pathLinearApply A u t = A t (u t) := rfl | |
| lemma norm_pathLinearApply_le (A : C(K,E βL[β] F)) : βpathLinearApply Aβ β€ βAβ := by | |
| apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg A) | |
| intro u | |
| apply (ContinuousMap.norm_le _ (mul_nonneg (norm_nonneg A) (norm_nonneg u))).mpr | |
| intro t | |
| exact (A t).le_opNorm (u t) |>.trans | |
| (mul_le_mul (A.norm_coe_le_norm t) (u.norm_coe_le_norm t) | |
| (norm_nonneg _) (norm_nonneg _)) | |
| def pathLinearApplyL : C(K,E βL[β] F) βL[β] C(K,E) βL[β] C(K,F) := by | |
| let L : C(K,E βL[β] F) ββ[β] C(K,E) βL[β] C(K,F) := | |
| { toFun := fun (A : C(K,E βL[β] F)) => pathLinearApply A | |
| map_add' := by intro A B; ext u t; rfl | |
| map_smul' := by intro c A; ext u t; rfl } | |
| refine LinearMap.mkContinuous (π := β) (πβ := β) | |
| (E := C(K,E βL[β] F)) (F := C(K,E) βL[β] C(K,F)) L 1 ?_ | |
| intro A | |
| change βpathLinearApply Aβ β€ 1 * βAβ | |
| simpa only [one_mul] using norm_pathLinearApply_le A | |
| lemma hasFDerivAt_path_comp (f : C(E,F)) (f' : C(E,E βL[β] F)) | |
| (hder : β x, HasFDerivAt f (f' x) x) (u : C(K,E)) : | |
| HasFDerivAt (fun v : C(K,E) => f.comp v) (pathLinearApply (f'.comp u)) u := by | |
| rw [hasFDerivAt_iff_isLittleO_nhds_zero,Asymptotics.isLittleO_iff] | |
| intro Ξ΅ hΞ΅ | |
| have hc : IsCompact (range u) := isCompact_range u.continuous | |
| have huni := hc.uniformContinuousAt_of_continuousAt f' | |
| (fun _ _ => f'.continuous.continuousAt) | |
| (r := {z : (E βL[β] F) Γ (E βL[β] F) | dist z.1 z.2 < Ξ΅}) | |
| (Metric.mem_uniformity_dist.mpr β¨Ξ΅,hΞ΅,fun {_ _} h => hβ©) | |
| obtain β¨Ξ΄,hΞ΄,hcloseβ© := Metric.mem_uniformity_dist.mp huni | |
| filter_upwards [Metric.ball_mem_nhds (0:C(K,E)) hΞ΄] with v hv | |
| have hvnorm : βvβ < Ξ΄ := by simpa using hv | |
| apply (ContinuousMap.norm_le _ (mul_nonneg hΞ΅.le (norm_nonneg v))).mpr | |
| intro t | |
| have hbound : β z β Metric.ball (u t) Ξ΄, βf' z - f' (u t)β β€ Ξ΅ := by | |
| intro z hz | |
| have hh := hclose (by simpa only [Metric.mem_ball,dist_comm] using hz) (mem_range_self t) | |
| change dist (f' (u t)) (f' z) < Ξ΅ at hh | |
| exact le_of_lt (by simpa only [dist_eq_norm, norm_sub_rev] using hh) | |
| have hb : u t + v t β Metric.ball (u t) Ξ΄ := by | |
| rw [Metric.mem_ball,dist_eq_norm,add_sub_cancel_left] | |
| exact (v.norm_coe_le_norm t).trans_lt hvnorm | |
| have hm := Convex.norm_image_sub_le_of_norm_hasFDerivWithin_le' | |
| (fun z (_ : z β Metric.ball (u t) Ξ΄) => (hder z).hasFDerivWithinAt) | |
| hbound (convex_ball (u t) Ξ΄) (Metric.mem_ball_self hΞ΄) hb | |
| have heq : ((f.comp (u+v) - f.comp u - pathLinearApply (f'.comp u) v) t) = | |
| f (u t + v t) - f (u t) - f' (u t) ((u t + v t) - u t) := by | |
| simp only [ContinuousMap.sub_apply,ContinuousMap.comp_apply,ContinuousMap.add_apply, | |
| pathLinearApply_apply,add_sub_cancel_left] | |
| rw [heq] | |
| exact hm.trans (by simpa only [add_sub_cancel_left] using | |
| mul_le_mul_of_nonneg_left (v.norm_coe_le_norm t) hΞ΅.le) | |
| lemma contDiff_path_comp_nat (m : β) (f : C(E,F)) (hf : ContDiff β m f) : | |
| ContDiff β m (fun v : C(K,E) => f.comp v) := by | |
| induction m generalizing F with | |
| | zero => exact contDiff_zero.mpr f.continuous_postcomp | |
| | succ m ih => | |
| obtain β¨f',hf',hderβ© := contDiff_succ_iff_hasFDerivAt.mp hf | |
| let F' : C(E,E βL[β] F) := β¨f',hf'.continuousβ© | |
| apply contDiff_succ_iff_hasFDerivAt.mpr | |
| refine β¨fun v => pathLinearApply (F'.comp v),?_,?_β© | |
| Β· exact (pathLinearApplyL (K := K) (E := E) (F := F)).contDiff.comp | |
| (ih F' hf') | |
| Β· intro u; exact hasFDerivAt_path_comp f F' hder u | |
| lemma contDiff_path_comp (f : C(E,F)) (hf : ContDiff β β f) : | |
| ContDiff β β (fun v : C(K,E) => f.comp v) := | |
| contDiff_infty.mpr fun m => contDiff_path_comp_nat m f (contDiff_infty.mp hf m) | |
| end WeakMTWTransport | |
| end | |
| end OAI | |