import Mathlib
import OAI.Analysis.Crouzeix.Vectorization

namespace OAI

/-! Block Polynomial. -/

noncomputable section

open scoped Matrix Matrix.Norms.L2Operator Kronecker TensorProduct

namespace CrouzeixHilbert

def blockPolynomialEval {n m : ℕ} (D : Coeff n) :
    Matrix (Fin m) (Fin m) (Polynomial ℂ) →+*
      Matrix (Fin n × Fin m) (Fin n × Fin m) ℂ where
  toFun M i j := (Polynomial.aeval D (M i.2 j.2)) i.1 j.1
  map_zero' := by ext ⟨i,j⟩ ⟨k,l⟩; simp
  map_one' := by
    ext ⟨i,j⟩ ⟨k,l⟩
    change (Polynomial.aeval D (if j = l then 1 else 0)) i k =
      if (i,j) = (k,l) then 1 else 0
    by_cases h : j = l
    · subst l
      simp only [ite_true, map_one, Matrix.one_apply, Prod.mk.injEq, and_true]
    · simp only [h, ite_false, map_zero, Matrix.zero_apply, Prod.mk.injEq, and_false]
  map_add' M N := by
    ext ⟨i,j⟩ ⟨k,l⟩
    change (Polynomial.aeval D (M j l + N j l)) i k = _ + _
    rw [map_add]
    rfl
  map_mul' M N := by
    ext ⟨i,j⟩ ⟨k,l⟩
    change (Polynomial.aeval D (∑ h, M j h * N h l)) i k =
      ∑ h : Fin n × Fin m, (Polynomial.aeval D (M j h.2)) i h.1 *
        (Polynomial.aeval D (N h.2 l)) h.1 k
    simp only [map_sum, map_mul, Matrix.sum_apply, Matrix.mul_apply,
      Fintype.sum_prod_type]
    rw [Finset.sum_comm]

@[simp] theorem blockPolynomialEval_apply {n m : ℕ} (D : Coeff n)
    (M : Matrix (Fin m) (Fin m) (Polynomial ℂ)) (i k : Fin n) (j l : Fin m) :
    blockPolynomialEval D M (i,j) (k,l) = Polynomial.aeval D (M j l) i k := rfl

theorem blockPolynomialEval_smul_constant {n m : ℕ} (D : Coeff n)
    (p : Polynomial ℂ) (B : Coeff m) :
    blockPolynomialEval D (p • B.map Polynomial.C) = Polynomial.aeval D p ⊗ₖ B := by
  ext ⟨i,j⟩ ⟨k,l⟩
  simp only [blockPolynomialEval_apply, Matrix.smul_apply, Matrix.map_apply,
    smul_eq_mul, map_mul, Polynomial.aeval_C, Matrix.kronecker_apply,
    Algebra.algebraMap_eq_smul_one, mul_smul_comm, mul_one, Matrix.smul_apply]
  exact mul_comm _ _

@[simp] theorem blockPolynomialEval_constant {n m : ℕ} (D : Coeff n) (B : Coeff m) :
    blockPolynomialEval D (B.map Polynomial.C) = 1 ⊗ₖ B := by
  simpa only [one_smul, map_one] using blockPolynomialEval_smul_constant D 1 B

theorem blockPolynomialEval_scalar {n m : ℕ} (D : Coeff n) (p : Polynomial ℂ) :
    blockPolynomialEval (m := m) D (p • 1) = Polynomial.aeval D p ⊗ₖ 1 := by
  have he : (1 : Coeff m).map Polynomial.C = 1 :=
    (Polynomial.C.mapMatrix).map_one
  rw [← he, blockPolynomialEval_smul_constant]

theorem blockPolynomialEval_commute {n m : ℕ} (D : Coeff n) (p : Polynomial ℂ)
    (M : Matrix (Fin m) (Fin m) (Polynomial ℂ)) :
    Commute (Polynomial.aeval D p ⊗ₖ (1 : Coeff m)) (blockPolynomialEval D M) := by
  rw [← blockPolynomialEval_scalar]
  apply Commute.map _ (blockPolynomialEval D)
  show (p • (1 : Matrix (Fin m) (Fin m) (Polynomial ℂ))) * M = M * (p • 1)
  rw [smul_mul_assoc, one_mul, mul_smul_comm, mul_one]

theorem blockPolynomialEval_expansion {n m : ℕ} (D : Coeff n)
    (P : Matrix (Fin m) (Fin m) (Polynomial ℂ)) :
    blockPolynomialEval D P =
      ∑ i, ∑ j, Polynomial.aeval D (P i j) ⊗ₖ Matrix.single i j 1 := by
  ext ⟨i,j⟩ ⟨k,l⟩
  simp [Matrix.sum_apply, Matrix.single_apply, ite_and]

namespace Realization

