import Mathlib
import OAI.Probability.BinarySweep.Mixing.BinaryContraction

namespace OAI

noncomputable section

section

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps.Young
variable (μ : YoungDiagram)

def longRowCells : Fin (μ.rowLen 0-μ.rowLen 1) ↪ Cell μ where
  toFun j := ⟨(0,μ.rowLen 1+j.val),YoungDiagram.mem_iff_lt_rowLen.mpr (by
    have hj := j.isLt
    have hm := μ.rowLen_anti 0 1 (by omega)
    omega)⟩
  inj' i j := by
    intro he
    apply Fin.ext
    have hh := congrArg (fun x : Cell μ => x.val.2) he
    dsimp at hh
    omega

lemma longRowCells_fixed (c : C μ) (j : Fin (μ.rowLen 0-μ.rowLen 1)) :
    c.val (longRowCells μ j)=longRowCells μ j := by
  have hc := c.property (longRowCells μ j)
  have hm := YoungDiagram.mem_iff_lt_rowLen.mp (c.val (longRowCells μ j)).property
  have hr : row (c.val (longRowCells μ j))=0 := by
    by_contra hne
    have ha := μ.rowLen_anti 1 (row (c.val (longRowCells μ j))) (by omega)
    change col (c.val (longRowCells μ j)) < μ.rowLen (row (c.val (longRowCells μ j))) at hm
    change col (c.val (longRowCells μ j))=μ.rowLen 1+j.val at hc
    omega
  apply Subtype.ext
  exact Prod.ext hr hc

theorem long_row_dimension (hrow : 0<μ.rowLen 1) :
    μ.rowLen 0-μ.rowLen 1 ≤ Module.finrank ℂ (SpechtSpace μ) := by
  let a : Cell μ := ⟨(1,0),YoungDiagram.mem_iff_lt_rowLen.mpr hrow⟩
  have hh := singleton_column_dimension μ a (by change (1:ℕ)≠0; omega)
    (longRowCells μ) (fun _ => rfl) (longRowCells_fixed μ)
  simpa only [Fintype.card_fin] using hh

end BinaryCoordinateSweeps.Young

end

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps.Young

def flatTail (μ : YoungDiagram) : ℕ := μ.card-max (μ.colLen 0) (μ.rowLen 0)
def longOriented (μ : YoungDiagram) : YoungDiagram :=
  if μ.colLen 0 ≤ μ.rowLen 0 then μ else μ.transpose

lemma transpose_card (μ : YoungDiagram) : μ.transpose.card=μ.card := by
  simp

lemma rowLens_sum (μ : YoungDiagram) : μ.rowLens.sum=μ.card := by
  have h := card_cellsOfRowLens μ.rowLens
  change (YoungDiagram.ofRowLens μ.rowLens μ.rowLens_sorted).card=_ at h
  rw [YoungDiagram.ofRowLens_to_rowLens_eq_self] at h
  exact h.symm

lemma rowLens_head (μ : YoungDiagram) : μ.rowLens.headD 0=μ.rowLen 0 := by
  by_cases h : μ.colLen 0=0
  · have hr : μ.rowLen 0=0 := by
      by_contra hn
      have hm : (0,0)∈μ := YoungDiagram.mem_iff_lt_rowLen.mpr (by omega)
      have hc := YoungDiagram.mem_iff_lt_colLen.mp hm
      omega
    simp [YoungDiagram.rowLens,h,hr]
  · obtain ⟨a,ha⟩ : ∃a, μ.colLen 0=a+1 := ⟨μ.colLen 0-1,by omega⟩
    simp [YoungDiagram.rowLens,ha,List.range_succ_eq_map]

lemma rowLens_tail_sum (μ : YoungDiagram) : μ.rowLens.tail.sum=μ.card-μ.rowLen 0 := by
  have hh : μ.rowLens.headD 0+μ.rowLens.tail.sum=μ.rowLens.sum := by
    cases μ.rowLens <;> simp
  rw [rowLens_head,rowLens_sum] at hh
  omega

