import Mathlib
import OAI.RepresentationTheory.Saxl.Main
import OAI.RepresentationTheory.UniversalSquare.Contraction.SquareDetection

namespace OAI

/-! Word Relabel. -/

section

noncomputable section
namespace Saxl
open scoped TensorProduct

def relabelWord {n m d : ℕ} (e : Fin n ≃ Fin m) : WordSpace n d ≃ₗ[ℂ] WordSpace m d where
  toFun v := fun w => v (w ∘ e)
  invFun v := fun w => v (w ∘ e.symm)
  left_inv v := by ext w; simp only [Function.comp_assoc, Equiv.symm_comp_self, Function.comp_id]
  right_inv v := by ext w; simp only [Function.comp_assoc, Equiv.self_comp_symm, Function.comp_id]
  map_add' _ _ := rfl
  map_smul' _ _ := rfl

@[simp] lemma relabelWord_apply {n m d : ℕ} (e : Fin n ≃ Fin m)
    (v : WordSpace n d) (w : Fin m → Fin d) : relabelWord e v w = v (w ∘ e) := rfl

lemma altWord_relabel {n m d : ℕ} {α : Type*} (e : Fin n ≃ Fin m)
    (c : Fin n → α) (a : Fin n → Fin d) :
    relabelWord e (altWord (fiberGroup c) a) =
      altWord (fiberGroup (c ∘ e.symm)) (a ∘ e.symm) := by
  ext w
  exact altWord_fiber_relabel e.symm c a w

lemma relabelWord_letterLift {n m d D : ℕ} (e : Fin n ≃ Fin m) (f : Fin d → Fin D)
    (v : WordSpace n d) : relabelWord e (letterLift f v) = letterLift f (relabelWord e v) := by
  have hnm : n = m := by simpa only [Fintype.card_fin] using Fintype.card_congr e
  subst m
  exact (Representation.IntertwiningMap.isIntertwining _ _ (letterLift f) e v).symm

def pairLetterMap {a b c d : ℕ} (f : Fin a → Fin c) (g : Fin b → Fin d) :
    Fin (a*b) → Fin (c*d) := fun x => finProdFinEquiv (f (finProdFinEquiv.symm x).1,
      g (finProdFinEquiv.symm x).2)

lemma pairLetterMap_injective {a b c d : ℕ} (f : Fin a → Fin c) (g : Fin b → Fin d)
    (hf : Function.Injective f) (hg : Function.Injective g) :
    Function.Injective (pairLetterMap f g) :=
  finProdFinEquiv.injective.comp ((hf.prodMap hg).comp finProdFinEquiv.symm.injective)

lemma letterLift_wordTensor {n a b c d : ℕ} (f : Fin a → Fin c) (g : Fin b → Fin d)
    (x : WordSpace n a) (y : WordSpace n b) :
    letterLift (pairLetterMap f g) (wordTensor n a b (x ⊗ₜ[ℂ] y)) =
      wordTensor n c d (letterLift f x ⊗ₜ[ℂ] letterLift g y) := by
  classical
  conv_lhs => rw [← (Pi.basisFun ℂ (Fin n → Fin a)).sum_repr x,
    ← (Pi.basisFun ℂ (Fin n → Fin b)).sum_repr y]
  conv_rhs => rw [← (Pi.basisFun ℂ (Fin n → Fin a)).sum_repr x,
    ← (Pi.basisFun ℂ (Fin n → Fin b)).sum_repr y]
  simp only [TensorProduct.sum_tmul, TensorProduct.tmul_sum, map_sum, map_smul,
    TensorProduct.smul_tmul, TensorProduct.tmul_smul, Pi.basisFun_apply,
    wordTensor_single, letterLift_single]
  have hm (p : Fin n → Fin a) (q : Fin n → Fin b) :
      pairLetterMap f g ∘ mergeWords p q = mergeWords (f ∘ p) (g ∘ q) := by
    funext i
    simp only [Function.comp_apply, pairLetterMap, mergeWords, Equiv.symm_apply_apply]
  simp only [hm]

lemma wordTensor_positionProduct {n k l a b : ℕ} (e : Fin n ≃ Fin k ⊕ Fin l)
    (x : WordSpace k a) (y : WordSpace l a) (v : WordSpace k b) (w : WordSpace l b) :
    wordTensor n a b (positionProduct e x y ⊗ₜ[ℂ] positionProduct e v w) =
      positionProduct e (wordTensor k a b (x ⊗ₜ[ℂ] v))
        (wordTensor l a b (y ⊗ₜ[ℂ] w)) := by
  ext z
  simp only [wordTensor_tmul, positionProduct]
  change (x (splitLeft (leftWord e z)) * y (splitLeft (rightWord e z))) *
    (v (splitRight (leftWord e z)) * w (splitRight (rightWord e z))) = _
  ring

lemma relabelWord_wordTensor {n m a b : ℕ} (e : Fin n ≃ Fin m)
    (x : WordSpace n a) (y : WordSpace n b) :
    relabelWord e (wordTensor n a b (x ⊗ₜ[ℂ] y)) =
      wordTensor m a b (relabelWord e x ⊗ₜ[ℂ] relabelWord e y) := by
  ext z
  rfl

lemma coordinateProjection_wordTensor {n a b : ℕ}
    (P : (Fin n → Fin a) → Prop) (Q : (Fin n → Fin b) → Prop)
    (x : WordSpace n a) (y : WordSpace n b) :
    coordinateProjection (fun w => P (splitLeft w) ∧ Q (splitRight w))
        (wordTensor n a b (x ⊗ₜ[ℂ] y)) =
      wordTensor n a b (coordinateProjection P x ⊗ₜ[ℂ] coordinateProjection Q y) := by
  classical
  ext w
  simp only [coordinateProjection_apply, wordTensor_tmul]
  by_cases hp : P (splitLeft w) <;> by_cases hq : Q (splitRight w) <;> simp [hp,hq]

end Saxl
end
end

end OAI