File size: 7,047 Bytes
b797a5b | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 | import Mathlib.Algebra.MvPolynomial.PDeriv
import Mathlib.Basic.Complex.Basic
import Mathlib.Tactic.Ring
import OAI.NumberTheory.PiExponent.Polynomials.PolynomialFrameDegree
namespace OAI
namespace PiExponentApprox
noncomputable section
abbrev FramePolynomial (m : ℕ) := MvPolynomial (Fin (m + 1)) ℂ
def logarithmicDerivation (m : ℕ) :
Derivation ℂ (FramePolynomial m) (FramePolynomial m) :=
(MvPolynomial.X (0 : Fin (m + 1)) : FramePolynomial m) •
MvPolynomial.pderiv (R := ℂ) (0 : Fin (m + 1)) +
∑ i : Fin m, MvPolynomial.pderiv (R := ℂ) i.succ
def polynomialFrame (m : ℕ) (i : Fin (m + 1)) :
Derivation ℂ (FramePolynomial m) (FramePolynomial m) :=
if i = 0 then logarithmicDerivation m else MvPolynomial.pderiv i
theorem derivation_finset_sum_apply {α : Type*} (m : ℕ) (s : Finset α)
(D : α → Derivation ℂ (FramePolynomial m) (FramePolynomial m))
(p : FramePolynomial m) : (∑ a ∈ s, D a) p = ∑ a ∈ s, D a p := by
classical
induction s using Finset.induction_on with
| empty => simp only [Finset.sum_empty, Derivation.zero_apply]
| @insert a s ha ih =>
rw [Finset.sum_insert ha, Finset.sum_insert ha, Derivation.add_apply, ih]
@[simp] theorem logarithmicDerivation_apply (m : ℕ) (p : FramePolynomial m) :
logarithmicDerivation m p =
MvPolynomial.X (0 : Fin (m + 1)) * MvPolynomial.pderiv 0 p +
∑ i : Fin m, MvPolynomial.pderiv i.succ p := by
simp only [logarithmicDerivation, Derivation.add_apply, Derivation.smul_apply,
derivation_finset_sum_apply, smul_eq_mul]
@[simp] theorem polynomialFrame_zero (m : ℕ) :
polynomialFrame m 0 = logarithmicDerivation m := by
simp only [polynomialFrame, ite_true]
@[simp] theorem polynomialFrame_pos (m : ℕ) (i : Fin (m + 1)) (hi : i ≠ 0) :
polynomialFrame m i = MvPolynomial.pderiv i := by
simp only [polynomialFrame, ite_eq_right hi]
theorem polynomial_pderiv_commute (m : ℕ) (i j : Fin (m + 1))
(p : FramePolynomial m) :
MvPolynomial.pderiv i (MvPolynomial.pderiv j p) =
MvPolynomial.pderiv j (MvPolynomial.pderiv i p) := by
by_cases hij : i = j
· subst j
rfl
· apply MvPolynomial.ext
intro d
simp only [MvPolynomial.coeff_pderiv, Finsupp.add_apply,
Finsupp.single_apply, ite_eq_right hij, ite_eq_right (Ne.symm hij),
add_zero]
rw [show d + Finsupp.single i 1 + Finsupp.single j 1 =
d + Finsupp.single j 1 + Finsupp.single i 1 by ac_rfl]
ring
theorem pderiv_logarithmicDerivation_commute (m : ℕ) (i : Fin (m + 1))
(hi : i ≠ 0) (p : FramePolynomial m) :
MvPolynomial.pderiv i (logarithmicDerivation m p) =
logarithmicDerivation m (MvPolynomial.pderiv i p) := by
have hEuler :
MvPolynomial.pderiv i
(MvPolynomial.X (0 : Fin (m + 1)) * MvPolynomial.pderiv 0 p) =
MvPolynomial.X (0 : Fin (m + 1)) *
MvPolynomial.pderiv 0 (MvPolynomial.pderiv i p) := by
rw [MvPolynomial.pderiv_mul, MvPolynomial.pderiv_X_of_ne (Ne.symm hi),
zero_mul, zero_add, polynomial_pderiv_commute m i 0 p]
have hSum : MvPolynomial.pderiv i (∑ j : Fin m, MvPolynomial.pderiv j.succ p) =
∑ j : Fin m, MvPolynomial.pderiv j.succ (MvPolynomial.pderiv i p) := by
rw [map_sum]
apply Finset.sum_congr rfl
intro j _
exact polynomial_pderiv_commute m i j.succ p
rw [logarithmicDerivation_apply, map_add, hEuler, hSum]
exact (logarithmicDerivation_apply m (MvPolynomial.pderiv i p)).symm
theorem polynomialFrame_commute (m : ℕ) (i j : Fin (m + 1))
(p : FramePolynomial m) :
polynomialFrame m i (polynomialFrame m j p) =
polynomialFrame m j (polynomialFrame m i p) := by
by_cases hi : i = 0
· subst i
by_cases hj : j = 0
· subst j
rfl
· rw [polynomialFrame_zero, polynomialFrame_pos m j hj]
exact (pderiv_logarithmicDerivation_commute m j hj p).symm
· by_cases hj : j = 0
· subst j
rw [polynomialFrame_zero, polynomialFrame_pos m i hi]
exact pderiv_logarithmicDerivation_commute m i hi p
· rw [polynomialFrame_pos m i hi, polynomialFrame_pos m j hj]
exact polynomial_pderiv_commute m i j p
@[simp] theorem polynomialFrame_add (m : ℕ) (i : Fin (m + 1))
(p q : FramePolynomial m) :
polynomialFrame m i (p + q) = polynomialFrame m i p + polynomialFrame m i q :=
map_add _ _ _
theorem polynomialFrame_mul (m : ℕ) (i : Fin (m + 1))
(p q : FramePolynomial m) :
polynomialFrame m i (p * q) =
polynomialFrame m i p * q + p * polynomialFrame m i q := by
rw [Derivation.leibniz]
simp only [smul_eq_mul]
ring
@[simp] theorem polynomialFrame_C (m : ℕ) (i : Fin (m + 1)) (a : ℂ) :
polynomialFrame m i (MvPolynomial.C a) = 0 := by
rw [MvPolynomial.C_eq_algebraMap]
exact Derivation.map_algebraMap _ a
theorem HasWeightedDegreeLE.logarithmicDerivation {m : ℕ}
{w : Fin (m + 1) → ℝ} {N : ℝ} {p : FramePolynomial m}
(hp : HasWeightedDegreeLE w N p) (hw : ∀ i, 0 ≤ w i) :
HasWeightedDegreeLE w N (PiExponentApprox.logarithmicDerivation m p) := by
rw [logarithmicDerivation_apply]
apply (hp.X_mul_pderiv 0).add
exact HasWeightedDegreeLE.sum Finset.univ _
(fun i _ => hp.pderiv_preserves i.succ (hw i.succ))
theorem HasWeightedDegreeLE.polynomialFrame {m : ℕ}
{w : Fin (m + 1) → ℝ} {N : ℝ} {p : FramePolynomial m}
(hp : HasWeightedDegreeLE w N p) (hw : ∀ i, 0 ≤ w i) (i : Fin (m + 1)) :
HasWeightedDegreeLE w N (PiExponentApprox.polynomialFrame m i p) := by
by_cases hi : i = 0
· subst i
rw [polynomialFrame_zero]
exact hp.logarithmicDerivation hw
· rw [polynomialFrame_pos m i hi]
exact hp.pderiv_preserves i (hw i)
def polynomialFrameWord (m : ℕ) (word : List (Fin (m + 1)))
(p : FramePolynomial m) : FramePolynomial m :=
word.foldr (fun i q => polynomialFrame m i q) p
@[simp] theorem polynomialFrameWord_nil (m : ℕ) (p : FramePolynomial m) :
polynomialFrameWord m [] p = p := rfl
@[simp] theorem polynomialFrameWord_cons (m : ℕ) (i : Fin (m + 1))
(word : List (Fin (m + 1))) (p : FramePolynomial m) :
polynomialFrameWord m (i :: word) p =
polynomialFrame m i (polynomialFrameWord m word p) := rfl
theorem polynomialFrame_commute_word (m : ℕ) (i : Fin (m + 1))
(word : List (Fin (m + 1))) (p : FramePolynomial m) :
polynomialFrame m i (polynomialFrameWord m word p) =
polynomialFrameWord m word (polynomialFrame m i p) := by
induction word with
| nil => rfl
| cons j word ih =>
rw [polynomialFrameWord_cons, polynomialFrameWord_cons,
polynomialFrame_commute m i j, ih]
theorem HasWeightedDegreeLE.polynomialFrameWord {m : ℕ}
{w : Fin (m + 1) → ℝ} {N : ℝ} {p : FramePolynomial m}
(hp : HasWeightedDegreeLE w N p) (hw : ∀ i, 0 ≤ w i)
(word : List (Fin (m + 1))) :
HasWeightedDegreeLE w N (PiExponentApprox.polynomialFrameWord m word p) := by
induction word with
| nil => exact hp
| cons i word ih => exact ih.polynomialFrame hw i
end
end PiExponentApprox
end OAI
|