lemma longOriented_card (μ : YoungDiagram) : (longOriented μ).card=μ.card := by
  unfold longOriented
  split <;> simp_all

lemma longOriented_row (μ : YoungDiagram) :
    (longOriented μ).rowLen 0=max (μ.colLen 0) (μ.rowLen 0) := by
  unfold longOriented
  split <;> simp_all [YoungDiagram.rowLen_transpose,Nat.le_of_lt]

lemma positive_list_tail_injective {a b : List ℕ}
    (ha : ∀x∈a,0<x) (hb : ∀x∈b,0<x)
    (hs : a.sum=b.sum) (ht : a.tail=b.tail) : a=b := by
  cases a with
  | nil =>
    cases b with
    | nil => rfl
    | cons x b =>
      have hh := hb x (by simp)
      simp only [List.sum_nil,List.sum_cons] at hs
      omega
  | cons x a =>
    cases b with
    | nil =>
      have hh := ha x (by simp)
      simp only [List.sum_nil,List.sum_cons] at hs
      omega
    | cons y b =>
      simp only [List.tail_cons] at ht
      subst b
      simp only [List.sum_cons] at hs
      have he : x=y := by omega
      subst y
      rfl

def tailCode {n k : ℕ} (p : {p : n.Partition // flatTail (diagram p)=k}) :
    Bool × Composition k :=
  (decide ((diagram p.val).colLen 0 ≤ (diagram p.val).rowLen 0),
    ⟨(longOriented (diagram p.val)).rowLens.tail,
      fun {i} hi => YoungDiagram.pos_of_mem_rowLens _ _ (List.mem_of_mem_tail hi),by
        rw [rowLens_tail_sum,longOriented_card,longOriented_row]
        exact p.property⟩)

lemma tailCode_injective {n k : ℕ} : Function.Injective (tailCode (n:=n) (k:=k)) := by
  intro p q he
  have ho : longOriented (diagram p.val)=longOriented (diagram q.val) := by
    apply YoungDiagram.equivListRowLens.injective
    apply Subtype.ext
    apply positive_list_tail_injective (YoungDiagram.pos_of_mem_rowLens _) (YoungDiagram.pos_of_mem_rowLens _)
    · rw [rowLens_sum,rowLens_sum,longOriented_card,longOriented_card,diagram_card,diagram_card]
    · exact congrArg (fun c : Bool × Composition k => c.2.blocks) he
  have hb := congrArg Prod.fst he
  change decide ((diagram p.val).colLen 0 ≤ (diagram p.val).rowLen 0)=
    decide ((diagram q.val).colLen 0 ≤ (diagram q.val).rowLen 0) at hb
  have hi := of_decide_eq_true (show decide (((diagram p.val).colLen 0 ≤ (diagram p.val).rowLen 0) ↔
    ((diagram q.val).colLen 0 ≤ (diagram q.val).rowLen 0))=true from by simp [hb])
  apply Subtype.ext
  apply diagram_injective
  unfold longOriented at ho
  by_cases hp : (diagram p.val).colLen 0 ≤ (diagram p.val).rowLen 0
  · simpa [hp,hi.mp hp] using ho
  · have hq : ¬(diagram q.val).colLen 0 ≤ (diagram q.val).rowLen 0 := fun hh => hp (hi.mpr hh)
    have hh := congrArg YoungDiagram.transpose ho
    simpa [hp,hq] using hh

theorem flatTail_card (n k : ℕ) :
    Fintype.card {p : n.Partition // flatTail (diagram p)=k} ≤ 2*2^k := by
  have h := Fintype.card_le_of_injective (tailCode (n:=n) (k:=k)) tailCode_injective
  simp only [Fintype.card_prod,Fintype.card_bool,composition_card] at h
  exact h.trans (Nat.mul_le_mul_left 2 (Nat.pow_le_pow_right (by omega) (by omega)))

end BinaryCoordinateSweeps.Young

end

end OAI