import Mathlib
import OAI.Probability.BinarySweep.TensorBounds.SignedBlock

namespace OAI

noncomputable section

section

open scoped BigOperators Classical ComplexOrder
open Matrix

namespace BinaryCoordinateSweeps.Signed
open Density Irrep Representation

variable {A : Type*} [Fintype A] [DecidableEq A] {n : ℕ}

lemma actionMatrix_mul (p : A → Bool) (g h : Equiv.Perm (Fin n)) :
    actionMatrix p (g*h)=actionMatrix p g*actionMatrix p h := by
  change LinearMap.toMatrix' ((tensorRep p n) (g*h))=_
  rw [map_mul]
  exact LinearMap.toMatrix'_comp _ _

lemma actionMatrix_one (p : A → Bool) : actionMatrix (n:=n) p 1=1 := by
  change LinearMap.toMatrix' ((tensorRep p n) 1)=_
  rw [map_one]
  exact LinearMap.toMatrix'_id

lemma actionMatrix_inv (p : A → Bool) (g : Equiv.Perm (Fin n)) :
    actionMatrix p g⁻¹=(actionMatrix p g).conjTranspose := by
  calc
    _ = actionMatrix p g⁻¹*(actionMatrix p g*(actionMatrix p g).conjTranspose) := by
      rw [actionMatrix_unitary,mul_one]
    _ = _ := by rw [← mul_assoc,← actionMatrix_mul,inv_mul_cancel,actionMatrix_one,one_mul]

def signedConj (p : A → Bool) (g : Equiv.Perm (Fin n))
    (M : Matrix (Fin n → A) (Fin n → A) ℂ) :=
  actionMatrix p g*M*(actionMatrix p g).conjTranspose

lemma signedConj_mul (p : A → Bool) (g : Equiv.Perm (Fin n))
    (M L : Matrix (Fin n → A) (Fin n → A) ℂ) :
    signedConj p g (M*L)=signedConj p g M*signedConj p g L := by
  unfold signedConj
  simp only [mul_assoc,← mul_assoc (actionMatrix p g).conjTranspose (actionMatrix p g),
    actionMatrix_star_mul,one_mul]

lemma signedConj_psd (p : A → Bool) (g : Equiv.Perm (Fin n))
    (M : Matrix (Fin n → A) (Fin n → A) ℂ) (hM : M.PosSemidef) :
    (signedConj p g M).PosSemidef := hM.mul_mul_conjTranspose_same _

lemma signedConj_fixed (p : A → Bool) (g : Equiv.Perm (Fin n))
    (M : Matrix (Fin n → A) (Fin n → A) ℂ)
    (hc : M*actionMatrix p g=actionMatrix p g*M) : signedConj p g M=M := by
  unfold signedConj
  rw [← hc,mul_assoc,actionMatrix_unitary,mul_one]

lemma signedConj_commutes (p : A → Bool) (g : Equiv.Perm (Fin n))
    (M Q : Matrix (Fin n → A) (Fin n → A) ℂ)
    (hc : M*actionMatrix p g=actionMatrix p g*M) (hq : M*Q=Q*M) :
    M*signedConj p g Q=signedConj p g Q*M := by
  rw [← signedConj_fixed p g M hc,← signedConj_mul,← signedConj_mul,hq]

lemma signedConj_sub_smul_sum {U : Type*} [Fintype U] (p : A → Bool) (g : Equiv.Perm (Fin n))
    (c : ℂ) (M : U → Matrix (Fin n → A) (Fin n → A) ℂ)
    (Q : Matrix (Fin n → A) (Fin n → A) ℂ) :
    signedConj p g (c • ∑u, M u-Q)=c • ∑u, signedConj p g (M u)-signedConj p g Q := by
  simp [signedConj,mul_sub,sub_mul,Matrix.mul_sum,Matrix.sum_mul]

end BinaryCoordinateSweeps.Signed

end

open scoped BigOperators Classical Kronecker
open Matrix

namespace BinaryCoordinateSweeps.Density
variable {A B G : Type*} [Fintype A] [DecidableEq A] [Fintype B] [DecidableEq B]

def matrixSlice (M : Matrix (A×B) (A×B) ℂ) (b c : B) : Matrix A A ℂ :=
  fun a a' => M (a,b) (a',c)

omit [DecidableEq A] in
lemma matrixSlice_mul_left (M : Matrix (A×B) (A×B) ℂ) (T : Matrix A A ℂ) (b c : B) :
    matrixSlice ((T ⊗ₖ (1 : Matrix B B ℂ))*M) b c = T*matrixSlice M b c := by
  ext a a'
  simp [matrixSlice,Matrix.mul_apply,Fintype.sum_prod_type,
    Matrix.one_apply,mul_ite,ite_mul]

omit [DecidableEq A] in
lemma matrixSlice_mul_right (M : Matrix (A×B) (A×B) ℂ) (T : Matrix A A ℂ) (b c : B) :
    matrixSlice (M*(T ⊗ₖ (1 : Matrix B B ℂ))) b c = matrixSlice M b c*T := by
  ext a a'
  simp [matrixSlice,Matrix.mul_apply,Fintype.sum_prod_type,
    Matrix.one_apply,mul_ite]

omit [DecidableEq A] in
theorem kronecker_centrality (T : G → Matrix A A ℂ) (P : Matrix A A ℂ)
    (hP : ∀ X : Matrix A A ℂ, (∀ g, X*T g=T g*X) → X*P=P*X)
    (M : Matrix (A×B) (A×B) ℂ)
    (hM : ∀ g, M*(T g ⊗ₖ (1 : Matrix B B ℂ))=(T g ⊗ₖ (1 : Matrix B B ℂ))*M) :
    M*(P ⊗ₖ (1 : Matrix B B ℂ))=(P ⊗ₖ (1 : Matrix B B ℂ))*M := by
  ext ⟨a,b⟩ ⟨a',c⟩
  have hc : ∀ g, matrixSlice M b c*T g=T g*matrixSlice M b c := by
    intro g
    have hh := congrArg (fun X => matrixSlice X b c) (hM g)
    simpa only [matrixSlice_mul_left,matrixSlice_mul_right] using hh
  have hh := hP (matrixSlice M b c) hc
  have he : matrixSlice (M*(P ⊗ₖ (1 : Matrix B B ℂ))) b c =
      matrixSlice ((P ⊗ₖ (1 : Matrix B B ℂ))*M) b c := by
    simpa only [matrixSlice_mul_left,matrixSlice_mul_right] using hh
  exact congrFun (congrFun he a) a'

end BinaryCoordinateSweeps.Density

end

end OAI