import Mathlib
import OAI.RepresentationTheory.Saxl.Main
import OAI.RepresentationTheory.UniversalSquare.Balance.BalanceLeaves
import OAI.RepresentationTheory.UniversalSquare.Balance.BalanceLift

namespace OAI

/-! Balance Packing. -/

section

noncomputable section
open scoped TensorProduct
namespace Saxl.Balance

structure Packing {n d e : ℕ} (v : WordSpace n d)
    (A : Fin (d*d) → Prop) (label : Fin (d*d) → ℕ) (w : WordSpace n e) where
  G : Type
  [groupG : Group G]
  [finiteG : Finite G]
  Y : Type
  [addY : AddCommGroup Y]
  [moduleY : Module ℂ Y]
  [finiteY : FiniteDimensional ℂ Y]
  c : Fin n → ℕ
  σ : ℕ → ℤ
  φ : G →* fiberGroup c
  τ : Representation ℂ G Y
  piece : Piece v c A label σ φ τ
  support : SupportLE (cyclic (wordRep n e) w).toRepresentation
    (Representation.coind ((fiberGroup c).subtype.comp φ) τ)

attribute [instance] Packing.groupG Packing.finiteG Packing.addY Packing.moduleY Packing.finiteY

def Packing.join {n a b d E : ℕ} {v : WordSpace a d} {u : WordSpace b d}
    {A : Fin (d*d) → Prop} {label : Fin (d*d) → ℕ}
    {w : WordSpace a E} {z : WordSpace b E}
    (P : Packing v A label w) (Q : Packing u A label z)
    (e : Fin n ≃ Fin a ⊕ Fin b) (hd : ∀ i j, P.c i ≠ Q.c j) :
    Packing (positionProduct e v u) A label (positionProduct e w z) := by
  letI : AddCommGroup (P.Y ⊗[ℂ] Q.Y) := Module.addCommMonoidToAddCommGroup ℂ
  exact {
    G := P.G × Q.G
    Y := P.Y ⊗[ℂ] Q.Y
    c := joinedLabels e P.c Q.c
    σ := P.σ + Q.σ
    φ := (joinedFiberHom e P.c Q.c).comp (P.φ.prodMap Q.φ)
    τ := outer P.τ Q.τ
    piece := P.piece.join Q.piece e hd
    support := product_supportLE_coind
      ((fiberGroup P.c).subtype.comp P.φ) ((fiberGroup Q.c).subtype.comp Q.φ)
      P.τ Q.τ e w z P.support Q.support }

def Packing.map {n d e E : ℕ} {v : WordSpace n d}
    {A : Fin (d*d) → Prop} {label : Fin (d*d) → ℕ} {w : WordSpace n e}
    (P : Packing v A label w)
    (T : Representation.IntertwiningMap (wordRep n e) (wordRep n E)) :
    Packing v A label (T w) :=
  { P with support := P.support.cyclic_image w T }

def Packing.lift {n d D e : ℕ} {v : WordSpace n d} {w : WordSpace n e}
    (f : Fin d → Fin D) (hf : ∀ a, (f a).val = a.val)
    (A : Fin (D*D) → Prop) (label : Fin (D*D) → ℕ)
    (P : Packing v (A ∘ pairLetterMap f f) (label ∘ pairLetterMap f f) w) :
    Packing (letterLift f v) A label w :=
  { P with piece := P.piece.lift f hf A label }

def Packing.replace {n d e E : ℕ} {v : WordSpace n d}
    {A : Fin (d*d) → Prop} {label : Fin (d*d) → ℕ}
    {w : WordSpace n e} (P : Packing v A label w) (z : WordSpace n E)
    (h : SupportLE (cyclic (wordRep n E) z).toRepresentation
      (cyclic (wordRep n e) w).toRepresentation) : Packing v A label z :=
  { P with support := h.trans P.support }

def boundedPacking {n e : ℕ} {μ : YoungDiagram} (t : Tableau n μ)
    (k : ℕ) (I : Set ℕ)
    (A : Fin (μ.colLen 0 * μ.colLen 0) → Prop)
    (label : Fin (μ.colLen 0 * μ.colLen 0) → ℕ)
    (h : ∀ a, (A a ∧ label a = k) ↔ output a ∈ I)
    (hs : SupportLE (wordRep n e)
      (projectedSpechtTensor t t (inOutputs I) (inOutputs_invariant I)).toRepresentation)
    (w : WordSpace n e) : Packing (polytabloid t) A label w := by
  let W := projectedSpechtTensor t t (inOutputs I) (inOutputs_invariant I)
  let φ := (fiberGroup (fun _ : Fin n => k)).subtype.comp (singleFiberHom n k)
  have hi : Function.Injective (coindLift (ρ := W.toRepresentation) φ (Representation.IntertwiningMap.id W.toRepresentation)) := by
    intro x y hxy
    have he := congrArg (fun z : Representation.coindV φ W.toRepresentation => z.val 1) hxy
    change W.toRepresentation 1 x = W.toRepresentation 1 y at he
    simpa only [map_one,Module.End.one_apply] using he
  refine {
    G := Equiv.Perm (Fin n)
    Y := W.toSubmodule
    c := fun _ => k
    σ := columnOutputSums t (fun _ => k)
    φ := singleFiberHom n k
    τ := W.toRepresentation
    piece := projectedPiece t k I A label h
    support := ?_ }
  exact ((SupportLE.of_injective (subrepInclusion (cyclic (wordRep n e) w))
    Subtype.val_injective).trans hs).trans (SupportLE.of_injective _ hi)

theorem Packing.kronecker_pos {n : ℕ} {lam μ θ : YoungDiagram}
    (a : Tableau n lam) (t : Tableau n μ)
    {A : Fin (lam.colLen 0 * lam.colLen 0) → Prop}
    {label : Fin (lam.colLen 0 * lam.colLen 0) → ℕ}
    (w : Fin n → Fin (θ.colLen 0))
    (P : Packing (polytabloid a) A label (Pi.single w 1))
    (ho : ∀ x y, A x → A y → label x < label y → output x < output y)
    (hc : μ.card = θ.card) (hd : Dominates μ θ)
    (e : Equiv.Perm (Fin (θ.colLen 0)))
    (hw : ∀ j, (Finset.univ.filter (fun i => w i = e j)).card = θ.rowLen j) :
    0 < kronecker a a t :=
  P.piece.kronecker_pos a t ho θ hc hd w e hw P.support

end Saxl.Balance
end
end

end OAI