openAI-math-dataset / lean /OAI /MathematicalPhysics /NavierStokes /ForcedComputation /Flow /FlowMixedPartials.lean
| import Mathlib.Analysis.Calculus.ContDiff.Comp | |
| import Mathlib.Analysis.Calculus.FDeriv.Symmetric | |
| import Mathlib.Analysis.Calculus.Deriv.Mul | |
| import Mathlib.Analysis.Calculus.Deriv.Prod | |
| namespace OAI | |
| /-! Commutation of a time derivative and an initial-point derivative. | |
| These lemmas turn joint smoothness of an actual flow into its variational | |
| equations, without an additional smooth-dependence input. -/ | |
| noncomputable section | |
| namespace ForcedComputation.Flow | |
| open scoped ContDiff | |
| variable {E F : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] | |
| [NormedAddCommGroup F] [NormedSpace ℝ F] | |
| theorem spaceDerivative_eq {G : ℝ × E → F} (hG : ContDiff ℝ ∞ G) | |
| (t : ℝ) (x v : E) : | |
| fderiv ℝ (fun y => G (t, y)) x v = fderiv ℝ G (t, x) (0, v) := by | |
| have hd := ((hG.differentiable (by simp) (t, x)).hasFDerivAt.comp x | |
| (hasFDerivAt_prodMk_right t x)).fderiv | |
| exact congrArg (fun A : E →L[ℝ] F => A v) hd | |
| theorem timeDerivative_eq {G : ℝ × E → F} (hG : ContDiff ℝ ∞ G) | |
| (t : ℝ) (x : E) : | |
| deriv (fun s => G (s, x)) t = fderiv ℝ G (t, x) (1, 0) := by | |
| exact ((hG.differentiable (by simp) (t, x)).hasFDerivAt.comp_hasDerivAt t | |
| ((hasDerivAt_id t).prodMk (hasDerivAt_const t x))).deriv | |
| theorem spaceDerivative_smooth {G : ℝ × E → F} (hG : ContDiff ℝ ∞ G) (v : E) : | |
| ContDiff ℝ ∞ (fun p : ℝ × E => fderiv ℝ (fun y => G (p.1, y)) p.2 v) := by | |
| have he : (fun p : ℝ × E => fderiv ℝ (fun y => G (p.1, y)) p.2 v) = | |
| fun p => fderiv ℝ G p (0, v) := by | |
| funext p | |
| exact spaceDerivative_eq hG p.1 p.2 v | |
| rw [he] | |
| exact (hG.fderiv_right (by simp)).clm_apply contDiff_const | |
| theorem time_space_commute {G : ℝ × E → F} (hG : ContDiff ℝ ∞ G) | |
| (t : ℝ) (x v : E) : | |
| HasDerivAt (fun s => fderiv ℝ (fun y => G (s, y)) x v) | |
| (fderiv ℝ (fun y => deriv (fun s => G (s, y)) t) x v) t := by | |
| have hD : ContDiff ℝ ∞ (fderiv ℝ G) := hG.fderiv_right (by simp) | |
| have ht := (hD.differentiable (by simp) (t, x)).hasFDerivAt.comp_hasDerivAt t | |
| ((hasDerivAt_id t).prodMk (hasDerivAt_const t x)) | |
| have htv := ht.clm_apply (hasDerivAt_const t (0, v)) | |
| simp only [map_zero, add_zero, Function.comp_def, id_eq] at htv | |
| have he : (fun s => fderiv ℝ (fun y => G (s, y)) x v) = | |
| fun s => fderiv ℝ G (s, x) (0, v) := by | |
| funext s | |
| exact spaceDerivative_eq hG s x v | |
| rw [he] | |
| have htime : (fun y => deriv (fun s => G (s, y)) t) = | |
| fun y => fderiv ℝ G (t, y) (1, 0) := by | |
| funext y | |
| exact timeDerivative_eq hG t y | |
| rw [htime] | |
| have hx := (hD.differentiable (by simp) (t, x)).hasFDerivAt.comp x | |
| (hasFDerivAt_prodMk_right t x) | |
| have hxv := congrArg (fun A : E →L[ℝ] F => A v) | |
| (hx.clm_apply (hasFDerivAt_const (1, 0) x)).fderiv | |
| simp only [add_apply, ContinuousLinearMap.comp_apply, | |
| zero_apply, map_zero, zero_add, ContinuousLinearMap.flip_apply, | |
| ContinuousLinearMap.inr_apply, Function.comp_def] at hxv | |
| rw [hxv] | |
| have hs := (hG.contDiffAt (x := (t, x))).isSymmSndFDerivAt (by simp) (1, 0) (0, v) | |
| rw [← hs] | |
| exact htv | |
| end ForcedComputation.Flow | |
| end | |
| end OAI | |