import OAI.Algebra.Determinantal.PencilSeparability

namespace OAI

namespace PermanentBorder.GradientAlgebra

open Finset

section CharacteristicTwo
variable {ι R : Type*} [Fintype ι] [DecidableEq ι] [CommRing R] [CharP R 2]

theorem permanent_eq_det (M : Matrix ι ι R) : M.permanent = M.det := by
  rw [Matrix.permanent, Matrix.det_apply]
  apply Finset.sum_congr rfl
  intro σ _
  rcases Int.units_eq_one_or (Equiv.Perm.sign σ) with h | h
  · simp [h]
  · simp [h, CharTwo.neg_eq]
end CharacteristicTwo

section Derivative
variable {R A ι : Type*} [CommRing R] [CommRing A] [Algebra R A]
variable [DecidableEq ι]

theorem derivation_prod (D : Derivation R A A) (s : Finset ι) (f : ι → A) :
    D (∏ i ∈ s, f i) = ∑ i ∈ s, (∏ j ∈ s.erase i, f j) * D (f i) := by
  induction s using Finset.induction_on with
  | empty => simp
  | @insert a s ha ih =>
    rw [Finset.prod_insert ha, D.leibniz, ih]
    simp only [smul_eq_mul, Finset.sum_insert ha, Finset.erase_insert ha,
      Finset.mul_sum]
    rw [add_comm]
    congr 1
    apply Finset.sum_congr rfl
    intro i hi
    have hai : a ≠ i := by
      intro h
      exact ha (h ▸ hi)
    rw [Finset.erase_insert_of_ne hai, Finset.prod_insert]
    · ring
    · exact Finset.notMem_mono (Finset.erase_subset _ _) ha

variable [Fintype ι]

theorem derivation_det_updateCol (D : Derivation R A A) (M : Matrix ι ι A) :
    D M.det = ∑ j, (M.updateCol j (fun i => D (M i j))).det := by
  rw [Matrix.det_apply, map_sum]
  simp only [Units.smul_def, map_zsmul, derivation_prod]
  simp only [Finset.smul_sum]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro j _
  rw [Matrix.det_apply]
  apply Finset.sum_congr rfl
  intro σ _
  rw [Units.smul_def]
  congr 1
  rw [← Finset.mul_prod_erase _ _ (Finset.mem_univ j)]
  rw [Matrix.updateCol_self]
  rw [mul_comm]
  congr 1
  apply Finset.prod_congr rfl
  intro i hi
  exact (Matrix.updateCol_ne (Finset.ne_of_mem_erase hi)).symm

theorem derivation_det (D : Derivation R A A) (M : Matrix ι ι A) :
    D M.det = ∑ j, ∑ i, M.adjugate j i * D (M i j) := by
  rw [derivation_det_updateCol]
  apply Finset.sum_congr rfl
  intro j _
  rw [← Matrix.cramer_apply, Matrix.cramer_eq_adjugate_mulVec]
  rfl
end Derivative

section Pencil
open MvPolynomial
variable {R ι σ τ : Type*} [CommRing R]

noncomputable def coefficientPart (e : τ →₀ ℕ) :
    MvPolynomial σ (MvPolynomial τ R) →+ MvPolynomial σ R where
  toFun := AddMonoidAlgebra.map (coeffAddMonoidHom e)
  map_zero' := by ext; simp
  map_add' := AddMonoidAlgebra.map_add _

@[simp] theorem coeff_coefficientPart (e : τ →₀ ℕ)
    (P : MvPolynomial σ (MvPolynomial τ R)) (d : σ →₀ ℕ) :
    (coefficientPart e P).coeff d = (P.coeff d).coeff e := rfl

theorem coefficientPart_pderiv (e : τ →₀ ℕ)
    (P : MvPolynomial σ (MvPolynomial τ R)) (i : σ) :
    coefficientPart e (pderiv i P) = pderiv i (coefficientPart e P) := by
  ext d
  simp only [coeff_coefficientPart, coeff_pderiv]
  rw [show (d i + 1 : MvPolynomial τ R) = C (d i + 1 : R) by simp]
  rw [mul_comm, coeff_C_mul, mul_comm]

variable [Fintype ι] [DecidableEq ι]

