import Mathlib
import OAI.Probability.BinarySweep.MatrixBounds.FourierTrace
import OAI.Probability.BinarySweep.Mixing.LongRowDimension

namespace OAI

noncomputable section

section

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps.Young

lemma rowLen_one_le_tail (μ : YoungDiagram) : μ.rowLen 1 ≤ μ.rowLens.tail.sum := by
  by_cases hh : μ.colLen 0≤1
  · have hz : μ.rowLen 1=0 := by
      by_contra hn
      have hm : (1,0)∈μ := YoungDiagram.mem_iff_lt_rowLen.mpr (by omega)
      have hc := YoungDiagram.mem_iff_lt_colLen.mp hm
      omega
    rw [hz]; omega
  · have hl : 1<μ.rowLens.length := by rw [YoungDiagram.length_rowLens]; omega
    have hmem : μ.rowLen 1 ∈ μ.rowLens.tail := by
      have hh := List.getElem_mem (show 0<μ.rowLens.tail.length from by simp; omega)
      simpa using hh
    exact List.single_le_sum (by simp) _ hmem

lemma rowLen_one_pos_of_tail (μ : YoungDiagram) (h : 0<μ.card-μ.rowLen 0) :
    0<μ.rowLen 1 := by
  have ht : 0<μ.rowLens.tail.sum := by rwa [rowLens_tail_sum]
  have hc : 1<μ.colLen 0 := by
    by_contra hn
    have ha : μ.colLen 0=0 ∨ μ.colLen 0=1 := by omega
    rcases ha with ha|ha <;> simp [YoungDiagram.rowLens,ha] at ht
  exact YoungDiagram.mem_iff_lt_rowLen.mp (YoungDiagram.mem_iff_lt_colLen.mpr hc)

lemma longOriented_dimension (μ : YoungDiagram) :
    Module.finrank ℂ (SpechtSpace (longOriented μ))=Module.finrank ℂ (SpechtSpace μ) := by
  by_cases h : μ.colLen 0 ≤ μ.rowLen 0
  · exact congrArg (fun ν => Module.finrank ℂ (SpechtSpace ν)) (ite_eq_left h)
  · exact (congrArg (fun ν => Module.finrank ℂ (SpechtSpace ν)) (ite_eq_right h)).trans
      (specht_finrank_transpose μ).symm

lemma dimension_grows (μ : YoungDiagram) (hk : 0 < flatTail μ) :
    μ.card-2*flatTail μ ≤ Module.finrank ℂ (SpechtSpace μ) := by
  have ht : (longOriented μ).card-(longOriented μ).rowLen 0=flatTail μ := by
    rw [longOriented_card,longOriented_row]; rfl
  have hr := rowLen_one_pos_of_tail (longOriented μ) (by rwa [ht])
  have hh := long_row_dimension (longOriented μ) hr
  rw [longOriented_dimension] at hh
  have hle := rowLen_one_le_tail (longOriented μ)
  rw [rowLens_tail_sum,ht] at hle
  have hc := height_width_le_card μ
  have hc' : max (μ.colLen 0) (μ.rowLen 0)≤μ.card := by simpa using hc
  rw [longOriented_row] at hh
  unfold flatTail at *
  omega

lemma partition_dimension_pos {n : ℕ} (p : n.Partition) :
    0<Module.finrank ℂ (PartitionHilbert p) := by
  exact Signed.irreducible_finrank_pos (partitionHilbertRep p)

lemma partition_dimension_grows {n k : ℕ} (p : n.Partition)
    (hp : flatTail (diagram p)=k) (hk : 0<k) :
    n-2*k ≤ Module.finrank ℂ (PartitionHilbert p) := by
  rw [hilbertSpecht_finrank]
  have hh := dimension_grows (diagram p) (by rwa [hp])
  rwa [diagram_card,hp] at hh

lemma partition_log_lower {n k : ℕ} (p : n.Partition) (hp : flatTail (diagram p)=k) :
    (Real.log 2/2)*(k:ℝ)≤Real.log (Module.finrank ℂ (PartitionHilbert p)) := by
  rw [hilbertSpecht_finrank,←hp]
  simpa only [flatTail,Fintype.card_coe] using log_dimension_lower (diagram p)

