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