import Mathlib
import OAI.RepresentationTheory.Saxl.Main
import OAI.RepresentationTheory.UniversalSquare.Specht.StandardColumns
import OAI.RepresentationTheory.UniversalSquare.Support.WordContents

namespace OAI

/-! Word Packing. -/

section

noncomputable section
namespace Saxl
open scoped BigOperators

lemma sum_wordContent {n d : ℕ} (w : Fin n → Fin d) :
    ∑ j, wordContent w j = n := by
  classical
  simp only [wordContent,Finset.card_filter]
  rw [Finset.sum_comm]
  simp

lemma single_joinPositions {n a b d : ℕ} (e : Fin n ≃ Fin a ⊕ Fin b)
    (w : Fin a → Fin d) (z : Fin b → Fin d) :
    positionProduct e (Pi.single w 1) (Pi.single z 1) =
      Pi.single ((positionWordsEquiv e).symm (w,z)) 1 := by
  have hl := congrArg Prod.fst ((positionWordsEquiv e).apply_symm_apply (w,z))
  have hr := congrArg Prod.snd ((positionWordsEquiv e).apply_symm_apply (w,z))
  change leftWord e ((positionWordsEquiv e).symm (w,z)) = w at hl
  change rightWord e ((positionWordsEquiv e).symm (w,z)) = z at hr
  rw [single_positionProduct e,hl,hr]

namespace Balance
open FlagColumns Columns

def Packing.congr {n d e : ℕ} {v u : WordSpace n d}
    {A : Fin (d*d) → Prop} {label : Fin (d*d) → ℕ} {w z : WordSpace n e}
    (P : Packing v A label w) (hv : v = u) (hw : w = z) : Packing u A label z where
  G := P.G
  Y := P.Y
  c := P.c
  σ := P.σ
  φ := P.φ
  τ := P.τ
  piece := by rw [← hv]; exact P.piece
  support := by rw [← hw]; exact P.support

structure WordPacking (rs ps : List ℕ) (d : ℕ)
    (A : Fin (d*d) → Prop) (label : Fin (d*d) → ℕ) (marks : Finset ℕ) where
  word : Fin rs.sum → Fin ps.length
  counts : ∀ j, wordContent word j = ps.get j
  packing : Packing (blocks rs (standard d)) A label (Pi.single word 1)
  marksBound : ∀ i, packing.c i ∈ marks

lemma WordPacking.total {rs ps : List ℕ} {d : ℕ}
    {A : Fin (d*d) → Prop} {label : Fin (d*d) → ℕ} {marks : Finset ℕ}
    (P : WordPacking rs ps d A label marks) : ps.sum = rs.sum := by
  calc
    ps.sum = ∑ j, ps.get j := by rw [← List.sum_ofFn, List.ofFn_get]
    _ = ∑ j, wordContent P.word j := Finset.sum_congr rfl (fun j _ => (P.counts j).symm)
    _ = rs.sum := sum_wordContent P.word

