import OAI.Algebra.FormulaHitting.ScaledDerivatives
import OAI.Algebra.FormulaHitting.WronskianBound
import OAI.Algebra.FormulaHitting.MinorFactor
import Mathlib.RingTheory.PowerSeries.NoZeroDivisors
import Mathlib.Data.Nat.Choose.Basic
import Mathlib.Algebra.BigOperators.Intervals

namespace OAI

noncomputable section

namespace NCHitting

open PowerSeries Polynomial Matrix Submodule

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

def derivativeMatrix {I : Type*} (k : ℕ) (h : I → PowerSeries F) :
    Matrix (Fin k) I (PowerSeries F) := fun j t => derivativeIter j.val (h t)

omit [CharZero F] in
theorem derivativeMatrix_combination {I J : Type*} [Fintype I]
    (k : ℕ) (h : I → PowerSeries F) (C : Matrix I J F) :
    derivativeMatrix k (fun l => ∑ t : I, C t l • h t) =
      derivativeMatrix k h * C.map PowerSeries.C := by
  classical
  funext j l
  change derivativeIter j.val (∑ t : I, C t l • h t) =
    ∑ t : I, derivativeIter j.val (h t) * PowerSeries.C (C t l)
  rw [derivativeIter_sum]
  simp only [derivativeIter_smul]
  simp only [PowerSeries.smul_eq_C_mul]
  apply Finset.sum_congr rfl
  intro t _
  exact mul_comm _ _

omit [CharZero F] in
theorem order_le_natDegree_of_dvd (f : PowerSeries F) (p : F[X])
    (hp : p ≠ 0) (h : f ∣ (p : PowerSeries F)) : f.order.toNat ≤ p.natDegree := by
  by_contra hn
  have hd : PowerSeries.X^f.order.toNat ∣ (p : PowerSeries F) :=
    PowerSeries.X_pow_order_dvd.trans h
  have hz := (PowerSeries.X_pow_dvd_iff.mp hd) p.natDegree (by omega)
  exact (Polynomial.leadingCoeff_ne_zero.mpr hp) (by simpa using hz)

theorem sum_fin_eq_choose (k : ℕ) : (∑ j : Fin k, j.val) = k.choose 2 := by
  calc
    (∑ j : Fin k, j.val) = ∑ j ∈ Finset.range k, j :=
      Fin.sum_univ_eq_sum_range (fun j => j) k
    _ = k.choose 2 := by rw [Finset.sum_range_id, Nat.choose_two_right]

variable {I : Type*} [Fintype I] [DecidableEq I]

def systemScalarOutput (u v : I → F) (G : Matrix I I (PowerSeries F)) :
    PowerSeries F := ∑ l : I, (∑ t : I, PowerSeries.C (u t) * G t l) * PowerSeries.C (v l)

