import Mathlib
import OAI.Probability.BinarySweep.Conditional.AugmentedComplement

namespace OAI

noncomputable section

section

open scoped BigOperators Classical

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

omit [DecidableEq I] [Fintype X] [DecidableEq X] in
lemma subPlacement_univ_injective :
    Function.Injective (subPlacement (X:=X) (Finset.univ : Finset I)) := by
  intro x y he
  ext i
  exact congrArg (fun t => t ⟨i,Finset.mem_univ _⟩) he

 def partialPlacement (A : Finset I) (g : Equiv.Perm X) :
    ((I ↪ X) → ℂ) →ₗ[ℂ] ((I ↪ X) → ℂ) where
  toFun v y := placementMarginal A v (movePlacement g⁻¹ (subPlacement A y))
  map_add' v w := by ext y; simp only [map_add,Pi.add_apply]
  map_smul' c v := by ext y; simp only [map_smul,RingHom.id_apply,Pi.smul_apply]

omit [DecidableEq I] in
lemma partialPlacement_apply (A : Finset I) (g : Equiv.Perm X)
    (v : (I ↪ X) → ℂ) (y : I ↪ X) :
    partialPlacement A g v y = ∑x : I ↪ X,
      if subPlacement A (movePlacement g x)=subPlacement A y then v x else 0 := by
  simp only [partialPlacement,placementMarginal,LinearMap.coe_mk,AddHom.coe_mk,
    move_sub_eq_iff]

omit [DecidableEq I] in
lemma partialPlacement_univ (g : Equiv.Perm X) :
    partialPlacement (Finset.univ : Finset I) g = placementRep g := by
  apply LinearMap.ext
  intro v
  funext y
  change (∑x : I ↪ X,
    if subPlacement Finset.univ x=movePlacement g⁻¹ (subPlacement Finset.univ y)
    then v x else 0)=v (movePlacement g⁻¹ y)
  simp only [← subPlacement_move,subPlacement_univ_injective.eq_iff]
  simp

 def placementAverage (p : Equiv.Perm X → ℂ) :
    ((I ↪ X) → ℂ) →ₗ[ℂ] ((I ↪ X) → ℂ) := ∑g, p g • placementRep g

 def partialPlacementAverage (A : Finset I) (p : Equiv.Perm X → ℂ) :
    ((I ↪ X) → ℂ) →ₗ[ℂ] ((I ↪ X) → ℂ) := ∑g, p g • partialPlacement A g

 def centeredPlacement (s : ℂ) (p : Equiv.Perm X → ℂ) :
    ((I ↪ X) → ℂ) →ₗ[ℂ] ((I ↪ X) → ℂ) :=
  ∑A ∈ (Finset.univ : Finset I).powerset,
    ((-1:ℂ)^(Fintype.card I-A.card)*s^A.card/s^Fintype.card I) • partialPlacementAverage A p

lemma partialPlacement_specht_zero (μ : YoungDiagram) (A : Finset (Tail μ))
    (hA : A≠Finset.univ) (g : G μ) (v : SpechtSpace μ) :
    partialPlacement A g (spechtPlacement μ v)=0 := by
  ext y
  change placementMarginal A (spechtPlacement μ v) _=0
  rw [spechtPlacement_marginal_zero μ A hA]
  rfl

lemma partialPlacementAverage_specht_zero (μ : YoungDiagram) (A : Finset (Tail μ))
    (hA : A≠Finset.univ) (p : G μ → ℂ) (v : SpechtSpace μ) :
    partialPlacementAverage A p (spechtPlacement μ v)=0 := by
  simp only [partialPlacementAverage,LinearMap.sum_apply,LinearMap.smul_apply,
    partialPlacement_specht_zero μ A hA,smul_zero,Finset.sum_const_zero]

