math / data /lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Flow /FlowPicardSmooth.lean
Download data/lean/OAI/MathematicalPhysics/NavierStokes/ForcedComputation/Flow/FlowPicardSmooth.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 5.76 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/NavierStokes/ForcedComputation/Flow/FlowPicardSmooth.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/MathematicalPhysics/NavierStokes/ForcedComputation/Flow/FlowPicardSmooth.lean
-
curl -L -o FlowPicardSmooth.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/MathematicalPhysics/NavierStokes/ForcedComputation/Flow/FlowPicardSmooth.lean
5.76 kB
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Flow.FlowSuperposition | |
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Flow.FlowPathIntegral | |
| import Mathlib.Analysis.Calculus.ImplicitContDiff | |
| import Mathlib.Analysis.Normed.Operator.Banach | |
| import Mathlib.Analysis.SpecificLimits.Normed | |
| namespace OAI | |
| /-! Smooth Picard residual on a fixed unit interval. The elapsed time is a | |
| parameter, so evaluating the solution at the endpoint is a bounded linear map. -/ | |
| noncomputable section | |
| namespace ForcedComputation.Flow | |
| open Set | |
| open scoped Topology ContDiff | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace β E] | |
| [FiniteDimensional β E] [CompleteSpace E] | |
| def picardResidual (Z : C(E, E)) (p : (β Γ E) Γ C(UnitTime, E)) : C(UnitTime, E) := | |
| p.2 - ContinuousLinearMap.const β UnitTime p.1.2 - | |
| p.1.1 β’ primitivePathL (postcompose Z p.2) | |
| theorem picardResidual_smooth (Z : C(E, E)) (hZ : ContDiff β β (Z : E β E)) : | |
| ContDiff β β (picardResidual Z) := by | |
| have ht : ContDiff β β (fun p : (β Γ E) Γ C(UnitTime, E) => p.1.1) := | |
| contDiff_fst.fst | |
| have hx : ContDiff β β (fun p : (β Γ E) Γ C(UnitTime, E) => p.1.2) := | |
| contDiff_fst.snd | |
| have hΞ³ : ContDiff β β (fun p : (β Γ E) Γ C(UnitTime, E) => p.2) := contDiff_snd | |
| exact (hΞ³.sub ((ContinuousLinearMap.const β UnitTime).contDiff.comp hx)).sub | |
| (ht.smul ((primitivePathL (E := E)).contDiff.comp | |
| ((postcompose_contDiff Z hZ).comp hΞ³))) | |
| def picardPathDerivative (Z : C(E, E)) (hZ : ContDiff β β (Z : E β E)) | |
| (Ο : β) (Ξ³ : C(UnitTime, E)) : C(UnitTime, E) βL[β] C(UnitTime, E) := | |
| 1 - Ο β’ primitivePathL.comp | |
| (applyPath β¨fun s => fderiv β Z (Ξ³ s), | |
| (hZ.continuous_fderiv (by simp)).comp Ξ³.continuousβ©) | |
| theorem picardResidual_hasFDerivAt_path (Z : C(E, E)) | |
| (hZ : ContDiff β β (Z : E β E)) (Ο : β) (x : E) (Ξ³ : C(UnitTime, E)) : | |
| HasFDerivAt (fun Ξ· => picardResidual Z ((Ο, x), Ξ·)) | |
| (picardPathDerivative Z hZ Ο Ξ³) Ξ³ := by | |
| have hs := postcompose_hasFDerivAt Z (hZ.of_le (by simp)) Ξ³ | |
| have hp := primitivePathL.hasFDerivAt.comp Ξ³ hs | |
| exact ((hasFDerivAt_id Ξ³).sub_const (ContinuousLinearMap.const β UnitTime x)).sub | |
| (hp.const_smul Ο) | |
| omit [FiniteDimensional β E] in | |
| theorem isInvertible_one_sub_of_norm_lt_one | |
| {A : C(UnitTime, E) βL[β] C(UnitTime, E)} (hA : βAβ < 1) : | |
| (1 - A).IsInvertible := by | |
| obtain β¨u, huβ© := isUnit_one_sub_of_norm_lt_one (x := A) hA | |
| refine β¨ContinuousLinearEquiv.unitsEquiv β _ u, ?_β© | |
| exact hu | |
| omit [FiniteDimensional β E] in | |
| theorem picardPathDerivative_invertible (Z : C(E, E)) | |
| (hZ : ContDiff β β (Z : E β E)) {L Ο : β} | |
| (hL : 0 β€ L) (hbound : β x, βfderiv β Z xβ β€ L) | |
| (hΟ : |Ο| * L < 1) (Ξ³ : C(UnitTime, E)) : | |
| (picardPathDerivative Z hZ Ο Ξ³).IsInvertible := by | |
| apply isInvertible_one_sub_of_norm_lt_one | |
| let A : C(UnitTime, E βL[β] E) := | |
| β¨fun s => fderiv β Z (Ξ³ s), | |
| (hZ.continuous_fderiv (by simp)).comp Ξ³.continuousβ© | |
| have hA : βAβ β€ L := (ContinuousMap.norm_le _ hL).mpr fun s => hbound (Ξ³ s) | |
| calc | |
| βΟ β’ primitivePathL.comp (applyPath A)β | |
| β€ |Ο| * βprimitivePathL.comp (applyPath A)β := by | |
| simpa only [Real.norm_eq_abs] using | |
| ContinuousLinearMap.opNorm_smul_le Ο (primitivePathL.comp (applyPath A)) | |
| _ β€ |Ο| * (βprimitivePathL (E := E)β * βapplyPath Aβ) := | |
| mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (abs_nonneg Ο) | |
| _ β€ |Ο| * (1 * L) := by | |
| gcongr | |
| Β· exact primitivePathL_norm | |
| Β· exact (applyPath_norm A).trans hA | |
| _ < 1 := by simpa only [one_mul] using hΟ | |
| theorem picardResidual_partial (Z : C(E, E)) | |
| (hZ : ContDiff β β (Z : E β E)) (Ο : β) (x : E) (Ξ³ : C(UnitTime, E)) : | |
| fderiv β (picardResidual Z) ((Ο, x), Ξ³) βL | |
| ContinuousLinearMap.inr β (β Γ E) C(UnitTime, E) = | |
| picardPathDerivative Z hZ Ο Ξ³ := by | |
| have hp : HasFDerivAt (fun Ξ· : C(UnitTime, E) => ((Ο, x), Ξ·)) | |
| (ContinuousLinearMap.inr β (β Γ E) C(UnitTime, E)) Ξ³ := by | |
| simpa only [ContinuousLinearMap.inr_apply, Prod.mk_add_mk, add_zero, zero_add] using | |
| ((ContinuousLinearMap.inr β (β Γ E) C(UnitTime, E)).hasFDerivAt (x := Ξ³)).const_add | |
| ((Ο, x), 0) | |
| have hd := ((picardResidual_smooth Z hZ).differentiable (by simp) ((Ο, x), Ξ³)).hasFDerivAt.comp Ξ³ hp | |
| exact hd.unique (picardResidual_hasFDerivAt_path Z hZ Ο x Ξ³) | |
| /-- A short Picard solution belongs to a smooth local family of Picard solutions. | |
| The family is obtained from the library implicit-function theorem. -/ | |
| theorem exists_local_picard_family (Z : C(E, E)) | |
| (hZ : ContDiff β β (Z : E β E)) {L Ο : β} | |
| (hL : 0 β€ L) (hbound : β x, βfderiv β Z xβ β€ L) | |
| (hΟ : |Ο| * L < 1) (x : E) (Ξ³ : C(UnitTime, E)) | |
| (hΞ³ : picardResidual Z ((Ο, x), Ξ³) = 0) : | |
| β Ξ : (β Γ E) β C(UnitTime, E), | |
| ContDiffAt β β Ξ (Ο, x) β§ Ξ (Ο, x) = Ξ³ β§ | |
| βαΆ p in π (Ο, x), picardResidual Z (p, Ξ p) = 0 := by | |
| have hc := (picardResidual_smooth Z hZ).contDiffAt (x := ((Ο, x), Ξ³)) | |
| have hi : (fderiv β (picardResidual Z) ((Ο, x), Ξ³) βL | |
| ContinuousLinearMap.inr β (β Γ E) C(UnitTime, E)).IsInvertible := by | |
| rw [picardResidual_partial Z hZ] | |
| exact picardPathDerivative_invertible Z hZ hL hbound hΟ Ξ³ | |
| refine β¨hc.implicitFunction (by simp) hi, | |
| hc.contDiffAt_implicitFunction (by simp) hi, | |
| hc.implicitFunction_apply_self (by simp) hi, ?_β© | |
| filter_upwards [hc.eventually_apply_implicitFunction (by simp) hi] with p hp | |
| exact hp.trans hΞ³ | |
| end ForcedComputation.Flow | |
| end | |
| end OAI | |