noncomputable def genericPencil (θ : ι → R) :
    Matrix ι ι (MvPolynomial (ι × ι) (MvPolynomial (Fin 3) R)) :=
  fun i j =>
    C (if i = j then X 0 + C (θ i) * X 1 else 0) + C (X 2) * X (i,j)

omit [Fintype ι] in
@[simp] theorem pderiv_genericPencil (θ : ι → R) (i j a b : ι) :
    pderiv (a,b) (genericPencil θ i j) =
      if (a,b) = (i,j) then C (X (2 : Fin 3)) else 0 := by
  classical
  simp [genericPencil, pderiv_X, Pi.single_apply, eq_comm]

theorem pderiv_det_genericPencil (θ : ι → R) (a b : ι) :
    pderiv (a,b) (genericPencil θ).det =
      C (X (2 : Fin 3)) * (genericPencil θ).adjugate b a := by
  rw [derivation_det]
  simp only [pderiv_genericPencil, Prod.mk.injEq]
  rw [Finset.sum_eq_single b]
  · simp [mul_comm]
  · intro j _ hj
    apply Finset.sum_eq_zero
    intro i _
    simp [Ne.symm hj]
  · simp
end Pencil

section CoefficientCalculus
open MvPolynomial
variable {R σ τ : Type*} [CommRing R]

theorem coefficientPart_C_X_mul (e : τ →₀ ℕ) (i : τ)
    (P : MvPolynomial σ (MvPolynomial τ R)) :
    coefficientPart (Finsupp.single i 1 + e) (C (X i) * P) =
      coefficientPart e P := by
  ext d
  simp only [coeff_coefficientPart, coeff_C_mul, coeff_X_mul]

@[simp] theorem coefficientPart_monomial (e : τ →₀ ℕ) (d : σ →₀ ℕ)
    (a : MvPolynomial τ R) :
    coefficientPart e (monomial d a) = monomial d (a.coeff e) := by
  classical
  ext d'
  simp only [coeff_coefficientPart, coeff_monomial]
  split_ifs <;> simp_all

theorem eval_coefficientPart (e : τ →₀ ℕ) (x : σ → R)
    (P : MvPolynomial σ (MvPolynomial τ R)) :
    eval x (coefficientPart e P) =
      (eval (fun i => C (x i)) P).coeff e := by
  classical
  induction P using MvPolynomial.induction_on' with
  | add P Q hp hq => simp [hp, hq]
  | monomial d a =>
    simp only [coefficientPart_monomial, eval_monomial]
    have hp : d.prod (fun i n => (C (x i) : MvPolynomial τ R) ^ n) =
        C (d.prod (fun i n => x i ^ n)) := by
      simp only [Finsupp.prod, map_prod, map_pow]
    rw [hp, mul_comm a, coeff_C_mul, mul_comm]

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

noncomputable def fixedPencil (θ : ι → R) (x : Matrix ι ι R) :
    Matrix ι ι (MvPolynomial (Fin 3) R) := fun i j =>
      (if i = j then X 0 + C (θ i) * X 1 else 0) + X 2 * C (x i j)

theorem eval_genericPencil (θ : ι → R) (x : Matrix ι ι R) :
    (eval (fun ij : ι × ι => C (x ij.1 ij.2))).mapMatrix (genericPencil θ) =
      fixedPencil θ x := by
  ext i j
  simp [genericPencil, fixedPencil]

theorem gradient_coefficient_identity (θ : ι → R) (x : Matrix ι ι R)
    (e : Fin 3 →₀ ℕ) (a b : ι) :
    eval (fun ij : ι × ι => x ij.1 ij.2)
      (pderiv (a,b) (coefficientPart (Finsupp.single 2 1 + e)
        (genericPencil θ).det)) =
      ((fixedPencil θ x).adjugate b a).coeff e := by
  rw [← coefficientPart_pderiv, pderiv_det_genericPencil, coefficientPart_C_X_mul,
    eval_coefficientPart]
  have h := congrArg (fun M : Matrix ι ι (MvPolynomial (Fin 3) R) => M b a)
    ((eval (fun ij : ι × ι => C (x ij.1 ij.2))).map_adjugate (genericPencil θ))
  change eval (fun ij : ι × ι => C (x ij.1 ij.2))
    ((genericPencil θ).adjugate b a) = _ at h
  rw [h, eval_genericPencil]

