introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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