| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace PiExponent.CommutingTaylor |
|
|
| open Finset Nat |
| variable {R : Type*} [CommRing R] [Algebra ℚ R] |
|
|
| def iter (D : Derivation ℚ R R) (n : ℕ) : R →ₗ[ℚ] R := D.toLinearMap ^ n |
|
|
| @[simp] theorem iter_zero (D : Derivation ℚ R R) (a : R) : iter D 0 a = a := rfl |
| @[simp] theorem iter_succ (D : Derivation ℚ R R) (n : ℕ) (a : R) : |
| iter D (n+1) a = D (iter D n a) := by |
| change (D.toLinearMap ^ (n + 1)) a = D ((D.toLinearMap ^ n) a) |
| calc |
| (D.toLinearMap ^ (n + 1)) a = (D.toLinearMap * D.toLinearMap ^ n) a := |
| congrArg (fun f : Module.End ℚ R => f a) (_root_.pow_succ' D.toLinearMap n) |
| _ = D.toLinearMap ((D.toLinearMap ^ n) a) := |
| Module.End.mul_apply D.toLinearMap (D.toLinearMap ^ n) a |
| _ = D ((D.toLinearMap ^ n) a) := |
| congrFun (Derivation.coeFn_coe D) ((D.toLinearMap ^ n) a) |
|
|
| theorem iter_mul (D : Derivation ℚ R R) (n : ℕ) (a b : R) : |
| iter D n (a*b) = ∑ ij ∈ antidiagonal n, |
| n.choose ij.1 • (iter D ij.1 a * iter D ij.2 b) := by |
| induction n with |
| | zero => simp |
| | succ n ih => |
| rw [sum_antidiagonal_choose_succ_nsmul |
| (fun i j => iter D i a * iter D j b) n] |
| simp only [iter_succ, ih, map_sum, map_nsmul, Derivation.leibniz, |
| smul_eq_mul, nsmul_add, Finset.sum_add_distrib] |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro ij hij |
| rw [n.choose_symm_of_eq_add (mem_antidiagonal.mp hij).symm] |
| rw [mul_comm] |
|
|
| private theorem factorial_normalize (i j : ℕ) : |
| (1 / ((i+j).factorial : ℚ)) * ((i+j).choose i : ℚ) = |
| (1 / (i.factorial : ℚ)) * (1 / (j.factorial : ℚ)) := by |
| have h : (((i+j).choose i : ℚ) * (i.factorial : ℚ) * (j.factorial : ℚ)) = |
| ((i+j).factorial : ℚ) := by |
| exact_mod_cast (by |
| simpa using Nat.choose_mul_factorial_mul_factorial (Nat.le_add_right i j) : |
| (i+j).choose i * i.factorial * j.factorial = (i+j).factorial) |
| have hi : (i.factorial : ℚ) ≠ 0 := by exact_mod_cast Nat.factorial_ne_zero i |
| have hj : (j.factorial : ℚ) ≠ 0 := by exact_mod_cast Nat.factorial_ne_zero j |
| have hn : ((i+j).factorial : ℚ) ≠ 0 := by exact_mod_cast Nat.factorial_ne_zero (i+j) |
| field_simp |
| nlinarith [h] |
|
|
| def taylorSeries (D : Derivation ℚ R R) (a : R) : PowerSeries R := |
| PowerSeries.mk fun n => (1 / (n.factorial : ℚ)) • iter D n a |
|
|
| @[simp] theorem coeff_taylorSeries (D : Derivation ℚ R R) (a : R) (n : ℕ) : |
| PowerSeries.coeff n (taylorSeries D a) = (1 / (n.factorial : ℚ)) • iter D n a := by |
| exact PowerSeries.coeff_mk n _ |
|
|
| theorem taylorSeries_mul (D : Derivation ℚ R R) (a b : R) : |
| taylorSeries D (a*b) = taylorSeries D a * taylorSeries D b := by |
| ext n |
| rw [PowerSeries.coeff_mul, coeff_taylorSeries, iter_mul, Finset.smul_sum] |
| apply Finset.sum_congr rfl |
| intro ij hij |
| have hn : ij.1 + ij.2 = n := mem_antidiagonal.mp hij |
| rw [coeff_taylorSeries, coeff_taylorSeries] |
| rw [← Nat.cast_smul_eq_nsmul ℚ, smul_smul, smul_mul_smul_comm] |
| rw [← hn, factorial_normalize] |
|
|
| def taylorHom (D : Derivation ℚ R R) : R →+* PowerSeries R where |
| toFun := taylorSeries D |
| map_zero' := by ext n; simp [taylorSeries] |
| map_one' := by |
| ext n |
| cases n with |
| | zero => simp [taylorSeries] |
| | succ n => |
| have h : iter D (n+1) (1:R) = 0 := by |
| induction n with |
| | zero => simp |
| | succ n ih => simp [ih] |
| simp [taylorSeries, h] |
| map_add' a b := by ext n; simp [taylorSeries, smul_add] |
| map_mul' := taylorSeries_mul D |
|
|
| @[simp] theorem coeff_taylorHom (D : Derivation ℚ R R) (a : R) (n : ℕ) : |
| PowerSeries.coeff n (taylorHom D a) = (1 / (n.factorial : ℚ)) • iter D n a := by |
| exact coeff_taylorSeries D a n |
|
|
| @[simp] theorem constantCoeff_taylorHom (D : Derivation ℚ R R) (a : R) : |
| PowerSeries.constantCoeff (taylorHom D a) = a := by |
| rw [← PowerSeries.coeff_zero_eq_constantCoeff_apply, coeff_taylorHom] |
| simp |
|
|
| def mixedIter : (m : ℕ) → (Fin m → Derivation ℚ R R) → (Fin m →₀ ℕ) → R →ₗ[ℚ] R |
| | 0, _, _ => LinearMap.id |
| | m+1, D, α => (mixedIter m (fun i => D i.succ) α.tail).comp (iter (D 0) (α 0)) |
|
|
| def taylorHomFin : (m : ℕ) → (Fin m → Derivation ℚ R R) → R →+* MvPowerSeries (Fin m) R |
| | 0, _ => MvPowerSeries.C |
| | m+1, D => (MvPowerSeries.finSuccEquiv R m).symm.toRingHom.comp |
| ((PowerSeries.map (taylorHomFin m (fun i => D i.succ))).comp (taylorHom (D 0))) |
|
|
| theorem coeff_taylorHomFin (m : ℕ) (D : Fin m → Derivation ℚ R R) |
| (α : Fin m →₀ ℕ) (a : R) : |
| MvPowerSeries.coeff α (taylorHomFin m D a) = |
| (∏ i, (1 / ((α i).factorial : ℚ))) • mixedIter m D α a := by |
| induction m generalizing a with |
| | zero => |
| have hα : α = 0 := Subsingleton.elim _ _ |
| simp [taylorHomFin, mixedIter, hα] |
| | succ m ih => |
| have hcoeff := MvPowerSeries.coeff_coeff_finSuccEquiv |
| ((MvPowerSeries.finSuccEquiv R m).symm |
| (PowerSeries.map (taylorHomFin m (fun i => D i.succ)) (taylorHom (D 0) a))) |
| (k := α 0) (x := α.tail) |
| simp only [AlgEquiv.apply_symm_apply] at hcoeff |
| rw [show α.tail.cons (α 0) = α by ext i; refine Fin.cases ?_ (fun j => ?_) i <;> simp] at hcoeff |
| rw [taylorHomFin, RingHom.comp_apply, RingHom.comp_apply] |
| change MvPowerSeries.coeff α ((MvPowerSeries.finSuccEquiv R m).symm |
| (PowerSeries.map (taylorHomFin m (fun i => D i.succ)) (taylorHom (D 0) a))) = _ |
| rw [← hcoeff, PowerSeries.coeff_map, coeff_taylorHom, ih] |
| simp only [map_smul, mixedIter, LinearMap.comp_apply, Fin.prod_univ_succ, |
| Finsupp.tail_apply, smul_smul] |
| rw [mul_comm] |
| |
| @[simp] theorem mixedIter_zero (m : ℕ) (D : Fin m → Derivation ℚ R R) (a : R) : |
| mixedIter m D 0 a = a := by |
| induction m generalizing a with |
| | zero => rfl |
| | succ m ih => |
| have ht : (0 : Fin (m+1) →₀ ℕ).tail = 0 := by ext i; rfl |
| simp [mixedIter, ht, ih] |
| |
| @[simp] theorem mixedIter_single (m : ℕ) (D : Fin m → Derivation ℚ R R) |
| (i : Fin m) (a : R) : mixedIter m D (Finsupp.single i 1) a = D i a := by |
| induction m generalizing a with |
| | zero => exact Fin.elim0 i |
| | succ m ih => |
| refine Fin.cases ?_ (fun j => ?_) i |
| · rw [← Finsupp.cons_zero_eq_single_zero] |
| simp [mixedIter, iter] |
| · rw [← Finsupp.cons_zero_single_eq_single_succ] |
| simp [mixedIter, ih] |
|
|
| @[simp] theorem coeff_zero_taylorHomFin (m : ℕ) (D : Fin m → Derivation ℚ R R) (a : R) : |
| MvPowerSeries.coeff 0 (taylorHomFin m D a) = a := by |
| simp [coeff_taylorHomFin] |
|
|
| @[simp] theorem coeff_single_taylorHomFin (m : ℕ) (D : Fin m → Derivation ℚ R R) |
| (i : Fin m) (a : R) : |
| MvPowerSeries.coeff (Finsupp.single i 1) (taylorHomFin m D a) = D i a := by |
| rw [coeff_taylorHomFin, mixedIter_single] |
| have h : (∏ j : Fin m, (1 / ((Finsupp.single i 1 j).factorial : ℚ))) = 1 := by |
| apply Finset.prod_eq_one |
| intro j hj |
| by_cases he : i = j <;> simp [he] |
| rw [h, one_smul] |
| |
| def residueTaylorFin {K : Type*} [CommRing K] |
| (m : ℕ) (D : Fin m → Derivation ℚ R R) (ρ : R →+* K) : |
| R →+* MvPowerSeries (Fin m) K := |
| (MvPowerSeries.map ρ).comp (taylorHomFin m D) |
|
|
| theorem coeff_residueTaylorFin {K : Type*} [CommRing K] [Algebra ℚ K] |
| (m : ℕ) (D : Fin m → Derivation ℚ R R) (ρ : R →+* K) |
| (α : Fin m →₀ ℕ) (a : R) : |
| MvPowerSeries.coeff α (residueTaylorFin m D ρ a) = |
| (∏ i, (1 / ((α i).factorial : ℚ))) • ρ (mixedIter m D α a) := by |
| simp [residueTaylorFin, coeff_taylorHomFin, map_rat_smul] |
|
|
| @[simp] theorem coeff_zero_residueTaylorFin {K : Type*} [CommRing K] |
| (m : ℕ) (D : Fin m → Derivation ℚ R R) (ρ : R →+* K) (a : R) : |
| MvPowerSeries.coeff 0 (residueTaylorFin m D ρ a) = ρ a := by |
| simp [residueTaylorFin] |
|
|
| @[simp] theorem coeff_single_residueTaylorFin {K : Type*} [CommRing K] |
| (m : ℕ) (D : Fin m → Derivation ℚ R R) (ρ : R →+* K) (i : Fin m) (a : R) : |
| MvPowerSeries.coeff (Finsupp.single i 1) (residueTaylorFin m D ρ a) = ρ (D i a) := by |
| simp [residueTaylorFin] |
|
|
| @[simp] theorem constantCoeff_residueTaylorFin {K : Type*} [CommRing K] |
| (m : ℕ) (D : Fin m → Derivation ℚ R R) (ρ : R →+* K) (a : R) : |
| MvPowerSeries.constantCoeff (residueTaylorFin m D ρ a) = ρ a := by |
| rw [← MvPowerSeries.coeff_zero_eq_constantCoeff_apply] |
| exact coeff_zero_residueTaylorFin m D ρ a |
|
|
| theorem constantCoeff_comp_residueTaylorFin {K : Type*} [CommRing K] |
| (m : ℕ) (D : Fin m → Derivation ℚ R R) (ρ : R →+* K) : |
| MvPowerSeries.constantCoeff.comp (residueTaylorFin m D ρ) = ρ := by |
| ext a |
| exact constantCoeff_residueTaylorFin m D ρ a |
|
|
| theorem iter_commute (D E : Derivation ℚ R R) |
| (h : Commute D.toLinearMap E.toLinearMap) (i j : ℕ) (a : R) : |
| iter D i (iter E j a) = iter E j (iter D i a) := by |
| exact LinearMap.congr_fun ((h.pow_left i).pow_right j).eq a |
|
|
| theorem mixedIter_commute (m : ℕ) (D : Fin m → Derivation ℚ R R) |
| (E : Derivation ℚ R R) (α : Fin m →₀ ℕ) |
| (h : ∀ i, Commute (D i).toLinearMap E.toLinearMap) (a : R) : |
| mixedIter m D α (E a) = E (mixedIter m D α a) := by |
| induction m generalizing a with |
| | zero => rfl |
| | succ m ih => |
| simp only [mixedIter, LinearMap.comp_apply] |
| rw [show iter (D 0) (α 0) (E a) = E (iter (D 0) (α 0) a) from |
| iter_commute (D 0) E (h 0) (α 0) 1 a] |
| exact ih (fun i => D i.succ) α.tail (fun i => h i.succ) _ |
|
|
| end PiExponent.CommutingTaylor |
|
|
| end |
|
|
| end OAI |
|
|