lemma partition_dimension_gt_one {n : ℕ} (p : n.Partition)
    (hp : 0<flatTail (diagram p)) : 1<Module.finrank ℂ (PartitionHilbert p) := by
  have hd := partition_dimension_pos p
  have hl := partition_log_lower p rfl
  have hlog : 0<Real.log 2 := Real.log_pos (by norm_num)
  by_contra hn
  have he : Module.finrank ℂ (PartitionHilbert p)=1 := by omega
  rw [he,Nat.cast_one,Real.log_one] at hl
  have hk : (0:ℝ)<flatTail (diagram p) := by exact_mod_cast hp
  nlinarith

open Irrep

lemma row_shape_cells (μ : YoungDiagram) (hμ : μ.card=μ.rowLen 0) (x : Cell μ) : row x=0 := by
  have ht := rowLen_one_le_tail μ
  rw [rowLens_tail_sum,hμ,Nat.sub_self] at ht
  have hm := YoungDiagram.mem_iff_lt_rowLen.mp x.property
  by_contra hn
  have ha := μ.rowLen_anti 1 (row x) (by omega)
  change col x<μ.rowLen (row x) at hm
  omega

lemma row_shape_tabloid (μ : YoungDiagram) (hμ : μ.card=μ.rowLen 0) (s t : Tabloid μ) : s=t := by
  obtain ⟨g,rfl⟩ := tabloidOfPerm_surjective μ s
  obtain ⟨h,rfl⟩ := tabloidOfPerm_surjective μ t
  apply Subtype.ext
  funext x
  exact (row_shape_cells μ hμ _).trans (row_shape_cells μ hμ _).symm

lemma hilbertSpecht_row (μ : YoungDiagram) (hμ : μ.card=μ.rowLen 0)
    (g : G μ) (v : SpechtHilbert μ) : hilbertSpecht μ g v=v := by
  apply Subtype.ext
  apply PiLp.ext
  intro t
  rw [hilbertSpecht_coeff,row_shape_tabloid μ hμ (g⁻¹ • t) t]

lemma row_average_zero {X : Type*} [Fintype X] [DecidableEq X]
    (μ : YoungDiagram) (hμ : μ.card=μ.rowLen 0) (e : Cell μ ≃ X) (p : Equiv.Perm X → ℂ)
    (hp : ∑g,p g=0) : groupAverage ((hilbertSpecht μ).comp e.symm.permCongrHom.toMonoidHom) p=0 := by
  apply LinearMap.ext
  intro v
  simp only [groupAverage,LinearMap.sum_apply,LinearMap.smul_apply,MonoidHom.comp_apply]
  change (∑g,p g • hilbertSpecht μ _ v)=0
  simp only [hilbertSpecht_row μ hμ,←Finset.sum_smul,hp,zero_smul]

lemma transpose_slot_moment {X : Type*} [Fintype X] [DecidableEq X]
    (μ : YoungDiagram) (e : Cell μ ≃ X) (p : Equiv.Perm X → ℂ) (q : ℕ) :
    evenMoment q (groupAverage ((hilbertSpecht μ).comp e.symm.permCongrHom.toMonoidHom) p)=
    evenMoment q (groupAverage ((hilbertSpecht μ.transpose).comp
      ((transposeCells μ).symm.trans e).symm.permCongrHom.toMonoidHom)
      (fun g => p g*(realSign g:ℂ))) := by
  rw [groupAverage_comp_slots,groupAverage_comp_slots,hilbert_transpose_moment]
  congr 2
  funext g
  congr 1
  change signC μ.transpose g=(realSign (((transposeCells μ).symm.trans e).permCongr g):ℂ)
  rw [realSign_permCongr_complex]
  change ((Equiv.Perm.sign g:ℤ):ℂ)=(((Equiv.Perm.sign g:ℤ):ℝ):ℂ)
  norm_cast

theorem flat_shape_moment_zero {X : Type*} [Fintype X] [DecidableEq X]
    (μ : YoungDiagram) (e : Cell μ ≃ X) (p : Equiv.Perm X → ℂ)
    (hμ : flatTail μ=0) (hp : ∑g,p g=0) (hs : ∑g,p g*(realSign g:ℂ)=0) :
    evenMoment 1 (groupAverage ((hilbertSpecht μ).comp e.symm.permCongrHom.toMonoidHom) p)=0 := by
  have hc : max (μ.colLen 0) (μ.rowLen 0)≤μ.card := by simpa using height_width_le_card μ
  have hh : μ.card=μ.rowLen 0 ∨ μ.card=μ.colLen 0 := by
    unfold flatTail at hμ
    omega
  rcases hh with hh|hh
  · rw [row_average_zero μ hh e p hp]
    simp [evenMoment]
  · rw [transpose_slot_moment]
    have ht : μ.transpose.card=μ.transpose.rowLen 0 := by
      rw [transpose_card,YoungDiagram.rowLen_transpose,hh]
    rw [row_average_zero μ.transpose ht _ _ hs]
    simp [evenMoment]