theorem gradient_zero_iff_adjugate_coefficient (θ : ι → R) (x : Matrix ι ι R)
    (e : Fin 3 →₀ ℕ) :
    (∀ a b, eval (fun ij : ι × ι => x ij.1 ij.2)
      (pderiv (a,b) (coefficientPart (Finsupp.single 2 1 + e)
        (genericPencil θ).det)) = 0) ↔
    ∀ i j, ((fixedPencil θ x).adjugate i j).coeff e = 0 := by
  simp_rw [gradient_coefficient_identity]
  exact ⟨fun h i j => h j i, fun h i j => h j i⟩
end CoefficientCalculus

section AffinePencil
open MvPolynomial
variable {R σ : Type*} [CommRing R]

noncomputable def biCoefficientPart (a b : ℕ) :
    MvPolynomial σ (Polynomial (Polynomial R)) →+ MvPolynomial σ R where
  toFun := AddMonoidAlgebra.map
    ((Polynomial.lcoeff R b).toAddMonoidHom.comp
      (Polynomial.lcoeff (Polynomial R) a).toAddMonoidHom)
  map_zero' := by ext; simp
  map_add' := AddMonoidAlgebra.map_add _

@[simp] theorem coeff_biCoefficientPart (a b : ℕ)
    (P : MvPolynomial σ (Polynomial (Polynomial R))) (d : σ →₀ ℕ) :
    (biCoefficientPart a b P).coeff d = ((P.coeff d).coeff a).coeff b := rfl

theorem biCoefficientPart_pderiv (a b : ℕ)
    (P : MvPolynomial σ (Polynomial (Polynomial R))) (i : σ) :
    biCoefficientPart a b (pderiv i P) = pderiv i (biCoefficientPart a b P) := by
  ext d
  simp only [coeff_biCoefficientPart, coeff_pderiv]
  simp only [← Nat.cast_add_one, Polynomial.coeff_mul_natCast]

@[simp] theorem biCoefficientPart_monomial (a b : ℕ) (d : σ →₀ ℕ)
    (c : Polynomial (Polynomial R)) :
    biCoefficientPart a b (monomial d c) = monomial d ((c.coeff a).coeff b) := by
  classical
  ext d'
  simp only [coeff_biCoefficientPart, coeff_monomial]
  split_ifs <;> simp_all

theorem eval_biCoefficientPart (a b : ℕ) (x : σ → R)
    (P : MvPolynomial σ (Polynomial (Polynomial R))) :
    eval x (biCoefficientPart a b P) =
      ((eval (fun i => Polynomial.C (Polynomial.C (x i))) P).coeff a).coeff b := by
  classical
  induction P using MvPolynomial.induction_on' with
  | add P Q hp hq => simp [hp, hq]
  | monomial d c =>
    simp only [biCoefficientPart_monomial, eval_monomial]
    have hp : d.prod (fun i n => (Polynomial.C (Polynomial.C (x i))) ^ n) =
        Polynomial.C (Polynomial.C (d.prod (fun i n => x i ^ n))) := by
      simp only [Finsupp.prod, map_prod, map_pow]
    rw [hp, mul_comm c, Polynomial.coeff_C_mul, Polynomial.coeff_C_mul, mul_comm]

variable {ι : Type*} [Fintype ι] [DecidableEq ι]
noncomputable def genericAffinePencil (θ : ι → R) :
    Matrix ι ι (MvPolynomial (ι × ι) (Polynomial (Polynomial R))) :=
  fun i j => C (if i = j then Polynomial.X + Polynomial.C
    (Polynomial.X * Polynomial.C (θ i)) else 0) + X (i,j)

noncomputable def fixedAffinePencil (θ : ι → R) (x : Matrix ι ι R) :
    Matrix ι ι (Polynomial (Polynomial R)) := fun i j =>
      (if i = j then Polynomial.X + Polynomial.C
        (Polynomial.X * Polynomial.C (θ i)) else 0) + Polynomial.C (Polynomial.C (x i j))

omit [Fintype ι] in
@[simp] theorem pderiv_genericAffinePencil (θ : ι → R) (i j a b : ι) :
    pderiv (a,b) (genericAffinePencil θ i j) = if (a,b) = (i,j) then 1 else 0 := by
  classical
  simp [genericAffinePencil, pderiv_X, Pi.single_apply, eq_comm]

