import Mathlib
import OAI.RepresentationTheory.Saxl.Main
import OAI.RepresentationTheory.UniversalSquare.Contraction.CompactDomainsCore
import OAI.RepresentationTheory.UniversalSquare.Specht.FinitePieri
import OAI.RepresentationTheory.UniversalSquare.Support.NumericalSupport

namespace OAI

/-! Row Square Tools. -/

section

noncomputable section
open scoped TensorProduct
namespace UniversalTensorSquare
open Saxl Saxl.Columns Saxl.Balance

abbrev RowSquare (p q : List ℕ) : Prop := SquareOccurs (rowDiagram p) (rowDiagram q)

lemma columnShape_transposeRows {p : List ℕ} (hp : GoodRows p) :
    columnShape (transposeRows p) = rowDiagram p := by
  rw [transposeRows_eq hp,columnShape_diagram]

lemma rowSquare_transpose {p q : List ℕ} (hp : GoodRows p)
    (h : RowSquare p q) : RowSquare (transposeRows p) q := by
  change SquareOccurs (rowDiagram (transposeRows p)) (rowDiagram q)
  rw [rowDiagram_transposeRows hp]
  exact h.input_transpose

lemma rowSquare_target_transpose {p q : List ℕ} (hp : GoodRows p) (hq : GoodRows q)
    (hs : transposeRows p = p) (h : RowSquare p q) : RowSquare p (transposeRows q) := by
  change SquareOccurs (rowDiagram p) (rowDiagram (transposeRows q))
  rw [rowDiagram_transposeRows hq]
  have ht : (rowDiagram p).transpose = rowDiagram p := by
    rw [← rowDiagram_transposeRows hp,hs]
  exact h.target_transpose ht

def RowJoin (p q x y a b : List ℕ) : Prop :=
  GoodRows p ∧ GoodRows q ∧ GoodRows x ∧ GoodRows y ∧ GoodRows a ∧ GoodRows b ∧
  ((transposeRows x ++ transposeRows y).Perm (transposeRows p) ∨
    (transposeRows x ++ transposeRows y).Perm p) ∧
  ((transposeRows a ++ transposeRows b).Perm (transposeRows q) ∨
    (transposeRows p = p ∧ (transposeRows a ++ transposeRows b).Perm q))
instance (p q x y a b : List ℕ) : Decidable (RowJoin p q x y a b) := by
  unfold RowJoin; infer_instance