theorem system_multiplicity (n : ℕ) (hn : 0 < n)
    (q : F[X]) (P : Matrix I I F[X]) (u v : I → F)
    (G : Matrix I I (PowerSeries F))
    (hq : q.natDegree ≤ n) (hqn : q ≠ 0)
    (hP : ∀ t l, (P t l).natDegree ≤ n-1) (hG : IsUnit G)
    (hD : ∀ t l, (q : PowerSeries F) * PowerSeries.derivative (R := F) (G t l) =
      ∑ a : I, (P t a : PowerSeries F) * G a l)
    (hy : systemScalarOutput u v G ≠ 0) :
    (systemScalarOutput u v G).order.toNat <
      (n-1) * (Fintype.card I).choose 2 + Fintype.card I := by
  classical
  let h : I → PowerSeries F := fun l => ∑ t : I, PowerSeries.C (u t) * G t l
  let V := Submodule.span F (Set.range h)
  let : FiniteDimensional F V := FiniteDimensional.span_of_finite F (Set.finite_range h)
  obtain ⟨k, b, a, hbi, hspan, ha, hlead, hzero⟩ := hasOrderBasis V
  have hbn : wronskian b ≠ 0 := (wronskian_order_sum b a ha hlead hzero).1
  have hk : k ≤ Fintype.card I := by
    have hkdim : Module.finrank F (Submodule.span F (Set.range b)) = k := by
      simpa using finrank_span_eq_card hbi
    rw [hspan] at hkdim
    rw [← hkdim]
    exact finrank_range_le_card h
  have hhmem : ∀ l, h l ∈ Submodule.span F (Set.range b) := by
    intro l
    rw [hspan]
    exact Submodule.subset_span ⟨l, rfl⟩
  have hbmem : ∀ l, b l ∈ Submodule.span F (Set.range h) := by
    intro l
    change b l ∈ V
    rw [← hspan]
    exact Submodule.subset_span ⟨l, rfl⟩
  have hc : ∀ l : I, ∃ c : Fin k → F, ∑ j : Fin k, c j • b j = h l := by
    intro l
    exact (Submodule.mem_span_range_iff_exists_fun F).mp (hhmem l)
  have he : ∀ l : Fin k, ∃ c : I → F, ∑ j : I, c j • h j = b l := by
    intro l
    exact (Submodule.mem_span_range_iff_exists_fun F).mp (hbmem l)
  choose c hc using hc
  choose e he using he
  let H := derivativeMatrix k h
  let W := wronskianMatrix b
  let C : Matrix (Fin k) I (PowerSeries F) :=
    fun j l => PowerSeries.C (c l j)
  let E : Matrix I (Fin k) (PowerSeries F) :=
    fun j l => PowerSeries.C (e l j)
  let D : Matrix (Fin k) (Fin k) (PowerSeries F) :=
    Matrix.diagonal (fun j => (q : PowerSeries F)^j.val)
  let Zp : Matrix (Fin k) I F[X] := fun j t => numeratorRow q P u j.val t
  let Z : Matrix (Fin k) I (PowerSeries F) :=
    fun j t => (Zp j t : PowerSeries F)
  have hHC : H = W * C := by
    funext j l
    change derivativeIter j.val (h l) =
      ∑ t : Fin k, derivativeIter j.val (b t) * PowerSeries.C (c l t)
    rw [← hc l, derivativeIter_sum]
    simp only [derivativeIter_smul]
    simp only [PowerSeries.smul_eq_C_mul]
    apply Finset.sum_congr rfl
    intro t _
    exact mul_comm _ _
  have hHE : W = H * E := by
    funext j l
    change derivativeIter j.val (b l) =
      ∑ t : I, derivativeIter j.val (h t) * PowerSeries.C (e l t)
    rw [← he l, derivativeIter_sum]
    simp only [derivativeIter_smul]
    simp only [PowerSeries.smul_eq_C_mul]
    apply Finset.sum_congr rfl
    intro t _
    exact mul_comm _ _
  have hZG : Z * G = D * H := by
    funext j l
    rw [Matrix.diagonal_mul]
    exact (scaled_derivative_row q P u G hD j.val l).symm
  have hDn : D.det ≠ 0 := by
    rw [Matrix.det_diagonal]
    apply Finset.prod_ne_zero_iff.mpr
    intro j _
    exact pow_ne_zero _ (Polynomial.coe_eq_zero_iff.not.mpr hqn)
  obtain ⟨f, hfn, hdiv⟩ := exists_nonzero_divisible_minor Z H G D W C E hG hDn hbn hZG hHC hHE
  let p : F[X] := (Zp.submatrix id f).det
  have hpcoe : (p : PowerSeries F) = (Z.submatrix id f).det := by
    exact RingHom.map_det Polynomial.coeToPowerSeries.ringHom (Zp.submatrix id f)
  have hpn : p ≠ 0 := by
    intro hp
    apply hfn
    rw [← hpcoe, hp, Polynomial.coe_zero]
  have hdegree : p.natDegree ≤ (n-1) * k.choose 2 := by
    calc
      p.natDegree ≤ ∑ j : Fin k, j.val * (n-1) := by
        apply natDegree_det_le_sum
        intro j l
        exact numeratorRow_degree hn q P u hq hP j.val (f l)
      _ = (n-1) * k.choose 2 := by
        rw [← Finset.sum_mul, sum_fin_eq_choose, mul_comm]
  have horder : (wronskian b).order.toNat ≤ (n-1) * k.choose 2 := by
    apply (order_le_natDegree_of_dvd (wronskian b) p hpn ?_).trans hdegree
    rwa [hpcoe]
  have hymem : systemScalarOutput u v G ∈ Submodule.span F (Set.range b) := by
    apply Submodule.sum_mem
    intro l _
    change h l * PowerSeries.C (v l) ∈ _
    rw [mul_comm, ← PowerSeries.smul_eq_C_mul]
    exact Submodule.smul_mem _ _ (hhmem l)
  have hybound := order_le_wronskian_add b hbn (systemScalarOutput u v G) hy hymem
  have hkpos : 0 < k := by
    by_contra hn
    have hk0 : k = 0 := by omega
    subst k
    have : systemScalarOutput u v G = 0 := by simpa using hymem
    exact hy this
  have hchoose : k.choose 2 ≤ (Fintype.card I).choose 2 := Nat.choose_le_choose 2 hk
  have hmul := Nat.mul_le_mul_left (n-1) hchoose
  omega

end NCHitting

end

end OAI