File size: 3,171 Bytes
4a56cd6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 | 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
|