import OAI.LinearAlgebra.MatrixMultiplication.Polynomial.ComplexPolynomialWitnessProduct
import OAI.LinearAlgebra.MatrixMultiplication.Polynomial.ComplexPolynomialExecutionSymmetry

namespace OAI

/-! Finite coefficient tensors and their algebraic transformations. -/

noncomputable section

namespace MatrixMultiplication.MatrixBalancing

open MatrixMultiplication.Foundation
open MatrixMultiplication.Foundation.Tensor

variable {K X Y Z : Type*} [Field K]
variable {r d D : ℕ}

def swapXYApproximation {T : Tensor K X Y Z}
    (P : PolynomialApproximation T r d D) :
    PolynomialApproximation (Tensor.swapXY T) r d D where
  polynomial := Tensor.swapXY P.polynomial
  rank_bound := P.rank_bound.swapXY
  vanishes := fun y x z k hk => P.vanishes x y z k hk
  leading := fun y x z => P.leading x y z
  degree_bound := fun y x z => P.degree_bound x y z

private theorem swapXY_directSum {ι : Type*} [DecidableEq ι]
    (T : ι → Tensor K X Y Z) :
    Tensor.swapXY (Tensor.directSum T) =
      Tensor.directSum (fun i => Tensor.swapXY (T i)) := by
  funext x y z
  have hguard : (y.1 = x.1 ∧ y.1 = z.1) ↔ (x.1 = y.1 ∧ x.1 = z.1) := by
    constructor
    · rintro ⟨hyx, hyz⟩
      exact ⟨hyx.symm, hyx.symm.trans hyz⟩
    · rintro ⟨hxy, hxz⟩
      exact ⟨hxy.symm, hxy.symm.trans hxz⟩
  simp only [Tensor.swapXY, Tensor.directSum, hguard]
  split_ifs with h
  · rw [h.1]
  · rfl

def directSum_swapXY {ι : Type*} [DecidableEq ι]
    {T : ι → Tensor K X Y Z}
    (P : PolynomialApproximation (Tensor.directSum T) r d D) :
    PolynomialApproximation (Tensor.directSum (fun i => Tensor.swapXY (T i))) r d D := by
  simpa only [swapXY_directSum] using swapXYApproximation P

section Matrix

variable {ι A B C : Type*} [DecidableEq ι]
variable [DecidableEq A] [DecidableEq B] [DecidableEq C]

theorem matrix_swapYZ :
    Tensor.pullback (Prod.swap : B × A → A × B)
      (Prod.swap : A × C → C × A) (Prod.swap : C × B → B × C)
      (Tensor.cyclic (Tensor.swapXY (matrixCoefficients (K := K) A B C))) =
        matrixCoefficients (K := K) B A C := by
  funext x y z
  simp only [Tensor.pullback, Tensor.cyclic, Tensor.swapXY, Prod.swap,
    matrixCoefficients]
  simp only [eq_comm, and_comm, and_left_comm]

theorem matrix_swapXZ :
    Tensor.pullback (Prod.swap : A × C → C × A)
      (Prod.swap : C × B → B × C) (Prod.swap : B × A → A × B)
      (Tensor.swapXY (Tensor.cyclic (matrixCoefficients (K := K) A B C))) =
        matrixCoefficients (K := K) A C B := by
  funext x y z
  simp only [Tensor.pullback, Tensor.cyclic, Tensor.swapXY, Prod.swap,
    matrixCoefficients]
  simp only [eq_comm, and_comm, and_left_comm, and_assoc]

def matrixDirectSum_swapYZ
    (P : PolynomialApproximation
      (Tensor.directSum (fun _ : ι => matrixCoefficients (K := K) A B C)) r d D) :
    PolynomialApproximation
      (Tensor.directSum (fun _ : ι => matrixCoefficients (K := K) B A C)) r d D := by
  have h := (directSum_swapXY P).directSum_cyclic.directSum_pullback
    (Prod.swap : B × A → A × B) (Prod.swap : A × C → C × A)
    (Prod.swap : C × B → B × C)
  simpa only [matrix_swapYZ] using h

def matrixDirectSum_swapXZ
    (P : PolynomialApproximation
      (Tensor.directSum (fun _ : ι => matrixCoefficients (K := K) A B C)) r d D) :
    PolynomialApproximation
      (Tensor.directSum (fun _ : ι => matrixCoefficients (K := K) A C B)) r d D := by
  have h := (directSum_swapXY P.directSum_cyclic).directSum_pullback
    (Prod.swap : A × C → C × A) (Prod.swap : C × B → B × C)
    (Prod.swap : B × A → A × B)
  simpa only [matrix_swapXZ] using h

