import Mathlib.RingTheory.PowerSeries.Derivative
import Mathlib.RingTheory.PowerSeries.Order
import Mathlib.Algebra.BigOperators.NatAntidiagonal
import Mathlib.Tactic.Ring
import Mathlib.Tactic.FieldSimp
import Lean.Elab.Tactic.Omega

namespace OAI

noncomputable section
open PowerSeries
namespace NCHitting

variable {F : Type*} [Field F] [CharZero F]

def integral (a : PowerSeries F) : PowerSeries F :=
  PowerSeries.mk fun r => match r with
    | 0 => 0
    | r + 1 => PowerSeries.coeff r a / (r + 1 : F)

omit [CharZero F] in
@[simp] theorem coeff_integral_zero (a : PowerSeries F) :
    PowerSeries.coeff 0 (integral a) = 0 := by simp [integral]

omit [CharZero F] in
@[simp] theorem coeff_integral_succ (a : PowerSeries F) (r : ℕ) :
    PowerSeries.coeff (r+1) (integral a) = PowerSeries.coeff r a / (r+1 : F) := by
  simp [integral]

omit [CharZero F] in
@[simp] theorem constantCoeff_integral (a : PowerSeries F) :
    PowerSeries.constantCoeff (integral a) = 0 := by
  simpa only [PowerSeries.coeff_zero_eq_constantCoeff] using coeff_integral_zero a

@[simp] theorem derivative_integral (a : PowerSeries F) :
    PowerSeries.derivative (R := F) (integral a) = a := by
  ext r
  rw [PowerSeries.coeff_derivative, coeff_integral_succ]
  exact div_mul_cancel₀ _ (by simpa using (Nat.cast_ne_zero.mpr (Nat.succ_ne_zero r) : ((r + 1 : ℕ) : F) ≠ 0))

theorem integral_unique (a b : PowerSeries F)
    (hd : PowerSeries.derivative (R := F) b = a) (hc : PowerSeries.constantCoeff b = 0) :
    b = integral a := by
  apply PowerSeries.derivative.ext
  · simpa using hd
  · simpa using hc

omit [CharZero F] in
@[simp] theorem integral_zero : integral (0 : PowerSeries F) = 0 := by
  ext r
  cases r <;> simp [integral]

omit [CharZero F] in
@[simp] theorem integral_add (a b : PowerSeries F) :
    integral (a+b) = integral a + integral b := by
  ext r
  cases r with
  | zero => simp
  | succ r => simp [add_div]

omit [CharZero F] in
@[simp] theorem integral_smul (c : F) (a : PowerSeries F) :
    integral (c • a) = c • integral a := by
  ext r
  cases r with
  | zero => simp
  | succ r => simp [smul_eq_mul, mul_div_assoc]

def kernel (i : ℕ) : PowerSeries F :=
  PowerSeries.mk fun r => (-1 : F)^r / (i : F)^(r+1)

omit [CharZero F] in
@[simp] theorem coeff_kernel (i r : ℕ) :
    PowerSeries.coeff r (kernel (F := F) i) = (-1 : F)^r / (i : F)^(r+1) := by
  simp [kernel]

def J (i : ℕ) (a : PowerSeries F) : PowerSeries F := integral (a * kernel i)

@[simp] theorem derivative_J (i : ℕ) (a : PowerSeries F) :
    PowerSeries.derivative (R := F) (J i a) = a * kernel i := by simp [J]

omit [CharZero F] in
@[simp] theorem constantCoeff_J (i : ℕ) (a : PowerSeries F) :
    PowerSeries.constantCoeff (J i a) = 0 := by simp [J]

omit [CharZero F] in
@[simp] theorem J_zero (i : ℕ) : J i (0 : PowerSeries F) = 0 := by simp [J]

omit [CharZero F] in
@[simp] theorem J_add (i : ℕ) (a b : PowerSeries F) :
    J i (a+b) = J i a + J i b := by simp [J, add_mul]

omit [CharZero F] in
@[simp] theorem J_smul (i : ℕ) (c : F) (a : PowerSeries F) :
    J i (c • a) = c • J i a := by simp [J]

def JLinear (i : ℕ) : PowerSeries F →ₗ[F] PowerSeries F where
  toFun := J i
  map_add' := J_add i
  map_smul' := J_smul i

omit [CharZero F] in
@[simp] theorem J_sum {ι : Type*} (i : ℕ) (s : Finset ι) (a : ι → PowerSeries F) :
    J i (∑ j ∈ s, a j) = ∑ j ∈ s, J i (a j) :=
  map_sum (JLinear i) a s