lemma rowSquare_join {p q x y a b : List ℕ} (hc : RowJoin p q x y a b)
    (h : RowSquare x a) (h' : RowSquare y b) : RowSquare p q := by
  obtain ⟨hp,hq,hx,hy,ha,hb,hp',hq'⟩ := hc
  unfold RowSquare at h h' ⊢
  rw [← columnShape_transposeRows hx,← columnShape_transposeRows ha] at h
  rw [← columnShape_transposeRows hy,← columnShape_transposeRows hb] at h'
  have hh := h.append h'
  have ht : SquareOccurs (rowDiagram p)
      (columnShape (transposeRows a ++ transposeRows b)) := by
    rcases hp' with hp' | hp'
    · simpa only [columnShape_perm hp',columnShape_transposeRows hp] using hh
    · rw [columnShape_perm hp'] at hh
      exact hh.input_transpose
  rcases hq' with hq' | ⟨hs,hq'⟩
  · simpa only [columnShape_perm hq',columnShape_transposeRows hq] using ht
  · rw [columnShape_perm hq'] at ht
    have hself : (rowDiagram p).transpose = rowDiagram p := by
      rw [← rowDiagram_transposeRows hp,hs]
    exact ht.target_transpose hself

lemma rowSquare_of_cols {p q cs : List ℕ} (hp : GoodRows p) (hq : GoodRows q)
    (he : cs = transposeRows p ∨ cs = p)
    (h : SquareOccurs (columnShape cs) (columnShape (transposeRows q))) : RowSquare p q := by
  rw [columnShape_transposeRows hq] at h
  rcases he with rfl | rfl
  · simpa only [columnShape_transposeRows hp] using h
  · exact h.input_transpose

lemma rowSquare_domain {n : ℕ} {p q cs ts : List ℕ}
    (hp : GoodRows p) (hq : GoodRows q) (hcs : GoodRows cs) (hts : GoodRows ts)
    (he : cs = transposeRows p ∨ cs = p) (ht : ts = transposeRows q)
    (hn : cs.sum = n) (hn' : ts.sum = n)
    (eb : Fin n ≃ Fin cs.sum) (et : Fin n ≃ Fin ts.sum)
    (flag : Finset (ℕ × ℕ × ℕ))
    (hcert : solveDomains n (.full ts) (.full cs) (.full cs)
      (certificateEdges cs cs ts (finCongr hn.symm) eb et) flag ≠ 0) : RowSquare p q := by
  have hc : (columnShape cs).transpose.rowLens = cs := by
    rw [columnShape_sorted cs hcs.1 hcs.2,YoungDiagram.transpose_transpose,
      YoungDiagram.rowLens_ofRowLens_eq_self hcs.2]
  have hd : (columnShape ts).transpose.rowLens = ts := by
    rw [columnShape_sorted ts hts.1 hts.2,YoungDiagram.transpose_transpose,
      YoungDiagram.rowLens_ofRowLens_eq_self hts.2]
  let a := canonicalTableau (columnShape cs) ((columnShape_card _).trans hn)
  let t := canonicalTableau (columnShape ts) ((columnShape_card _).trans hn')
  apply rowSquare_of_cols hp hq he
  rw [← ht]
  refine ⟨n,a,t,kronecker_pos_of_integer_certificate a a t cs cs ts hc hc hd
    (finCongr hn.symm) eb et (fun r a b => if (r,a,b) ∈ flag then 1 else 0) ?_⟩
  rwa [contractionInteger_solve]

lemma kronecker_pos_of_projected {n : ℕ} {α μ : YoungDiagram}
    (a : Tableau n α) (t : Tableau n μ)
    (P : (Fin n → Fin (α.colLen 0 * α.colLen 0)) → Prop)
    (hP : ∀ (g : Equiv.Perm (Fin n)) w, P (w ∘ g) ↔ P w)
    (F : Representation.IntertwiningMap (spechtRep t)
      (projectedSpechtTensor a a P hP).toRepresentation) (hF : F ≠ 0) :
    0 < kronecker a a t := by
  let : AddCommGroup (Specht a ⊗[ℂ] Specht a) := Module.addCommMonoidToAddCommGroup ℂ
  obtain ⟨Z,hZ⟩ := subrepresentation_embeds_of_le_range
    ((invariantCoordinateProjection P hP).comp (spechtTensorMap a a))
    (projectedSpechtTensor a a P hP) le_rfl
  exact (kronecker_pos_iff a a t).mpr ⟨Z.comp F,intertwining_comp_ne_zero Z hZ F hF⟩

lemma rowSquare_short {p rs : List ℕ} (q δ : ℕ)
    (hp : GoodRows p) (hr : GoodRows rs) (hq : 0 < q) (hδ : δ = 1 ∨ δ = 2)
    (he : [q+δ,q] = transposeRows p ∨ [q+δ,q] = p)
    (hrl : rs.length ≤ 4) (hrs : rs.sum = 2*q+δ)
    (ho : δ = 2 → ∃ j ∈ List.range (rs.sum+1),
      rs.countP (fun x => decide (j < x)) % 2 = 1) : RowSquare p rs := by
  have hs : GoodRows [q+δ,q] := by
    constructor
    · apply List.Pairwise.sortedGE; simp
    · simp; omega
  have hc : columnShape [q+δ,q] = (ShortColumns.shape q δ).transpose := by
    rw [columnShape_sorted _ hs.1 hs.2]; rfl
  let a := canonicalTableau (columnShape [q+δ,q])
    (show (columnShape [q+δ,q]).card = 2*q+δ by rw [columnShape_card]; simp; omega)
  let t := canonicalTableau (rowDiagram rs) ((rowDiagram_card _).trans hrs)
  have ha := a
  rw [hc] at ha
  obtain ⟨F,hF⟩ := short_pair_support q δ rfl hδ ha (rowDiagram rs) t
    (by rwa [rowDiagram_height hr]) (by
      intro hd
      obtain ⟨j,_,hj⟩ := ho hd
      exact ⟨j,by simpa only [rowDiagram,YoungDiagram.colLen_transpose,columnShape_rowLen] using hj⟩)
  have hh := kronecker_pos_of_projected ha t _ _ F hF
  apply rowSquare_of_cols hp hr he
  rw [columnShape_transposeRows hr,hc]
  exact ⟨2*q+δ,ha,t,hh⟩

lemma rowSquare_even {p rs : List ℕ} (m : ℕ)
    (hp : GoodRows p) (hr : GoodRows rs) (hm : 0 < m)
    (he : p = [m,m] ∨ transposeRows p = [m,m])
    (hrl : rs.length ≤ 4) (hrs : rs.sum = 2*m) (heven : ∀ r ∈ rs, Even r) :
    RowSquare p rs := by
  let t := canonicalTableau (rowDiagram rs) ((rowDiagram_card _).trans hrs)
  have hev (i : ℕ) : Even ((rowDiagram rs).rowLen i) := by
    rw [rowDiagram_rowLen hr]
    cases h : rs[i]? with
    | none => simp
    | some a => exact heven a (List.mem_of_getElem? h)
  obtain ⟨F,hF⟩ := ShortColumns.even_columnSquare_support m (rowDiagram rs) t hev
    (by rwa [rowDiagram_height hr])
  let a := ShortColumns.evenTableau m
  let : AddCommGroup (Specht a ⊗[ℂ] Specht a) := Module.addCommMonoidToAddCommGroup ℂ
  obtain ⟨Z,hZ⟩ := subrepresentation_embeds_of_le_range (spechtTensorMap a a)
    (columnSquareCyclic a) (polytabloidTensor_cyclic_le_range a a a a)
  have hh : SquareOccurs (ShortColumns.shape m 0) (rowDiagram rs) :=
    ⟨2*m,a,t,(kronecker_pos_iff a a t).mpr
      ⟨Z.comp F,intertwining_comp_ne_zero Z hZ F hF⟩⟩
  have hrows : GoodRows [m,m] := by
    constructor
    · apply List.Pairwise.sortedGE; simp
    · simp; omega
  have hshape : ShortColumns.shape m 0 = rowDiagram [m,m] := by
    rw [rowDiagram_eq _ hrows]; rfl
  rw [hshape] at hh
  rcases he with rfl | he
  · exact hh
  · rw [← he,rowDiagram_transposeRows hp] at hh
    simpa only [YoungDiagram.transpose_transpose] using hh.input_transpose

lemma rowSquare_trivial (p : List ℕ) (hn : 0 < p.sum) : RowSquare p [p.sum] := by
  have hgood : GoodRows [p.sum] := ⟨by apply List.Pairwise.sortedGE; simp,by simpa using hn⟩
  let a := canonicalTableau (rowDiagram p) (rowDiagram_card p)
  let t := canonicalTableau (rowDiagram [p.sum]) (by simpa using rowDiagram_card [p.sum])
  have height : (rowDiagram [p.sum]).colLen 0 = 1 := by rw [rowDiagram_height hgood]; rfl
  let f : Fin ((rowDiagram p).colLen 0) → Fin ((rowDiagram [p.sum]).colLen 0) :=
    fun _ => ⟨0,by omega⟩
  refine ⟨p.sum,a,t,kronecker_pos_of_column_content a t (rowDiagram [p.sum]) rfl
    (fun _ => le_rfl) f ?_⟩
  intro j
  have hj : j.val = 0 := by have := j.isLt; omega
  have heq (i : Fin p.sum) : f (columnLengthWord a i) = j := Fin.ext hj.symm
  simp only [heq,Finset.filter_true,Finset.card_univ,Fintype.card_fin,
    rowDiagram_rowLen hgood,hj]
  rfl

end UniversalTensorSquare
end
end

end OAI