end BinaryCoordinateSweeps.Young

end

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps
open Irrep Young

lemma sign_convolution {X : Type*} [Fintype X] [DecidableEq X]
    (p q : Equiv.Perm X → ℝ) :
    (∑g,convolution p q g*realSign g)=(∑g,p g*realSign g)*(∑g,q g*realSign g) := by
  simp only [convolution,Finset.sum_mul]
  rw [Finset.sum_comm]
  calc
    _ = ∑x,∑y,p x*q y*realSign (x*y) := by
      apply Finset.sum_congr rfl
      intro x _
      simpa only [Equiv.coe_mulLeft,inv_mul_cancel_left] using
        (Equiv.sum_comp (Equiv.mulLeft x) (fun g => p x*q (x⁻¹*g)*realSign g)).symm
    _ = _ := by
      simp only [map_mul,Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro x _
      apply Finset.sum_congr rfl
      intro y _
      ring

lemma sweep_sign_zero {d w : ℕ} (hd : 0<d) (hw : 0<w) :
    (∑g,sweepLaw d w g*realSign g)=0 := by
  obtain ⟨w,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : w≠0)
  rw [sweepLaw,convolutionPower,sign_convolution,binary_sign_annihilated d hd,zero_mul]

lemma sweep_centered_mass (d w : ℕ) :
    (∑g : Equiv.Perm (Slot d),((sweepLaw d w g:ℝ)-uniformLaw _ g:ℂ))=0 := by
  simp only [←Complex.ofReal_sub]
  rw [←Complex.ofReal_sum,Finset.sum_sub_distrib]
  have hp : IsProbability (sweepLaw d w) := convolutionPower_probability
    ⟨finiteLaw_nonneg _,finiteLaw_sum _⟩ w
  rw [hp.2,uniformLaw_sum,sub_self,Complex.ofReal_zero]

lemma sweep_centered_sign {d w : ℕ} (hd : 0<d) (hw : 0<w) :
    (∑g : Equiv.Perm (Slot d),((sweepLaw d w g:ℝ)-uniformLaw _ g:ℂ)*(realSign g:ℂ))=0 := by
  have : Nonempty (Fin d) := ⟨⟨0,hd⟩⟩
  simp only [←Complex.ofReal_mul,←Complex.ofReal_sum,sub_mul,Finset.sum_sub_distrib,
    sweep_sign_zero hd hw,uniform_sign_zero,sub_self,Complex.ofReal_zero]

lemma variation_fourier_equiv {X : Type} [Fintype X] [DecidableEq X]
    {n : ℕ} (e : X ≃ Fin n) (p q : Equiv.Perm X → ℝ) :
    totalVariation p q ^2 ≤ (1/4:ℝ)*
      ∑ℓ : n.Partition,(Module.finrank ℂ (PartitionHilbert ℓ):ℝ)*
        evenMoment 1 (groupAverage ((partitionHilbertRep ℓ).comp e.permCongrHom.toMonoidHom)
          (fun g => (p g-q g:ℂ))) := by
  have ht := Fourier.variation_fourier_bound (p ∘ e.symm.permCongr) (q ∘ e.symm.permCongr)
  have he : totalVariation (p ∘ e.symm.permCongr) (q ∘ e.symm.permCongr)=totalVariation p q := by
    unfold totalVariation
    congr 1
    exact Equiv.sum_comp e.symm.permCongr (fun g => |p g-q g|)
  rw [he] at ht
  convert ht using 2
  apply Finset.sum_congr rfl
  intro ℓ _
  have hh := groupAverage_comp_slots e.symm (partitionHilbertRep ℓ)
    (fun g => (p g-q g:ℂ))
  simpa only [Equiv.symm_symm,Function.comp_apply] using
    congrArg (fun A => (Module.finrank ℂ (PartitionHilbert ℓ):ℝ)*evenMoment 1 A) hh

end BinaryCoordinateSweeps

end

end OAI