theorem centeredPlacement_specht (μ : YoungDiagram) (s : ℂ) (hs : s≠0)
    (p : G μ → ℂ) (v : SpechtSpace μ) :
    centeredPlacement s p (spechtPlacement μ v) =
      placementAverage p (spechtPlacement μ v) := by
  unfold centeredPlacement
  simp only [LinearMap.sum_apply,LinearMap.smul_apply]
  rw [Finset.sum_eq_single Finset.univ]
  · simp only [Finset.card_univ,Nat.sub_self,pow_zero,one_mul,
      div_self (pow_ne_zero _ hs),one_smul,partialPlacementAverage,
      partialPlacement_univ,placementAverage,LinearMap.sum_apply,LinearMap.smul_apply]
  · intro A _ hA
    rw [partialPlacementAverage_specht_zero μ A hA,smul_zero]
  · intro hn
    exact (hn (Finset.mem_powerset.mpr (Finset.Subset.refl _))).elim

lemma placementAverage_specht (μ : YoungDiagram) (p : G μ → ℂ) (v : SpechtSpace μ) :
    placementAverage p (spechtPlacement μ v)=
      spechtPlacement μ (∑g, p g • spechtRep μ g v) := by
  simp only [placementAverage,LinearMap.sum_apply,LinearMap.smul_apply,map_sum,map_smul,
    spechtPlacement_intertwines]

end BinaryCoordinateSweeps.Young

end

open scoped BigOperators Classical

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

 def placementCoeffs : EuclideanSpace ℂ (I ↪ X) ≃ₗ[ℂ] ((I ↪ X) → ℂ) :=
  WithLp.linearEquiv 2 ℂ _
 def partialHilbert (A : Finset I) (g : Equiv.Perm X) :
    EuclideanSpace ℂ (I ↪ X) →ₗ[ℂ] EuclideanSpace ℂ (I ↪ X) :=
  placementCoeffs.symm.conj (partialPlacement A g)
 def partialKernel (A : Finset I) (g : Equiv.Perm X) : Matrix (I ↪ X) (I ↪ X) ℂ :=
  fun y x => if subPlacement A (movePlacement g x)=subPlacement A y then 1 else 0

omit [DecidableEq I] in
lemma partialKernel_toLin (A : Finset I) (g : Equiv.Perm X) :
    (partialKernel A g).toEuclideanLin=partialHilbert A g := by
  apply LinearMap.ext
  intro v
  apply (placementCoeffs (I:=I) (X:=X)).injective
  funext y
  change (∑x, partialKernel A g y x*v x)=partialPlacement A g (placementCoeffs v) y
  rw [partialPlacement_apply]
  apply Finset.sum_congr rfl
  intro x _
  dsimp [partialKernel]
  split_ifs <;> simp [placementCoeffs]

omit [Fintype I] [DecidableEq I] [Fintype X] in
lemma partialKernel_adjoint (A : Finset I) (g : Equiv.Perm X) :
    (partialKernel A g).conjTranspose=partialKernel A g⁻¹ := by
  ext y x
  have he : subPlacement A (movePlacement g y)=subPlacement A x ↔
      subPlacement A (movePlacement g⁻¹ x)=subPlacement A y := by
    rw [move_sub_eq_iff,← subPlacement_move]
    exact eq_comm
  simp only [Matrix.conjTranspose_apply,partialKernel,he]
  split_ifs <;> simp

omit [DecidableEq I] in
lemma partialHilbert_adjoint (A : Finset I) (g : Equiv.Perm X) :
    (partialHilbert A g).adjoint=partialHilbert A g⁻¹ := by
  rw [← partialKernel_toLin,← Matrix.toEuclideanLin_conjTranspose_eq_adjoint,
    partialKernel_adjoint,partialKernel_toLin]

 def centeredHilbert (s : ℝ) (p : Equiv.Perm X → ℂ) :
    EuclideanSpace ℂ (I ↪ X) →ₗ[ℂ] EuclideanSpace ℂ (I ↪ X) :=
  placementCoeffs.symm.conj (centeredPlacement (s:ℂ) p)

