import OAI.Algebra.FormulaHitting.Series
import OAI.Algebra.FormulaHitting.Independence
import Mathlib.Data.Finsupp.Basic
import Mathlib.Algebra.BigOperators.Finsupp.Basic
import Mathlib.LinearAlgebra.Finsupp.LinearCombination

namespace OAI

noncomputable section
open Polynomial PowerSeries
namespace NCHitting

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

abbrev PolyWords (F : Type*) [Field F] (n : ℕ) := List (Fin n) →₀ F[X]

def polynomialEncode : PolyWords F n →+ PowerSeries F :=
  Finsupp.liftAddHom fun w =>
    { toFun := fun p => (p : PowerSeries F) * wordSeries w
      map_zero' := by simp
      map_add' := by intro p q; simp [add_mul] }

omit [CharZero F] in
@[simp] theorem polynomialEncode_single (w : List (Fin n)) (p : F[X]) :
    polynomialEncode (Finsupp.single w p) = (p : PowerSeries F) * wordSeries w := by
  simp [polynomialEncode]

def stripLetter (i : Fin n) : PolyWords F n →+ PolyWords F n :=
  Finsupp.comapDomain.addMonoidHom (List.cons_injective (a := i))

omit [CharZero F] in
@[simp] theorem stripLetter_apply (i : Fin n) (c : PolyWords F n) (w : List (Fin n)) :
    stripLetter i c w = c (i :: w) := rfl

omit [CharZero F] in
@[simp] theorem stripLetter_single_nil (i : Fin n) (p : F[X]) :
    stripLetter i (Finsupp.single [] p) = 0 := by
  ext w
  simp [stripLetter_apply]

omit [CharZero F] in
@[simp] theorem stripLetter_single_cons (i j : Fin n) (w : List (Fin n)) (p : F[X]) :
    stripLetter i (Finsupp.single (j :: w) p) =
      if i = j then Finsupp.single w p else 0 := by
  classical
  by_cases h : i = j
  · subst j
    ext v
    simp [stripLetter_apply, Finsupp.single_apply]
  · ext v
    simp [stripLetter_apply, h]

def polynomialDifferential (q p0 : F[X]) : F[X] →+ F[X] where
  toFun p := q * (p0 * p.derivative - p0.derivative * p)
  map_zero' := by simp
  map_add' p r := by simp [Polynomial.derivative_add]; ring

def polynomialMul (q : F[X]) : F[X] →+ F[X] where
  toFun p := q * p
  map_zero' := mul_zero q
  map_add' := mul_add q

def polynomialTransform (q p0 : F[X]) (Q : Fin n → F[X]) : PolyWords F n →+ PolyWords F n :=
  Finsupp.mapRange.addMonoidHom (polynomialDifferential q p0) +
    ∑ i, (Finsupp.mapRange.addMonoidHom (polynomialMul (p0 * Q i))).comp (stripLetter i)

omit [CharZero F] in
@[simp] theorem polynomialTransform_apply (q p0 : F[X]) (Q : Fin n → F[X])
    (c : PolyWords F n) (w : List (Fin n)) :
    polynomialTransform q p0 Q c w =
      q * (p0 * (c w).derivative - p0.derivative * c w) +
        ∑ i, (p0 * Q i) * c (i :: w) := by
  classical
  simp [polynomialTransform, polynomialDifferential, polynomialMul]

omit [CharZero F] in
@[simp] theorem polynomialTransform_single_nil (q p0 : F[X]) (Q : Fin n → F[X])
    (p : F[X]) :
    polynomialTransform q p0 Q (Finsupp.single [] p) =
      Finsupp.single [] (q * (p0 * p.derivative - p0.derivative * p)) := by
  classical
  simp [polynomialTransform, polynomialDifferential, polynomialMul]

omit [CharZero F] in
@[simp] theorem polynomialTransform_single_cons (q p0 : F[X]) (Q : Fin n → F[X])
    (i : Fin n) (w : List (Fin n)) (p : F[X]) :
    polynomialTransform q p0 Q (Finsupp.single (i :: w) p) =
      Finsupp.single (i :: w) (q * (p0 * p.derivative - p0.derivative * p)) +
        Finsupp.single w ((p0 * Q i) * p) := by
  classical
  simp [polynomialTransform, polynomialDifferential, polynomialMul, apply_ite]

omit [CharZero F] in
theorem polynomialEncode_transform (q p0 : F[X]) (Q : Fin n → F[X])
    (hq : ∀ (i : Fin n) (w : List (Fin n)),
      (q : PowerSeries F) * PowerSeries.derivative (R := F) (wordSeries (i :: w)) =
        (Q i : PowerSeries F) * wordSeries w)
    (c : PolyWords F n) :
    polynomialEncode (polynomialTransform q p0 Q c) =
      (q : PowerSeries F) * ((p0 : PowerSeries F) *
        PowerSeries.derivative (R := F) (polynomialEncode c) -
          (p0.derivative : PowerSeries F) * polynomialEncode c) := by
  classical
  induction c using Finsupp.induction_linear with
  | zero => simp
  | add c d hc hd =>
    simp only [map_add, hc, hd]
    ring
  | single w p =>
    cases w with
    | nil => simp [PowerSeries.derivative_coe]
    | cons i w =>
      rw [polynomialTransform_single_cons, map_add, polynomialEncode_single,
        polynomialEncode_single, polynomialEncode_single]
      simp only [Polynomial.coe_mul, Polynomial.coe_sub]
      symm
      calc
        _ = ((q : PowerSeries F) * ((p0 : PowerSeries F) *
              (p.derivative : PowerSeries F) - (p0.derivative : PowerSeries F) *
                (p : PowerSeries F))) *
              wordSeries (i :: w) +
            ((p0 : PowerSeries F) * (p : PowerSeries F)) *
              ((q : PowerSeries F) * PowerSeries.derivative (R := F) (wordSeries (i :: w))) := by
          rw [Derivation.leibniz, PowerSeries.derivative_coe]
          simp only [smul_eq_mul]
          ring
        _ = _ := by rw [hq]; ring

def naturalPoles (i : Fin n) : F := -((i.val + 1 : ℕ) : F)

theorem naturalPoles_injective : Function.Injective (naturalPoles (F := F) (n := n)) := by
  intro i j h
  apply Fin.ext
  have he : ((i.val + 1 : ℕ) : F) = ((j.val + 1 : ℕ) : F) := neg_injective h
  have hn := Nat.cast_injective he
  omega

omit [CharZero F] in
theorem natural_poleProduct_ne_zero : poleProduct (naturalPoles (F := F) (n := n)) ≠ 0 := by
  apply Finset.prod_ne_zero_iff.mpr
  intro i hi
  exact Polynomial.X_sub_C_ne_zero _

theorem natural_poleProduct_mul_kernel (i : Fin n) :
    (poleProduct (naturalPoles (F := F) (n := n)) : PowerSeries F) * kernel (i.val + 1) =
      (puncturedPoleProduct (naturalPoles (F := F)) i : PowerSeries F) := by
  rw [poleProduct_eq _ i]
  simp only [Polynomial.coe_mul, Polynomial.coe_add,
    Polynomial.coe_X, Polynomial.coe_C,
    naturalPoles, map_neg, sub_neg_eq_add]
  calc
    _ = (puncturedPoleProduct (naturalPoles (F := F)) i : PowerSeries F) *
          (kernel (i.val + 1) * (PowerSeries.X + PowerSeries.C (((i.val + 1 : ℕ) : F)))) := by ring
    _ = _ := by rw [kernel_mul_linear _ (Nat.succ_ne_zero _)]; simp

theorem natural_poleProduct_derivative (i : Fin n) (w : List (Fin n)) :
    (poleProduct (naturalPoles (F := F) (n := n)) : PowerSeries F) *
      PowerSeries.derivative (R := F) (wordSeries (i :: w)) =
        (puncturedPoleProduct (naturalPoles (F := F)) i : PowerSeries F) * wordSeries w := by
  rw [derivative_wordSeries_cons]
  rw [mul_left_comm, natural_poleProduct_mul_kernel, mul_comm]

def LengthBound (D : ℕ) (c : PolyWords F n) : Prop :=
  ∀ w, c w ≠ 0 → w.length ≤ D

def topSupport (D : ℕ) (c : PolyWords F n) : Finset (List (Fin n)) :=
  c.support.filter fun w => w.length = D

omit [CharZero F] in
@[simp] theorem mem_topSupport (D : ℕ) (c : PolyWords F n) (w : List (Fin n)) :
    w ∈ topSupport D c ↔ c w ≠ 0 ∧ w.length = D := by
  simp [topSupport]

omit [CharZero F] in
theorem transform_lengthBound (D : ℕ) (c : PolyWords F n) (hc : LengthBound D c)
    (q p0 : F[X]) (Q : Fin n → F[X]) : LengthBound D (polynomialTransform q p0 Q c) := by
  intro w hw
  by_contra hlen
  have hcw : c w = 0 := by
    by_contra hne
    exact hlen (hc w hne)
  have hchild : ∀ i, c (i :: w) = 0 := by
    intro i
    by_contra hne
    have hb := hc (i :: w) hne
    simp only [List.length_cons] at hb
    omega
  apply hw
  simp [hcw, hchild]

omit [CharZero F] in
theorem transform_top_coefficient (D : ℕ) (c : PolyWords F n) (hc : LengthBound D c)
    (q p0 : F[X]) (Q : Fin n → F[X]) (w : List (Fin n)) (hw : w.length = D) :
    polynomialTransform q p0 Q c w = q * (p0 * (c w).derivative - p0.derivative * c w) := by
  have hchild : ∀ i, c (i :: w) = 0 := by
    intro i
    by_contra hne
    have hb := hc (i :: w) hne
    simp only [List.length_cons, hw] at hb
    omega
  simp [hchild]

omit [CharZero F] in
private theorem topSupport_transform_ssubset (D : ℕ) (c : PolyWords F n)
    (hc : LengthBound D c) (q : F[X]) (Q : Fin n → F[X])
    (w0 : List (Fin n)) (hw0 : w0 ∈ topSupport D c) :
    topSupport D (polynomialTransform q (c w0) Q c) ⊂ topSupport D c := by
  have hsub : topSupport D (polynomialTransform q (c w0) Q c) ⊆ topSupport D c := by
    intro w hw
    obtain ⟨hne, hlen⟩ := (mem_topSupport _ _ _).mp hw
    apply (mem_topSupport _ _ _).mpr
    refine ⟨?_, hlen⟩
    intro hz
    apply hne
    rw [transform_top_coefficient D c hc q (c w0) Q w hlen, hz]
    simp
  apply Finset.ssubset_iff_subset_ne.mpr
  refine ⟨hsub, ?_⟩
  intro heq
  have hm : w0 ∈ topSupport D (polynomialTransform q (c w0) Q c) := by rwa [heq]
  have hz : polynomialTransform q (c w0) Q c w0 = 0 := by
    rw [transform_top_coefficient D c hc q (c w0) Q w0
      ((mem_topSupport _ _ _).mp hw0).2]
    ring
  exact ((mem_topSupport _ _ _).mp hm).1 hz

theorem polynomialEncode_eq_zero (D : ℕ) (c : PolyWords F n)
    (hc : LengthBound D c) (he : polynomialEncode c = 0) : c = 0 := by
  classical
  induction D generalizing c with
  | zero =>
    have hs : c = Finsupp.single [] (c []) := by
      ext w
      cases w with
      | nil => simp
      | cons i w =>
        have hz : c (i :: w) = 0 := by
          by_contra hne
          have hh := hc (i :: w) hne
          simp [List.length_cons] at hh
        simp [hz]
    have hz : c [] = 0 := by
      have hh := he
      rw [hs, polynomialEncode_single, wordSeries_nil, mul_one] at hh
      exact Polynomial.coe_eq_zero_iff.mp hh
    rw [hs, hz, Finsupp.single_zero]
  | succ D ih =>
    by_contra hcne
    have top_exists : ∀ b : PolyWords F n, LengthBound (D+1) b →
        polynomialEncode b = 0 → b ≠ 0 → (topSupport (D+1) b).Nonempty := by
      intro b hb hbe hbne
      by_contra hn
      apply hbne
      apply ih b ?_ hbe
      intro w hw
      have hbnd := hb w hw
      have hneq : w.length ≠ D+1 := by
        intro hlen
        exact hn ⟨w, (mem_topSupport _ _ _).mpr ⟨hw, hlen⟩⟩
      omega
    let P : ℕ → Prop := fun k => ∃ b : PolyWords F n,
      LengthBound (D+1) b ∧ polynomialEncode b = 0 ∧ b ≠ 0 ∧
        (topSupport (D+1) b).card = k
    have hex : ∃ k, P k := ⟨(topSupport (D+1) c).card, c, hc, he, hcne, rfl⟩
    obtain ⟨b, hb, hbe, hbne, hbcard⟩ := Nat.find_spec hex
    obtain ⟨w0, hw0⟩ := top_exists b hb hbe hbne
    have hp0 : b w0 ≠ 0 := ((mem_topSupport _ _ _).mp hw0).1
    have hwlen : w0.length = D+1 := ((mem_topSupport _ _ _).mp hw0).2
    let q := poleProduct (naturalPoles (F := F) (n := n))
    let Q := puncturedPoleProduct (naturalPoles (F := F) (n := n))
    let p0 := b w0
    let b' := polynomialTransform q p0 Q b
    have hb' : LengthBound (D+1) b' := transform_lengthBound _ b hb q p0 Q
    have hb'e : polynomialEncode b' = 0 := by
      rw [polynomialEncode_transform q p0 Q natural_poleProduct_derivative, hbe]
      simp
    have hcard : (topSupport (D+1) b').card < (topSupport (D+1) b).card :=
      Finset.card_lt_card (topSupport_transform_ssubset (D+1) b hb q Q w0 hw0)
    have hb'zero : b' = 0 := by
      by_contra hne
      have hmin : Nat.find hex ≤ (topSupport (D+1) b').card :=
        Nat.find_min' hex ⟨b', hb', hb'e, hne, rfl⟩
      omega
    have htop : ∀ w, w.length = D+1 →
        Polynomial.wronskian p0 (b w) = 0 := by
      intro w hw
      have hh : polynomialTransform q p0 Q b w = 0 := by
        exact DFunLike.congr_fun hb'zero w
      rw [transform_top_coefficient (D+1) b hb q p0 Q w hw] at hh
      have hq : q ≠ 0 := natural_poleProduct_ne_zero
      exact (mul_eq_zero.mp hh).resolve_left hq
    cases w0 with
    | nil => simp at hwlen
    | cons i v =>
      have hvl : v.length = D := by simpa using hwlen
      have hprop : ∀ j : Fin n, ∃ a : F, b (j :: v) = a • p0 := by
        intro j
        apply eq_smul_of_wronskian_eq_zero p0 (b (j :: v)) hp0
        apply htop
        simp [hvl]
      choose a ha using hprop
      have hraw : q * (p0 * (b v).derivative - p0.derivative * b v) +
          ∑ j, (p0 * Q j) * b (j :: v) = 0 := by
        rw [← polynomialTransform_apply]
        exact DFunLike.congr_fun hb'zero v
      have hsum : (∑ j, (p0 * Q j) * b (j :: v)) =
          p0^2 * (∑ j, Polynomial.C (a j) * Q j) := by
        rw [Finset.mul_sum]
        apply Finset.sum_congr rfl
        intro j hj
        rw [ha j, Polynomial.smul_eq_C_mul]
        ring
      rw [hsum] at hraw
      have ha0 := no_polynomial_log_primitive (naturalPoles (F := F) (n := n))
        naturalPoles_injective p0 (b v) hp0 a hraw i
      apply hp0
      rw [ha i, ha0, zero_smul]

omit [CharZero F] in
private theorem linearCombination_eq_polynomialEncode (c : PolyWords F n) :
    Finsupp.linearCombination F[X] (wordSeries (F := F) (n := n)) c = polynomialEncode c := by
  simp [Finsupp.linearCombination_apply, polynomialEncode, Finsupp.liftAddHom_apply,
    Algebra.smul_def, PowerSeries.algebraMap_apply']

theorem wordSeries_polynomial_independent :
    LinearIndependent F[X] (wordSeries (F := F) (n := n)) := by
  rw [linearIndependent_iff]
  intro c hc
  apply polynomialEncode_eq_zero (c.support.sup List.length) c
  · intro w hw
    exact Finset.le_sup (Finsupp.mem_support_iff.mpr hw)
  · rwa [linearCombination_eq_polynomialEncode] at hc

theorem wordSeries_independent : LinearIndependent F (wordSeries (F := F) (n := n)) :=
  wordSeries_polynomial_independent.restrict_scalars' F

end NCHitting

end

end OAI