theorem pderiv_det_genericAffinePencil (θ : ι → R) (a b : ι) :
    pderiv (a,b) (genericAffinePencil θ).det = (genericAffinePencil θ).adjugate b a := by
  classical
  have hd := derivation_det (pderiv (a,b)) (genericAffinePencil θ)
  rw [hd]
  simp only [pderiv_genericAffinePencil, Prod.mk.injEq]
  rw [Finset.sum_eq_single b]
  · simp
  · intro j _ hj
    apply Finset.sum_eq_zero
    intro i _
    simp [Ne.symm hj]
  · simp

theorem eval_genericAffinePencil (θ : ι → R) (x : Matrix ι ι R) :
    (eval (fun ij : ι × ι => Polynomial.C (Polynomial.C (x ij.1 ij.2)))).mapMatrix
      (genericAffinePencil θ) = fixedAffinePencil θ x := by
  ext i j
  simp [genericAffinePencil, fixedAffinePencil]

noncomputable def affineSelector (θ : ι → R) (q : ℕ) : MvPolynomial (ι × ι) R :=
  biCoefficientPart q q (genericAffinePencil θ).permanent

theorem gradient_affineSelector [CharP R 2] (θ : ι → R)
    (x : Matrix ι ι R) (q : ℕ) (a b : ι) :
    eval (fun ij : ι × ι => x ij.1 ij.2) (pderiv (a,b) (affineSelector θ q)) =
      (((fixedAffinePencil θ x).adjugate b a).coeff q).coeff q := by
  classical
  have hp := permanent_eq_det (genericAffinePencil θ)
  rw [affineSelector, hp, ← biCoefficientPart_pderiv,
    pderiv_det_genericAffinePencil, eval_biCoefficientPart]
  have h := congrArg (fun M : Matrix ι ι (Polynomial (Polynomial R)) => M b a)
    ((eval (fun ij : ι × ι => Polynomial.C (Polynomial.C (x ij.1 ij.2)))).map_adjugate
      (genericAffinePencil θ))
  change eval (fun ij : ι × ι => Polynomial.C (Polynomial.C (x ij.1 ij.2)))
    ((genericAffinePencil θ).adjugate b a) = _ at h
  rw [h, eval_genericAffinePencil]
end AffinePencil

end PermanentBorder.GradientAlgebra

namespace PermanentBorder.Selector
open MvPolynomial
section
variable {R σ : Type*} [CommRing R]

noncomputable def bivariateToNested : MvPolynomial (Fin 2) R →+* Polynomial (Polynomial R) :=
  (Polynomial.mapRingHom (uniqueAlgEquiv R (Fin 1)).toRingHom).comp
    (finSuccEquiv R 1).toRingHom

lemma bivariateToNested_coeff (P : MvPolynomial (Fin 2) R) (q : ℕ) :
    ((bivariateToNested P).coeff q).coeff q = P.coeff (countIndex q) := by
  change ((Polynomial.map (uniqueAlgEquiv R (Fin 1)).toRingHom
    (finSuccEquiv R 1 P)).coeff q).coeff q = _
  rw [Polynomial.coeff_map]
  change ((uniqueAlgEquiv R (Fin 1)) ((finSuccEquiv R 1 P).coeff q)).coeff q = _
  rw [coeff_uniqueAlgEquiv, finSuccEquiv_coeff_coeff]
  congr 1
  ext i
  fin_cases i
  · simp [countIndex]
  · change (Finsupp.cons q (Finsupp.single (0 : Fin 1) q))
      (Fin.succ (0 : Fin 1)) = q
    change (Finsupp.single (0 : Fin 1) q) 0 = q
    simp

@[simp] lemma bivariateToNested_C (r : R) :
    bivariateToNested (C r) = Polynomial.C (Polynomial.C r) := by
  simp [bivariateToNested, finSuccEquiv_apply]

@[simp] lemma bivariateToNested_X_zero :
    bivariateToNested (X (0 : Fin 2) : MvPolynomial (Fin 2) R) = Polynomial.X := by
  change Polynomial.map (uniqueAlgEquiv R (Fin 1)).toRingHom
    (finSuccEquiv R 1 (X 0)) = _
  rw [finSuccEquiv_X_zero, Polynomial.map_X]

@[simp] lemma bivariateToNested_X_one :
    bivariateToNested (X (1 : Fin 2) : MvPolynomial (Fin 2) R) =
      Polynomial.C Polynomial.X := by
  change Polynomial.map (uniqueAlgEquiv R (Fin 1)).toRingHom
    (finSuccEquiv R 1 (X (Fin.succ (0 : Fin 1)))) = _
  rw [finSuccEquiv_X_succ, Polynomial.map_C]
  congr 1
  simp

