openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Flow /FlowPicardSolution.lean
| import OAI.MathematicalPhysics.NavierStokes.ForcedComputation.Flow.FlowPicardSmooth | |
| namespace OAI | |
| /-! Identification of the local implicit Picard family with an actual flow. | |
| The short-time uniqueness proof is a norm estimate in the compact path space. -/ | |
| noncomputable section | |
| namespace ForcedComputation.Flow | |
| open Set Filter | |
| open scoped Topology ContDiff NNReal | |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] | |
| [FiniteDimensional ℝ E] [CompleteSpace E] | |
| omit [FiniteDimensional ℝ E] [CompleteSpace E] [NormedSpace ℝ E] in | |
| theorem postcompose_norm_sub_le (Z : C(E, E)) {L : ℝ≥0} | |
| (hZ : LipschitzWith L Z) (γ η : C(UnitTime, E)) : | |
| ‖postcompose Z γ - postcompose Z η‖ ≤ (L : ℝ) * ‖γ - η‖ := by | |
| apply (ContinuousMap.norm_le _ (mul_nonneg L.coe_nonneg (norm_nonneg _))).mpr | |
| intro s | |
| exact (hZ.norm_sub_le (γ s) (η s)).trans | |
| (mul_le_mul_of_nonneg_left ((γ - η).norm_coe_le_norm s) L.coe_nonneg) | |
| omit [FiniteDimensional ℝ E] in | |
| theorem picard_solution_unique (Z : C(E, E)) {L : ℝ≥0} | |
| (hZ : LipschitzWith L Z) {τ : ℝ} (hτ : |τ| * (L : ℝ) < 1) | |
| (x : E) {γ η : C(UnitTime, E)} | |
| (hγ : picardResidual Z ((τ, x), γ) = 0) | |
| (hη : picardResidual Z ((τ, x), η) = 0) : γ = η := by | |
| have hγ' : γ - ContinuousLinearMap.const ℝ UnitTime x = | |
| τ • primitivePathL (postcompose Z γ) := sub_eq_zero.mp hγ | |
| have hη' : η - ContinuousLinearMap.const ℝ UnitTime x = | |
| τ • primitivePathL (postcompose Z η) := sub_eq_zero.mp hη | |
| have he : γ - η = τ • primitivePathL (postcompose Z γ - postcompose Z η) := by | |
| rw [map_sub, smul_sub, ← hγ', ← hη'] | |
| abel | |
| have hb : ‖γ - η‖ ≤ (|τ| * (L : ℝ)) * ‖γ - η‖ := by | |
| calc | |
| ‖γ - η‖ = |τ| * ‖primitivePathL (postcompose Z γ - postcompose Z η)‖ := by | |
| rw [he, norm_smul, Real.norm_eq_abs] | |
| _ ≤ |τ| * ‖postcompose Z γ - postcompose Z η‖ := | |
| mul_le_mul_of_nonneg_left (primitivePath_norm _) (abs_nonneg τ) | |
| _ ≤ |τ| * ((L : ℝ) * ‖γ - η‖) := | |
| mul_le_mul_of_nonneg_left (postcompose_norm_sub_le Z hZ γ η) (abs_nonneg τ) | |
| _ = _ := by ring | |
| apply sub_eq_zero.mp | |
| apply norm_eq_zero.mp | |
| have hn := norm_nonneg (γ - η) | |
| nlinarith | |
| omit [FiniteDimensional ℝ E] [CompleteSpace E] in | |
| def orbitPath {Z : E → E} {Ψ : ℝ → E → E} | |
| (hΨ : ∀ t x, HasDerivAt (fun s => Ψ s x) (Z (Ψ t x)) t) | |
| (τ : ℝ) (x : E) : C(UnitTime, E) := | |
| ⟨fun s => Ψ (τ * s.1) x, | |
| (continuous_iff_continuousAt.mpr fun t => (hΨ t x).continuousAt).comp | |
| (continuous_const.mul continuous_subtype_val)⟩ | |
| omit [FiniteDimensional ℝ E] [CompleteSpace E] in | |
| @[simp] theorem orbitPath_apply {Z : E → E} {Ψ : ℝ → E → E} | |
| (hΨ : ∀ t x, HasDerivAt (fun s => Ψ s x) (Z (Ψ t x)) t) | |
| (τ : ℝ) (x : E) (s : UnitTime) : orbitPath hΨ τ x s = Ψ (τ * s.1) x := rfl | |
| omit [FiniteDimensional ℝ E] in | |
| theorem orbitPath_picard (Z : C(E, E)) {Ψ : ℝ → E → E} | |
| (hΨ : ∀ t x, HasDerivAt (fun s => Ψ s x) (Z (Ψ t x)) t) | |
| (hzero : ∀ x, Ψ 0 x = x) (τ : ℝ) (x : E) : | |
| picardResidual Z ((τ, x), orbitPath hΨ τ x) = 0 := by | |
| let γ := orbitPath hΨ τ x | |
| have hc : Continuous (fun s : ℝ => Ψ (τ * s) x) := | |
| (continuous_iff_continuousAt.mpr fun t => (hΨ t x).continuousAt).comp | |
| (continuous_const.mul continuous_id) | |
| have hd (s : ℝ) : HasDerivAt (fun r => Ψ (τ * r) x) | |
| (τ • Z (Ψ (τ * s) x)) s := by | |
| simpa only [Function.comp_def, mul_one] using | |
| (hΨ (τ * s) x).scomp s ((hasDerivAt_id s).const_mul τ) | |
| ext t | |
| change Ψ (τ * t.1) x - x - τ • | |
| (∫ s in (0 : ℝ)..t.1, extendPath (postcompose Z γ) s) = 0 | |
| have he : (∫ s in (0 : ℝ)..t.1, extendPath (postcompose Z γ) s) = | |
| ∫ s in (0 : ℝ)..t.1, Z (Ψ (τ * s) x) := by | |
| apply intervalIntegral.integral_congr | |
| intro s hs | |
| have hs' : s ∈ Icc (0 : ℝ) 1 := by | |
| rw [uIcc_of_le t.2.1] at hs | |
| exact ⟨hs.1, hs.2.trans t.2.2⟩ | |
| simp only [extendPath_apply, postcompose, ContinuousMap.comp_apply, | |
| projIcc_of_mem zero_le_one hs', γ, orbitPath_apply] | |
| rw [he] | |
| have hi := intervalIntegral.integral_eq_sub_of_hasDerivAt | |
| (fun s _ => hd s) (((Z.continuous.comp hc).const_smul τ).intervalIntegrable 0 t.1) | |
| rw [intervalIntegral.integral_smul, mul_zero, hzero] at hi | |
| exact sub_eq_zero.mpr hi.symm | |
| /-- Joint smoothness in short elapsed time and the initial point. -/ | |
| theorem flow_contDiffAt_short (Z : C(E, E)) | |
| (hZ : ContDiff ℝ ∞ (Z : E → E)) {L : ℝ≥0} (hL : LipschitzWith L Z) | |
| {Ψ : ℝ → E → E} | |
| (hΨ : ∀ t x, HasDerivAt (fun s => Ψ s x) (Z (Ψ t x)) t) | |
| (hzero : ∀ x, Ψ 0 x = x) (τ : ℝ) (x : E) | |
| (hτ : |τ| * (L : ℝ) < 1) : | |
| ContDiffAt ℝ ∞ (fun p : ℝ × E => Ψ p.1 p.2) (τ, x) := by | |
| let γ := orbitPath hΨ τ x | |
| obtain ⟨Γ, hΓ, _, hΓeq⟩ := exists_local_picard_family Z hZ L.coe_nonneg | |
| (fun _ => norm_fderiv_le_of_lipschitz ℝ hL) hτ x γ | |
| (orbitPath_picard Z hΨ hzero τ x) | |
| let e : UnitTime := ⟨1, by norm_num⟩ | |
| have hs : ContDiffAt ℝ ∞ (fun p => Γ p e) (τ, x) := | |
| (ContinuousMap.evalCLM ℝ e : C(UnitTime, E) →L[ℝ] E).contDiff.contDiffAt.comp (τ, x) hΓ | |
| have hn : ∀ᶠ p : ℝ × E in 𝓝 (τ, x), |p.1| * (L : ℝ) < 1 := | |
| (isOpen_lt (continuous_fst.abs.mul continuous_const) continuous_const).mem_nhds hτ | |
| have he : (fun p => Γ p e) =ᶠ[𝓝 (τ, x)] fun p => Ψ p.1 p.2 := by | |
| filter_upwards [hΓeq, hn] with p hp hsmall | |
| have hu := picard_solution_unique Z hL hsmall p.2 hp | |
| (orbitPath_picard Z hΨ hzero p.1 p.2) | |
| have hv := congrArg (fun η : C(UnitTime, E) => η e) hu | |
| simpa only [orbitPath_apply, e, mul_one] using hv | |
| exact hs.congr_of_eventuallyEq he.symm | |
| end ForcedComputation.Flow | |
| end | |
| end OAI | |