def WordPacking.join {rs ss ps qs : List ℕ} {d : ℕ}
    {A : Fin (d*d) → Prop} {label : Fin (d*d) → ℕ} {marks marks' : Finset ℕ}
    (P : WordPacking rs ps d A label marks) (Q : WordPacking ss qs d A label marks')
    (hdis : Disjoint marks marks') : WordPacking (rs++ss) (ps++qs) d A label (marks ∪ marks') := by
  classical
  let e := appendPositions rs ss
  let f := appendLetters ps qs
  let wi := f.symm ∘ Sum.inl ∘ P.word
  let zi := f.symm ∘ Sum.inr ∘ Q.word
  let P' := P.packing.map (letterLift (f.symm ∘ Sum.inl))
  let Q' := Q.packing.map (letterLift (f.symm ∘ Sum.inr))
  have hd : ∀ i j, P'.c i ≠ Q'.c j := by
    intro i j hij
    have h₁ := P.marksBound i
    have h₂ := Q.marksBound j
    change P.packing.c i = Q.packing.c j at hij
    rw [← hij] at h₂
    exact Finset.disjoint_left.mp hdis h₁ h₂
  let R := P'.join Q' e hd
  have hv : positionProduct e (blocks rs (standard d)) (blocks ss (standard d)) =
      blocks (rs++ss) (standard d) := (blocks_append rs ss _).symm
  have hw : positionProduct e (letterLift (f.symm ∘ Sum.inl) (Pi.single P.word 1))
      (letterLift (f.symm ∘ Sum.inr) (Pi.single Q.word 1)) =
      Pi.single ((positionWordsEquiv e).symm (wi,zi)) 1 := by
    rw [letterLift_single,letterLift_single,single_joinPositions]
    rfl
  refine {
    word := (positionWordsEquiv e).symm (wi,zi)
    counts := ?_
    packing := R.congr hv hw
    marksBound := ?_ }
  · intro j
    change wordContent ((positionWordsEquiv e).symm
      ((fun i => f.symm (Sum.inl (P.word i))), (fun i => f.symm (Sum.inr (Q.word i))))) j = _
    rw [wordContent_position_join e f P.word Q.word j, get_appendLetters]
    rcases h : f j with j | j
    · exact P.counts j
    · exact Q.counts j
  · intro i
    change joinedLabels e P.packing.c Q.packing.c i ∈ marks ∪ marks'
    unfold joinedLabels
    rcases e i with i | i
    · exact Finset.mem_union_left _ (P.marksBound i)
    · exact Finset.mem_union_right _ (Q.marksBound i)

def WordPacking.sorted {rs ps : List ℕ} {d : ℕ}
    {A : Fin (d*d) → Prop} {label : Fin (d*d) → ℕ} {marks : Finset ℕ}
    (P : WordPacking rs ps d A label marks) (hp : ∀ p ∈ ps, 0 < p) :
    WordPacking rs (columnShape ps).transpose.rowLens d A label marks := by
  classical
  let q := Classical.choose (list_get_equiv (columnShape_rows_permutation ps hp))
  have hq := Classical.choose_spec (list_get_equiv (columnShape_rows_permutation ps hp))
  refine {
    word := q ∘ P.word
    counts := ?_
    packing := (P.packing.map (letterLift q)).congr rfl (letterLift_single q P.word)
    marksBound := P.marksBound }
  intro j
  rw [wordContent_lift_equiv,P.counts,← hq,Equiv.apply_symm_apply]

theorem WordPacking.kronecker_pos {rs ps : List ℕ} {lam μ : YoungDiagram}
    (a : Tableau rs.sum lam) (t : Tableau rs.sum μ)
    {A : Fin (lam.colLen 0 * lam.colLen 0) → Prop}
    {label : Fin (lam.colLen 0 * lam.colLen 0) → ℕ} {marks : Finset ℕ}
    (P : WordPacking rs ps (lam.colLen 0) A label marks)
    (hv : blocks rs (standard (lam.colLen 0)) = polytabloid a)
    (hp : ∀ p ∈ ps, 0 < p)
    (ho : ∀ x y, A x → A y → label x < label y → output x < output y)
    (hd : Dominates μ (columnShape ps).transpose) : 0 < kronecker a a t := by
  let θ := (columnShape ps).transpose
  let Q := P.sorted hp
  let q : Fin θ.rowLens.length ≃ Fin (θ.colLen 0) := finCongr YoungDiagram.length_rowLens
  let w := q ∘ Q.word
  let R := (Q.packing.map (letterLift q)).congr hv (letterLift_single q Q.word)
  apply R.kronecker_pos a t w ho _ hd (Equiv.refl _) _
  · have hc : μ.card = rs.sum := by
      simpa only [Fintype.card_fin,Fintype.card_coe] using (Fintype.card_congr t).symm
    rw [hc, show θ.card = ps.sum from by simp only [θ,transpose_card,columnShape_card]]
    exact P.total.symm
  · intro j
    change wordContent w j = θ.rowLen j
    rw [wordContent_lift_equiv,Q.counts]
    exact YoungDiagram.get_rowLens

end Balance
end Saxl
end
end

end OAI