lemma commAlgEquiv_coeff_coeff (P : MvPolynomial (Fin 2) (MvPolynomial σ R))
    (a : Fin 2 →₀ ℕ) (b : σ →₀ ℕ) :
    ((commAlgEquiv R (Fin 2) σ P).coeff b).coeff a = (P.coeff a).coeff b := by
  classical
  induction P using MvPolynomial.induction_on' with
  | add P Q hP hQ => simp [hP,hQ]
  | monomial d c =>
    induction c using MvPolynomial.induction_on' with
    | add c e hc he => simp [map_add, hc,he]
    | monomial e c =>
      change ((AddMonoidAlgebra.commAlgEquiv R
        (AddMonoidAlgebra.single d (AddMonoidAlgebra.single e c))).coeff b).coeff a = _
      rw [AddMonoidAlgebra.commAlgEquiv_single_single]
      change ((monomial e (monomial d c)).coeff b).coeff a = _
      simp only [coeff_monomial]
      split_ifs <;> simp_all

noncomputable def interchangeBivariate :
    MvPolynomial (Fin 2) (MvPolynomial σ R) →+*
      MvPolynomial σ (Polynomial (Polynomial R)) :=
  (map bivariateToNested).comp (commAlgEquiv R (Fin 2) σ).toRingHom

lemma biCoefficientPart_interchange (P : MvPolynomial (Fin 2) (MvPolynomial σ R)) (q : ℕ) :
    GradientAlgebra.biCoefficientPart q q (interchangeBivariate P) = P.coeff (countIndex q) := by
  ext d
  rw [GradientAlgebra.coeff_biCoefficientPart]
  change (((map bivariateToNested (commAlgEquiv R (Fin 2) σ P)).coeff d).coeff q).coeff q = _
  rw [coeff_map,bivariateToNested_coeff,commAlgEquiv_coeff_coeff]

@[simp] lemma interchangeBivariate_C_X (i : σ) :
    interchangeBivariate (C (X i) : MvPolynomial (Fin 2) (MvPolynomial σ R)) = X i := by
  simp [interchangeBivariate]

@[simp] lemma interchangeBivariate_C_C (r : R) :
    interchangeBivariate (C (C r) : MvPolynomial (Fin 2) (MvPolynomial σ R)) =
      C (Polynomial.C (Polynomial.C r)) := by
  simp [interchangeBivariate]

@[simp] lemma interchangeBivariate_X_zero :
    interchangeBivariate (X (0 : Fin 2) : MvPolynomial (Fin 2) (MvPolynomial σ R)) =
      C Polynomial.X := by
  simp [interchangeBivariate]

@[simp] lemma interchangeBivariate_X_one :
    interchangeBivariate (X (1 : Fin 2) : MvPolynomial (Fin 2) (MvPolynomial σ R)) =
      C (Polynomial.C (Polynomial.X : Polynomial R)) := by
  simp [interchangeBivariate]
end

lemma diagonalCoefficient_eq_affineSelector {R I : Type*} [CommRing R]
    [Fintype I] [DecidableEq I] (θ : I → R) (q : ℕ) :
    diagonalCoefficient (Matrix.of fun i j => (X (i,j) : MvPolynomial (I×I) R))
      (fun i => C (θ i)) q = GradientAlgebra.affineSelector θ q := by
  classical
  unfold diagonalCoefficient GradientAlgebra.affineSelector
  rw [← biCoefficientPart_interchange]
  congr 1
  unfold Matrix.permanent
  simp only [map_sum,map_prod]
  apply Finset.sum_congr rfl
  intro π _
  apply Finset.prod_congr rfl
  intro i _
  simp only [Matrix.add_apply,Matrix.of_apply,Matrix.diagonal_apply,
    GradientAlgebra.genericAffinePencil]
  split_ifs
  · simp only [map_add,map_mul,interchangeBivariate_C_X,interchangeBivariate_X_zero,
      interchangeBivariate_C_C,interchangeBivariate_X_one]
    simp only [← map_mul,← map_add]
    rw [add_comm]
    congr 2
    rw [mul_comm]
  · simp
end PermanentBorder.Selector

end OAI