| import Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas |
| import Mathlib.Analysis.Calculus.IteratedDeriv.FaaDiBruno |
| import Mathlib.Analysis.Calculus.Deriv.Pow |
| import Mathlib.Tactic.FunProp |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Function Set |
| open scoped ContDiff Topology BigOperators |
|
|
| namespace SmoothLocal.Taylor |
|
|
| def normalizedTimePower (a : ℝ) (m : ℕ) (t : ℝ) : ℝ := |
| (t - a)^m / (m.factorial : ℝ) |
|
|
| theorem normalizedTimePower_contDiff (a : ℝ) (m : ℕ) : |
| ContDiff ℝ ∞ (normalizedTimePower a m) := by |
| unfold normalizedTimePower |
| fun_prop |
|
|
| theorem normalizedTimePower_hasDerivAt (a t : ℝ) (m : ℕ) : |
| HasDerivAt (normalizedTimePower a (m + 1)) (normalizedTimePower a m t) t := by |
| have h := (((hasDerivAt_id t).sub_const a).pow (m + 1)).div_const ((m + 1).factorial : ℝ) |
| change HasDerivAt (normalizedTimePower a (m + 1)) |
| ((m + 1 : ℕ) * (t - a)^(m + 1 - 1) * 1 / ((m + 1).factorial : ℝ)) t at h |
| simp only [Nat.add_sub_cancel, mul_one] at h |
| have he : (m + 1 : ℕ) * (t - a)^m / ((m + 1).factorial : ℝ) = normalizedTimePower a m t := by |
| simp only [Nat.factorial_succ, Nat.cast_mul, Nat.cast_add, Nat.cast_one, normalizedTimePower] |
| have hm : (m.factorial : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (Nat.factorial_ne_zero m) |
| have hm1 : (m : ℝ) + 1 ≠ 0 := by positivity |
| field_simp [hm, hm1] |
| rw [he] at h |
| exact h |
|
|
| theorem normalizedTimePower_deriv (a : ℝ) (m : ℕ) : |
| deriv (normalizedTimePower a (m + 1)) = normalizedTimePower a m := by |
| funext t |
| exact (normalizedTimePower_hasDerivAt a t m).deriv |
|
|
| theorem normalizedTimePower_iteratedDeriv_at_center (a : ℝ) (m k : ℕ) : |
| iteratedDeriv k (normalizedTimePower a m) a = if k = m then 1 else 0 := by |
| change iteratedDeriv k (fun t : ℝ => (t - a)^m / (m.factorial : ℝ)) a = _ |
| rw [iteratedDeriv_div_const] |
| rw [iteratedDeriv_comp_sub_const (f := fun t : ℝ => t^m)] |
| change iteratedDeriv k (fun t : ℝ => t^m) (a - a) / (m.factorial : ℝ) = _ |
| rw [sub_self, iteratedDeriv_fun_pow_zero] |
| split_ifs with h |
| · exact div_self (Nat.cast_ne_zero.mpr (Nat.factorial_ne_zero m) : (m.factorial : ℝ) ≠ 0) |
| · simpa only [Nat.cast_zero] using (zero_div (m.factorial : ℝ)) |
|
|
| theorem coefficient_timePower_jet (a C : ℝ) (m k : ℕ) : |
| iteratedDeriv k (fun t => C * normalizedTimePower a m t) a = |
| if k = m then C else 0 := by |
| rw [iteratedDeriv_const_mul_field, normalizedTimePower_iteratedDeriv_at_center] |
| split_ifs <;> simp |
|
|
| section Composition |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
|
|
| theorem iteratedDeriv_comp_eq_of_jets {Q : E → F} {f g : ℝ → E} {a : ℝ} {n : ℕ} |
| (hf : ContDiffAt ℝ ∞ f a) (hg : ContDiffAt ℝ ∞ g a) |
| (hQ : ContDiffAt ℝ ∞ Q (f a)) |
| (hjets : ∀ j ≤ n, iteratedDeriv j f a = iteratedDeriv j g a) : |
| iteratedDeriv n (Q ∘ f) a = iteratedDeriv n (Q ∘ g) a := by |
| have hvalue : f a = g a := by simpa only [iteratedDeriv_zero] using hjets 0 (Nat.zero_le n) |
| have hQg : ContDiffAt ℝ ∞ Q (g a) := by rw [← hvalue]; exact hQ |
| rw [iteratedDeriv_vcomp_eq_sum_orderedFinpartition hQ hf (WithTop.coe_le_coe.mpr le_top), |
| iteratedDeriv_vcomp_eq_sum_orderedFinpartition hQg hg (WithTop.coe_le_coe.mpr le_top)] |
| apply Finset.sum_congr rfl |
| intro c hc |
| rw [hvalue] |
| congr 1 |
| funext j |
| exact hjets (c.partSize j) (c.partSize_le j) |
|
|
| theorem iteratedDeriv_add_eq_of_zero_jets {f h : ℝ → E} {a : ℝ} {n : ℕ} |
| (hf : ContDiffAt ℝ ∞ f a) (hh : ContDiffAt ℝ ∞ h a) |
| (hzero : ∀ j ≤ n, iteratedDeriv j h a = 0) : |
| ∀ j ≤ n, iteratedDeriv j (fun t => f t + h t) a = iteratedDeriv j f a := by |
| intro j hj |
| rw [iteratedDeriv_fun_add (hf.of_le (WithTop.coe_le_coe.mpr le_top)) |
| (hh.of_le (WithTop.coe_le_coe.mpr le_top)), hzero j hj, add_zero] |
|
|
| end Composition |
| end SmoothLocal.Taylor |
|
|
| end |
|
|
| end OAI |
|
|