def matrixDirectSum_reindex {κ A' B' C' : Type*}
    [DecidableEq κ] [DecidableEq A'] [DecidableEq B'] [DecidableEq C']
    (P : PolynomialApproximation
      (Tensor.directSum (fun _ : ι => matrixCoefficients (K := K) A B C)) r d D)
    (e : κ → ι) (he : Function.Injective e)
    (f : A' → A) (hf : Function.Injective f)
    (g : B' → B) (hg : Function.Injective g)
    (j : C' → C) (hj : Function.Injective j) :
    PolynomialApproximation
      (Tensor.directSum (fun _ : κ => matrixCoefficients (K := K) A' B' C')) r d D := by
  have h := P.pullback
    (fun x : κ × (A' × B') => (e x.1, (f x.2.1, g x.2.2)))
    (fun y : κ × (B' × C') => (e y.1, (g y.2.1, j y.2.2)))
    (fun z : κ × (C' × A') => (e z.1, (j z.2.1, f z.2.2)))
  convert h using 1
  funext x y z
  simp only [Tensor.pullback, Tensor.directSum, matrixCoefficients,
    he.eq_iff, hf.eq_iff, hg.eq_iff, hj.eq_iff]

def matrixDirectSum_product {κ A' B' C' : Type*}
    [DecidableEq κ] [DecidableEq A'] [DecidableEq B'] [DecidableEq C']
    {s e E : ℕ}
    (P : PolynomialApproximation
      (Tensor.directSum (fun _ : ι => matrixCoefficients (K := K) A B C)) r d D)
    (Q : PolynomialApproximation
      (Tensor.directSum (fun _ : κ => matrixCoefficients (K := K) A' B' C')) s e E) :
    PolynomialApproximation
      (Tensor.directSum (fun _ : ι × κ =>
        matrixCoefficients (K := K) (A × A') (B × B') (C × C')))
      (r * s) (d + e) (D + E) := by
  have h := (P.directSum_product Q).directSum_pullback
    (fun x : (A × A') × (B × B') => ((x.1.1, x.2.1), (x.1.2, x.2.2)))
    (fun y : (B × B') × (C × C') => ((y.1.1, y.2.1), (y.1.2, y.2.2)))
    (fun z : (C × C') × (A × A') => ((z.1.1, z.2.1), (z.1.2, z.2.2)))
  convert h using 1
  funext x y z
  simp only [Tensor.directSum, Tensor.pullback, matrixCoefficients_product]

def matrixDirectSum_balanced
    (P : PolynomialApproximation
      (Tensor.directSum (fun _ : ι => matrixCoefficients (K := K) A B C)) r d D) :
    PolynomialApproximation
      (Tensor.directSum (fun _ : ι × ι =>
        matrixCoefficients (K := K) (A × B) (C × C) (A × B)))
      (r ^ 2) (2 * d) (2 * D) := by
  have h := matrixDirectSum_swapXZ (matrixDirectSum_product P (matrixDirectSum_swapYZ P))
  have h' := matrixDirectSum_reindex h
    (Equiv.refl (ι × ι)) (Equiv.refl _).injective
    (Equiv.refl (A × B)) (Equiv.refl _).injective
    (Equiv.refl (C × C)) (Equiv.refl _).injective
    (Equiv.prodComm A B) (Equiv.prodComm A B).injective
  simpa only [pow_two, two_mul] using h'

end Matrix

def finiteBalanced {L a b c : ℕ}
    (P : PolynomialApproximation
      (Tensor.directSum (fun _ : Fin L =>
        matrixCoefficients (K := K) (Fin a) (Fin b) (Fin c))) r d D) :
    PolynomialApproximation
      (Tensor.directSum (fun _ : Fin (L ^ 2) =>
        matrixCoefficients (K := K) (Fin (a * b)) (Fin (c ^ 2)) (Fin (a * b))))
      (r ^ 2) (2 * d) (2 * D) := by
  let tags : Fin (L ^ 2) ≃ Fin L × Fin L := Fintype.equivOfCardEq (by simp [pow_two])
  let outer : Fin (a * b) ≃ Fin a × Fin b := Fintype.equivOfCardEq (by simp)
  let inner : Fin (c ^ 2) ≃ Fin c × Fin c := Fintype.equivOfCardEq (by simp [pow_two])
  exact matrixDirectSum_reindex (matrixDirectSum_balanced P)
    tags tags.injective outer outer.injective inner inner.injective outer outer.injective

end MatrixMultiplication.MatrixBalancing

end

end OAI