theorem aeval_reduced_denom_isUnit {A : Type*} [Ring A] [Algebra ℂ A]
    (D : A) (p q : Polynomial ℂ) (hq : IsUnit (Polynomial.aeval D q)) :
    IsUnit (Polynomial.aeval D
      ((algebraMap _ (RatFunc ℂ)) p / (algebraMap _ (RatFunc ℂ)) q).denom) := by
  let r := (algebraMap _ (RatFunc ℂ)) p / (algebraMap _ (RatFunc ℂ)) q
  obtain ⟨b, hb⟩ := RatFunc.denom_div_dvd p q
  have hc := (Commute.all r.denom b).map (Polynomial.aeval D)
  apply (hc.isUnit_mul_iff.mp ?_).1
  rw [← map_mul]
  exact hb ▸ hq

theorem aeval_quotient_cancel {A : Type*} [Ring A] [Algebra ℂ A]
    (D : A) (p q : Polynomial ℂ) (hq0 : q ≠ 0) (hq : IsUnit (Polynomial.aeval D q)) :
    Polynomial.aeval D q *
      (Polynomial.aeval D ((algebraMap _ (RatFunc ℂ)) p / (algebraMap _ (RatFunc ℂ)) q).num *
        Ring.inverse (Polynomial.aeval D ((algebraMap _ (RatFunc ℂ)) p /
          (algebraMap _ (RatFunc ℂ)) q).denom)) = Polynomial.aeval D p := by
  let r := (algebraMap _ (RatFunc ℂ)) p / (algebraMap _ (RatFunc ℂ)) q
  have hd := aeval_reduced_denom_isUnit D p q hq
  have he := congrArg (Polynomial.aeval D)
    ((RatFunc.num_mul_eq_mul_denom_iff hq0).mpr (show r = _ from rfl))
  simp only [map_mul] at he
  change Polynomial.aeval D q * (Polynomial.aeval D r.num * Ring.inverse _) = _
  rw [← mul_assoc, ((Commute.all q r.num).map (Polynomial.aeval D)).eq,
    he, mul_assoc, Ring.mul_inverse_cancel _ hd, mul_one]

theorem map_ringInverse_equiv {A B : Type*} [Ring A] [Ring B]
    (e : A ≃+* B) (x : A) : e (Ring.inverse x) = Ring.inverse (e x) := by
  by_cases hx : IsUnit x
  · exact map_ringInverse_of_isUnit e.toRingHom hx
  · have hy : ¬ IsUnit (e x) := by
      intro h
      apply hx
      simpa only [RingEquiv.symm_apply_apply] using h.map e.symm
    rw [Ring.inverse_non_unit _ hx, Ring.inverse_non_unit _ hy, map_zero]

end Realization

def rationalBaseMatrix {n : ℕ} (D : Coeff n) (r : RatFunc ℂ) : Coeff n :=
  Polynomial.aeval D r.num * Ring.inverse (Polynomial.aeval D r.denom)

@[simp] theorem rationalEval_matrix {n : ℕ} (D : Coeff n) (r : RatFunc ℂ) :
    rationalEval (Matrix.toEuclideanCLM (𝕜 := ℂ) D) r =
      Matrix.toEuclideanCLM (𝕜 := ℂ) (rationalBaseMatrix D r) := by
  simp only [rationalEval, rationalBaseMatrix, map_mul,
    Polynomial.aeval_algHom_apply]
  congr 1
  exact (Realization.map_ringInverse_equiv
    (Matrix.toEuclideanCLM (𝕜 := ℂ) (n := Fin n)).toRingEquiv _).symm

def blockRationalEval {n m : ℕ} (D : Coeff n) (R : RationalMatrix m) :
    Matrix (Fin n × Fin m) (Fin n × Fin m) ℂ :=
  ∑ i, ∑ j, rationalBaseMatrix D (R i j) ⊗ₖ Matrix.single i j 1

theorem matrixAmplificationCoordinates_rationalEval {n m : ℕ}
    (D : Coeff n) (R : RationalMatrix m)
    (v : Amplification (EuclideanSpace ℂ (Fin n)) m) :
    matrixAmplificationCoordinates n m
      (matrixRationalEval (Matrix.toEuclideanCLM (𝕜 := ℂ) D) R v) =
        Matrix.toEuclideanCLM (𝕜 := ℂ) (blockRationalEval D R)
          (matrixAmplificationCoordinates n m v) := by
  simp only [matrixRationalEval, blockRationalEval, sum_apply, map_sum,
    rationalEval_matrix, matrixAmplificationCoordinates_tensorOperator]

theorem blockRationalEval_denom_cancel {n m : ℕ} (D : Coeff n)
    (P : Matrix (Fin m) (Fin m) (Polynomial ℂ)) (q : Polynomial ℂ)
    (hq0 : q ≠ 0) (hq : IsUnit (Polynomial.aeval D q)) :
    (Polynomial.aeval D q ⊗ₖ (1 : Coeff m)) *
      blockRationalEval D (fun i j => (algebraMap _ (RatFunc ℂ)) (P i j) /
        (algebraMap _ (RatFunc ℂ)) q) = blockPolynomialEval D P := by
  unfold blockRationalEval
  rw [Finset.mul_sum, blockPolynomialEval_expansion]
  apply Finset.sum_congr rfl
  intro i _
  rw [Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro j _
  rw [← Matrix.mul_kronecker_mul, one_mul]
  rw [rationalBaseMatrix, Realization.aeval_quotient_cancel D (P i j) q hq0 hq]

end CrouzeixHilbert

end

end OAI