openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Flow /FlowPicardSmooth.lean
| 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 | |