import Mathlib
import OAI.Probability.BinarySweep.GridBounds.DiagonalRigidity

namespace OAI

noncomputable section

section

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps.Young
variable (μ : YoungDiagram)

lemma factorial_le_diagonal_dimension (L : ℕ) (hL : ∀ x : Cell μ, diagonal μ x < L) :
    (Fintype.card (Cell μ)).factorial ≤ L^(Fintype.card (Cell μ)) *
      Module.finrank ℂ (SpechtSpace μ) := by
  let f : Cell μ → Fin L := fun x => ⟨diagonal μ x,hL x⟩
  have hf : fiberStabilizer f = diagonalStabilizer μ := by
    ext g
    constructor
    · intro hg x
      exact congrArg Fin.val (hg x)
    · intro hg x
      exact Fin.ext (hg x)
  have hb := factorial_le_colorings_mul_stabilizer f
  rw [Fintype.card_fin, hf, Nat.card_eq_fintype_card] at hb
  exact hb.trans (Nat.mul_le_mul_left _ (diagonal_card_le_dimension μ))

lemma specht_dimension_pos : 0 < Module.finrank ℂ (SpechtSpace μ) :=
  lt_of_lt_of_le (Fintype.card_pos) (diagonal_card_le_dimension μ)

theorem log_dimension_lower_of_diagonal_bound (L : ℕ) (hpos : 0 < L)
    (hk : 0 < Fintype.card (Cell μ)) (hL : ∀ x : Cell μ, diagonal μ x < L) :
    (Fintype.card (Cell μ) : ℝ) *
        (Real.log (Fintype.card (Cell μ)) - Real.log L - 1) ≤
      Real.log (Module.finrank ℂ (SpechtSpace μ)) := by
  let k := Fintype.card (Cell μ)
  let D := Module.finrank ℂ (SpechtSpace μ)
  have hD : (0 : ℝ) < D := by exact_mod_cast specht_dimension_pos μ
  have hLr : (0 : ℝ) < L := by exact_mod_cast hpos
  have hfac : (0 : ℝ) < k.factorial := by positivity
  have hbound : (k.factorial : ℝ) ≤ (L : ℝ)^k * D := by
    exact_mod_cast factorial_le_diagonal_dimension μ L hL
  have hlog := Real.log_le_log hfac hbound
  rw [Real.log_mul (pow_ne_zero _ hLr.ne') hD.ne', Real.log_pow] at hlog
  have hst := Stirling.le_log_factorial_stirling (show k ≠ 0 from hk.ne')
  have hpi : 0 ≤ Real.log (2*Real.pi) := Real.log_nonneg (by linarith [Real.pi_gt_three])
  have hklog : 0 ≤ Real.log k := Real.log_nonneg (by exact_mod_cast hk)
  change (k : ℝ) * (Real.log k - Real.log L - 1) ≤ Real.log D
  nlinarith

lemma diagonal_lt_height_add_width (x : Cell μ) :
    diagonal μ x < μ.colLen 0 + μ.rowLen 0 := by
  have hr : row x < μ.colLen (col x) := YoungDiagram.mem_iff_lt_colLen.mp x.property
  have hc : col x < μ.rowLen (row x) := YoungDiagram.mem_iff_lt_rowLen.mp x.property
  have hr' := μ.colLen_anti 0 (col x) (Nat.zero_le _)
  have hc' := μ.rowLen_anti 0 (row x) (Nat.zero_le _)
  unfold diagonal
  omega

lemma width_add_rectangle_le_card (x : Cell μ) :
    μ.rowLen 0 + row x * (col x+1) ≤ Fintype.card (Cell μ) := by
  let f : Fin (μ.rowLen 0) ⊕ (Fin (row x) × Fin (col x+1)) → Cell μ :=
    Sum.elim (fun a => ⟨(0,a.val), YoungDiagram.mem_iff_lt_rowLen.mpr a.isLt⟩)
      (fun a => ⟨(a.1.val+1,a.2.val), μ.up_left_mem
        (show a.1.val+1 ≤ row x from a.1.isLt)
        (show a.2.val ≤ col x from Nat.le_of_lt_succ a.2.isLt) x.property⟩)
  have hf : Function.Injective f := by
    intro a b he
    have he' := congrArg Subtype.val he
    cases a with
    | inl a =>
      cases b with
      | inl b =>
        have hab : a = b := Fin.ext (congrArg Prod.snd he')
        exact congrArg Sum.inl hab
      | inr b =>
        have hh := congrArg Prod.fst he'
        change 0 = b.1.val+1 at hh
        omega
    | inr a =>
      cases b with
      | inl b =>
        have hh := congrArg Prod.fst he'
        change a.1.val+1 = 0 at hh
        omega
      | inr b =>
        congr 1
        apply Prod.ext
        · apply Fin.ext
          have hh := congrArg Prod.fst he'
          change a.1.val+1 = b.1.val+1 at hh
          omega
        · exact Fin.ext (congrArg Prod.snd he')
  simpa only [Fintype.card_sum, Fintype.card_prod, Fintype.card_fin] using
    Fintype.card_le_of_injective f hf

lemma height_add_rectangle_le_card (x : Cell μ) :
    μ.colLen 0 + col x * (row x+1) ≤ Fintype.card (Cell μ) := by
  let y : Cell μ.transpose := ⟨x.val.swap, YoungDiagram.mem_transpose.mpr x.property⟩
  have hh := width_add_rectangle_le_card μ.transpose y
  have hc : Fintype.card (Cell μ.transpose) = Fintype.card (Cell μ) := by
    simpa only [Cell, Fintype.card_coe, YoungDiagram.card] using YoungDiagram.card_transpose μ
  simpa only [YoungDiagram.rowLen_transpose, hc, y, row, col, Prod.fst_swap, Prod.snd_swap] using hh

lemma height_width_le_card : max (μ.colLen 0) (μ.rowLen 0) ≤ Fintype.card (Cell μ) := by
  by_cases h : Nonempty (Cell μ)
  · obtain ⟨x⟩ := h
    exact max_le (by have := height_add_rectangle_le_card μ x; omega)
      (by have := width_add_rectangle_le_card μ x; omega)
  · have hempty : μ = ⊥ := by
      apply YoungDiagram.ext
      ext x
      simp only [YoungDiagram.cells_bot, Finset.notMem_empty, iff_false]
      intro hx
      exact h ⟨⟨x,hx⟩⟩
    subst μ
    simp [YoungDiagram.colLen, YoungDiagram.rowLen]

lemma diagonal_twice_le (x : Cell μ) :
    2*(diagonal μ x+1) ≤ Fintype.card (Cell μ) + max (μ.colLen 0) (μ.rowLen 0) := by
  have hr : row x < μ.colLen 0 :=
    (YoungDiagram.mem_iff_lt_colLen.mp x.property).trans_le (μ.colLen_anti 0 _ (Nat.zero_le _))
  have hc : col x < μ.rowLen 0 :=
    (YoungDiagram.mem_iff_lt_rowLen.mp x.property).trans_le (μ.rowLen_anti 0 _ (Nat.zero_le _))
  have hm := height_width_le_card μ
  unfold diagonal
  by_cases hrow : row x = 0
  · rw [hrow]
    omega
  by_cases hcol : col x = 0
  · rw [hcol]
    omega
  rcases le_total (μ.colLen 0) (μ.rowLen 0) with h | h
  · rw [max_eq_right h]
    have hh := width_add_rectangle_le_card μ x
    have hm2 : 2*row x ≤ row x*(col x+1) := by
      rw [mul_comm 2]
      exact Nat.mul_le_mul_left _ (by omega)
    omega
  · rw [max_eq_left h]
    have hh := height_add_rectangle_le_card μ x
    have hm2 : 2*col x ≤ col x*(row x+1) := by
      rw [mul_comm 2]
      exact Nat.mul_le_mul_left _ (by omega)
    omega

lemma diagonal_lt_half_card_add_max (x : Cell μ) :
    diagonal μ x < (Fintype.card (Cell μ) + max (μ.colLen 0) (μ.rowLen 0))/2 := by
  have hh := diagonal_twice_le μ x
  omega

end BinaryCoordinateSweeps.Young

end

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps.Young
variable {X Y : Type*} [Fintype X] [Fintype Y]

def assembleFiberPerm (f : X → Y) (p : ∀ y, Equiv.Perm {x // f x = y}) :
    fiberStabilizer f :=
  ⟨(Equiv.sigmaFiberEquiv f).permCongr (Equiv.sigmaCongrRight p), by
    intro x
    exact (p (f x) ⟨x,rfl⟩).property⟩

omit [Fintype X] [Fintype Y] in
lemma assembleFiberPerm_injective (f : X → Y) : Function.Injective (assembleFiberPerm f) := by
  intro p q he
  have hh := congrArg Subtype.val he
  have hh' : Equiv.sigmaCongrRight p = Equiv.sigmaCongrRight q :=
    (Equiv.sigmaFiberEquiv f).permCongr.injective hh
  exact Equiv.Perm.sigmaCongrRightHom_injective hh'

lemma product_factorial_le_stabilizer (f : X → Y) :
    (∏ y, (Fintype.card {x // f x = y}).factorial) ≤ Nat.card (fiberStabilizer f) := by
  have hi := Nat.card_le_card_of_injective (assembleFiberPerm f) (assembleFiberPerm_injective f)
  simpa only [Nat.card_eq_fintype_card, Fintype.card_pi, Fintype.card_perm] using hi

lemma two_pow_sub_one_le_factorial (n : ℕ) : 2^(n-1) ≤ n.factorial := by
  cases n with
  | zero => simp
  | succ n =>
    induction n with
    | zero => simp
    | succ n ih =>
      rw [Nat.succ_sub_one, pow_succ, Nat.factorial_succ]
      have hp : 2 ≤ n+1+1 := by omega
      simpa only [Nat.succ_sub_one, mul_comm] using Nat.mul_le_mul ih hp

lemma two_pow_card_sub_colors_le_stabilizer (f : X → Y) :
    2^(Fintype.card X - Fintype.card Y) ≤ Nat.card (fiberStabilizer f) := by
  have hsum : ∑ y, Fintype.card {x // f x = y} = Fintype.card X := by
    rw [← Fintype.card_sigma]
    exact Fintype.card_congr (Equiv.sigmaFiberEquiv f)
  have hexp : Fintype.card X - Fintype.card Y ≤
      ∑ y, (Fintype.card {x // f x = y} - 1) := by
    have hh := Finset.sum_le_sum (s := Finset.univ) (fun (y : Y) _ =>
      show Fintype.card {x // f x = y} ≤ (Fintype.card {x // f x = y} - 1) + 1 from by omega)
    rw [hsum, Finset.sum_add_distrib] at hh
    simp only [Finset.sum_const, Finset.card_univ, smul_eq_mul, mul_one] at hh
    omega
  calc
    _ ≤ 2^(∑ y, (Fintype.card {x // f x = y} - 1)) := Nat.pow_le_pow_right (by decide) hexp
    _ = ∏ y, 2^(Fintype.card {x // f x = y} - 1) := (Finset.prod_pow_eq_pow_sum _ _ _).symm
    _ ≤ ∏ y, (Fintype.card {x // f x = y}).factorial :=
      Finset.prod_le_prod (fun y _ => two_pow_sub_one_le_factorial _)
    _ ≤ _ := product_factorial_le_stabilizer f

end BinaryCoordinateSweeps.Young

end

end OAI