omit [CharZero F] in
theorem coeff_J (i r : ℕ) (a : PowerSeries F) :
    PowerSeries.coeff r (J i a) =
      ∑ q ∈ Finset.range r,
        ((-1 : F)^(r-q-1) / ((r : F) * (i : F)^(r-q))) * PowerSeries.coeff q a := by
  cases r with
  | zero => simp [J]
  | succ r =>
    rw [J, coeff_integral_succ, PowerSeries.coeff_mul,
      Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk, div_eq_mul_inv, Finset.sum_mul]
    apply Finset.sum_congr rfl
    intro q hq
    have hqr : q ≤ r := Nat.lt_succ_iff.mp (Finset.mem_range.mp hq)
    have hsub' : r+1-q = r-q+1 := by omega
    simp only [coeff_kernel, hsub', Nat.add_sub_cancel, Nat.cast_add, Nat.cast_one]
    simp only [div_eq_mul_inv, mul_inv_rev]
    ring

omit [CharZero F] in
theorem coeff_J_eq_zero (i r : ℕ) (a : PowerSeries F)
    (h : ∀ q < r, PowerSeries.coeff q a = 0) :
    PowerSeries.coeff r (J i a) = 0 := by
  rw [coeff_J]
  apply Finset.sum_eq_zero
  intro q hq
  rw [h q (Finset.mem_range.mp hq), mul_zero]

theorem kernel_mul_linear (i : ℕ) (hi : i ≠ 0) :
    kernel (F := F) i * (PowerSeries.X + PowerSeries.C (i : F)) = 1 := by
  have hiF : (i : F) ≠ 0 := Nat.cast_ne_zero.mpr hi
  ext r
  cases r with
  | zero => simp [mul_add, kernel, hiF]
  | succ r =>
    rw [mul_add, map_add, PowerSeries.coeff_mul_C]
    have hx : PowerSeries.coeff (r+1) (kernel (F := F) i * PowerSeries.X) =
        PowerSeries.coeff r (kernel (F := F) i) := by
      simp
    rw [hx]
    simp only [coeff_kernel, PowerSeries.coeff_one, Nat.succ_ne_zero, ite_false,
      pow_succ]
    field_simp
    ring

def wordSeries {n : ℕ} : List (Fin n) → PowerSeries F
  | [] => 1
  | i :: w => J (i.val + 1) (wordSeries w)

omit [CharZero F] in
@[simp] theorem wordSeries_nil {n : ℕ} : wordSeries (F := F) (n := n) [] = 1 := rfl
omit [CharZero F] in
@[simp] theorem wordSeries_cons {n : ℕ} (i : Fin n) (w : List (Fin n)) :
    wordSeries (F := F) (i :: w) = J (i.val + 1) (wordSeries w) := rfl

@[simp] theorem derivative_wordSeries_cons {n : ℕ} (i : Fin n) (w : List (Fin n)) :
    PowerSeries.derivative (R := F) (wordSeries (i :: w)) = wordSeries w * kernel (i.val + 1) := by simp

omit [CharZero F] in
@[simp] theorem constantCoeff_wordSeries_cons {n : ℕ} (i : Fin n) (w : List (Fin n)) :
    PowerSeries.constantCoeff (wordSeries (F := F) (i :: w)) = 0 := by simp

omit [CharZero F] in
theorem coeff_wordSeries_below {n : ℕ} (w : List (Fin n)) (r : ℕ) (hr : r < w.length) :
    PowerSeries.coeff r (wordSeries (F := F) w) = 0 := by
  induction w generalizing r with
  | nil => simp at hr
  | cons i w ih =>
    rw [wordSeries_cons]
    apply coeff_J_eq_zero
    intro q hq
    apply ih q
    simp only [List.length_cons] at hr
    omega

omit [CharZero F] in
theorem length_le_order_wordSeries {n : ℕ} (w : List (Fin n)) :
    (w.length : ℕ∞) ≤ (wordSeries (F := F) w).order :=
  PowerSeries.nat_le_order _ _ (coeff_wordSeries_below w)

section Map
variable {K : Type*} [Field K] [CharZero K]

omit [CharZero F] [CharZero K] in
theorem map_integral (f : F →+* K) (a : PowerSeries F) :
    PowerSeries.map f (integral a) = integral (PowerSeries.map f a) := by
  ext r
  cases r with
  | zero => simp
  | succ r => simp [map_div₀]

omit [CharZero F] [CharZero K] in
theorem map_kernel (f : F →+* K) (i : ℕ) :
    PowerSeries.map f (kernel (F := F) i) = kernel (F := K) i := by
  ext r
  simp [map_div₀]

omit [CharZero F] [CharZero K] in
theorem map_J (f : F →+* K) (i : ℕ) (a : PowerSeries F) :
    PowerSeries.map f (J i a) = J i (PowerSeries.map f a) := by
  simp [J, map_integral, map_kernel]

omit [CharZero F] [CharZero K] in
theorem map_wordSeries (f : F →+* K) {n : ℕ} (w : List (Fin n)) :
    PowerSeries.map f (wordSeries (F := F) w) = wordSeries (F := K) w := by
  induction w with
  | nil => simp
  | cons i w ih => simp [map_J, ih]

end Map

end NCHitting

end

end OAI