omit [DecidableEq I] in
lemma centeredHilbert_sum (s : ℝ) (p : Equiv.Perm X → ℂ) :
    centeredHilbert (I:=I) s p = ∑A ∈ (Finset.univ : Finset I).powerset,
      ((-1:ℂ)^(Fintype.card I-A.card)*(s:ℂ)^A.card/(s:ℂ)^Fintype.card I) •
        ∑g, p g • partialHilbert A g := by
  simp only [centeredHilbert,centeredPlacement,partialPlacementAverage,map_sum,map_smul,
    partialHilbert]

omit [DecidableEq I] in
lemma centeredHilbert_adjoint (s : ℝ) (p : Equiv.Perm X → ℂ) :
    (centeredHilbert (I:=I) s p).adjoint=centeredHilbert s (fun g => star (p g⁻¹)) := by
  simp only [centeredHilbert_sum,map_sum,map_smulₛₗ,partialHilbert_adjoint,
    map_div₀,map_mul,map_pow,map_neg,map_one,Complex.star_def,Complex.conj_ofReal]
  apply Finset.sum_congr rfl
  intro A _
  congr 1
  have he := Equiv.sum_comp (Equiv.inv (Equiv.Perm X)) (fun g => star (p g⁻¹) • partialHilbert A g)
  simp only [starRingEnd_apply]
  simpa only [Equiv.inv_apply,inv_inv] using he

 def spechtPlacementHilbert (μ : YoungDiagram) :
    SpechtHilbert μ →ₗ[ℂ] EuclideanSpace ℂ (Tail μ ↪ Cell μ) :=
  placementCoeffs.symm.toLinearMap.comp ((spechtPlacement μ).comp (spechtHilbertEquiv μ).symm.toLinearMap)

lemma spechtPlacementHilbert_injective (μ : YoungDiagram) :
    Function.Injective (spechtPlacementHilbert μ) :=
  placementCoeffs.symm.injective.comp ((spechtPlacement_injective μ).comp (spechtHilbertEquiv μ).symm.injective)

lemma centeredHilbert_specht (μ : YoungDiagram) (s : ℝ) (hs : s≠0)
    (p : G μ → ℂ) (v : SpechtHilbert μ) :
    centeredHilbert s p (spechtPlacementHilbert μ v)=
      spechtPlacementHilbert μ (Irrep.groupAverage (hilbertSpecht μ) p v) := by
  obtain ⟨u,rfl⟩ := (spechtHilbertEquiv μ).surjective v
  apply placementCoeffs.injective
  simp only [centeredHilbert,spechtPlacementHilbert,LinearMap.comp_apply,
    LinearEquiv.conj_apply,LinearEquiv.coe_coe,LinearEquiv.symm_symm,
    LinearEquiv.apply_symm_apply,LinearEquiv.symm_apply_apply]
  change centeredPlacement (s:ℂ) p (spechtPlacement μ u)=
    spechtPlacement μ ((spechtHilbertEquiv μ).symm (Irrep.groupAverage (hilbertSpecht μ) p
      (spechtHilbertEquiv μ u)))
  rw [centeredPlacement_specht μ _ (by exact_mod_cast hs),placementAverage_specht]
  congr 1
  simp only [Irrep.groupAverage,LinearMap.sum_apply,LinearMap.smul_apply,map_sum,map_smul]
  apply Finset.sum_congr rfl
  intro g _
  congr 1
  change spechtRep μ g u=(spechtHilbertEquiv μ).symm
    ((spechtHilbertEquiv μ) (spechtRep μ g ((spechtHilbertEquiv μ).symm ((spechtHilbertEquiv μ) u))))
  simp only [LinearEquiv.symm_apply_apply]

end BinaryCoordinateSweeps.Young

end

end OAI