math / data /lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Flow /FlowPointwise.lean
Download data/lean/OAI/MathematicalPhysics/NavierStokes/ForcedComputation/Flow/FlowPointwise.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 3.17 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/NavierStokes/ForcedComputation/Flow/FlowPointwise.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/MathematicalPhysics/NavierStokes/ForcedComputation/Flow/FlowPointwise.lean
-
curl -L -o FlowPointwise.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/NavierStokes/ForcedComputation/Flow/FlowPointwise.lean
3.17 kB
| import Mathlib.Analysis.Calculus.ContDiff.Basic | |
| import Mathlib.Analysis.Calculus.MeanValue | |
| import Mathlib.Topology.ContinuousMap.Compact | |
| namespace OAI | |
| /-! Pointwise calculus on the compact path space used in the local flow proof. | |
| The continuous linear map below lifts a continuously varying linear map to | |
| continuous paths. No differential-equation hypothesis is used here. -/ | |
| noncomputable section | |
| namespace ForcedComputation.Flow | |
| open Set Filter | |
| open scoped Topology ContDiff | |
| variable {K E F : Type*} [TopologicalSpace K] [CompactSpace K] | |
| [NormedAddCommGroup E] [NormedSpace β E] | |
| [NormedAddCommGroup F] [NormedSpace β F] | |
| /-- Apply a continuous family of linear maps pointwise to a path. -/ | |
| def applyPath (A : C(K, E βL[β] F)) : C(K, E) βL[β] C(K, F) := | |
| LinearMap.mkContinuous | |
| { toFun := fun u => β¨fun t => A t (u t), A.continuous.clm_apply u.continuousβ© | |
| map_add' := by | |
| intro u v | |
| ext t | |
| change A t (u t + v t) = A t (u t) + A t (v t) | |
| exact map_add (A t) (u t) (v t) | |
| map_smul' := by | |
| intro c u | |
| ext t | |
| change A t (c β’ u t) = c β’ A t (u t) | |
| exact map_smul (A t) c (u t) } | |
| βAβ (by | |
| 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 _))) | |
| @[simp] theorem applyPath_apply (A : C(K, E βL[β] F)) (u : C(K, E)) (t : K) : | |
| applyPath A u t = A t (u t) := rfl | |
| theorem applyPath_norm (A : C(K, E βL[β] F)) : βapplyPath Aβ β€ βAβ := | |
| LinearMap.mkContinuous_norm_le _ (norm_nonneg A) _ | |
| /-- Pointwise application depends continuously and linearly on the family. -/ | |
| def applyPathL : C(K, E βL[β] F) βL[β] (C(K, E) βL[β] C(K, F)) := | |
| LinearMap.mkContinuous | |
| { toFun := fun A : C(K, E βL[β] F) => applyPath A | |
| map_add' := by | |
| intro A B | |
| ext u t | |
| change (A t + B t) (u t) = A t (u t) + B t (u t) | |
| exact add_apply _ _ _ | |
| map_smul' := by | |
| intro c A | |
| ext u t | |
| rfl } | |
| 1 (by | |
| intro A | |
| change βapplyPath Aβ β€ (1 : β) * βAβ | |
| rw [one_mul] | |
| exact applyPath_norm A) | |
| @[simp] theorem applyPathL_apply (A : C(K, E βL[β] F)) : | |
| applyPathL A = applyPath A := rfl | |
| /-- A uniform derivative modulus bounds the first-order remainder on a segment. -/ | |
| theorem remainder_bound {f : E β F} {df : E β E βL[β] F} | |
| (hf : β z, HasFDerivAt f (df z) z) (x y : E) {Ξ΅ : β} | |
| (hΞ΅ : β z β segment β x y, βdf z - df xβ β€ Ξ΅) : | |
| βf y - f x - df x (y - x)β β€ Ξ΅ * βy - xβ := by | |
| have h := (convex_segment x y).norm_image_sub_le_of_norm_hasFDerivWithin_le | |
| (f := fun z => f z - df x z) (f' := fun z => df z - df x) | |
| (fun z _ => ((hf z).sub (df x).hasFDerivAt).hasFDerivWithinAt) | |
| hΞ΅ (left_mem_segment β x y) (right_mem_segment β x y) | |
| have he : (f y - df x y) - (f x - df x x) = f y - f x - df x (y - x) := by | |
| rw [map_sub] | |
| abel | |
| rwa [he] at h | |
| end ForcedComputation.Flow | |
| end | |
| end OAI | |