import Mathlib
import OAI.Probability.BinarySweep.TensorBounds.SignedTypeCentrality
import OAI.Probability.BinarySweep.MatrixBounds.SpectralMoment

namespace OAI

noncomputable section

section

open scoped BigOperators Classical ComplexOrder MonoidAlgebra
open Matrix

namespace BinaryCoordinateSweeps
open Density Irrep Representation

lemma euclidean_pow {I : Type*} [Fintype I] [DecidableEq I]
    (M : Matrix I I ℂ) (q : ℕ) : (M^q).toEuclideanLin=M.toEuclideanLin^q := by
  induction q with
  | zero => simp only [pow_zero,Matrix.toLpLin_one,Module.End.one_eq_id]
  | succ q ih => rw [pow_succ,Matrix.toLpLin_mul_same,ih,pow_succ,Module.End.mul_eq_comp]

lemma projected_gram_power {I : Type*} [Fintype I] [DecidableEq I]
    (P M : Matrix I I ℂ) (hP : P.IsHermitian) (hPP : P*P=P) (hPM : P*M=M*P)
    {q : ℕ} (hq : 0 < q) :
    (star (P*M)*(P*M))^q = (star M*M)^q*P := by
  have hs : P*star M=star M*P := by
    have hh := congrArg star hPM
    simpa only [star_mul,show star P=P from hP.eq] using hh.symm
  have hc : Commute (star M*M) P := by
    change star M*M*P=P*(star M*M)
    rw [mul_assoc,← hPM,← mul_assoc,← hs,mul_assoc]
  have he : star (P*M)*(P*M)=(star M*M)*P := by
    simp only [star_mul,show star P=P from hP.eq]
    rw [mul_assoc,← mul_assoc P P M,hPP,hPM,← mul_assoc]
  rw [he,hc.mul_pow,(show IsIdempotentElem P from hPP).pow_eq (ne_of_gt hq)]

lemma trace_mul_projection {W : Type*} [NormedAddCommGroup W] [InnerProductSpace ℂ W]
    [FiniteDimensional ℂ W] (S : Submodule ℂ W) (B : W →ₗ[ℂ] W)
    (hS : ∀w∈S, B w∈S) :
    LinearMap.trace ℂ W (B*S.starProjection.toLinearMap)=
      LinearMap.trace ℂ S (B.restrict hS) := by
  have hm (w : W) : (B*S.starProjection.toLinearMap) w∈S :=
    hS _ (S.starProjection_apply_mem w)
  have he : (B*S.starProjection.toLinearMap).restrict (fun w _ => hm w)=B.restrict hS := by
    ext w
    change B (S.starProjection w.val)=B w.val
    rw [Submodule.starProjection_eq_self_iff.mpr w.property]
  rw [← LinearMap.trace_restrict_eq_of_forall_mem S _ hm,he]

namespace Signed
variable {A : Type*} [Fintype A] [DecidableEq A] {n : ℕ}
  {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V]

def signedAverage (p : A → Bool) (w : Equiv.Perm (Fin n) → ℂ) :
    Matrix (Fin n → A) (Fin n → A) ℂ := ∑g, w g • actionMatrix p g

lemma signedAverage_linear (p : A → Bool) (w : Equiv.Perm (Fin n) → ℂ) :
    (signedAverage p w).toEuclideanLin=groupAverage (hilbertTensorRep p n) w := by
  simp only [signedAverage,map_sum,map_smul,actionMatrix_linear,groupAverage]

omit [FiniteDimensional ℂ V] in
lemma isotypicProjection_commutes_average (p : A → Bool)
    (ρ : Representation ℂ (Equiv.Perm (Fin n)) V) (w : Equiv.Perm (Fin n) → ℂ) :
    isotypicProjection p ρ*signedAverage p w=signedAverage p w*isotypicProjection p ρ := by
  simp only [signedAverage,Finset.mul_sum,Finset.sum_mul,mul_smul_comm,smul_mul_assoc,
    typeProjection_commutes_action]

theorem local_projected_moment (p : A → Bool)
    (ρ : Representation ℂ (Equiv.Perm (Fin n)) V) [ρ.IsIrreducible]
    (hρ : ∀g v, ‖ρ g v‖=‖v‖) (w : Equiv.Perm (Fin n) → ℂ) {q : ℕ} (hq : 0 < q) :
    TraceHolder.matrixMoment q (isotypicProjection p ρ*signedAverage p w)=
      (Module.finrank ℂ (IntertwiningMap ρ (hilbertTensorRep p n)):ℝ)*evenMoment q (groupAverage ρ w) := by
  unfold TraceHolder.matrixMoment
  rw [projected_gram_power _ _ (isotypicProjection_psd p ρ).isHermitian
    (projectionMatrix_idempotent _) (isotypicProjection_commutes_average p ρ w) hq]
  rw [← trace_toEuclideanLinear]
  simp only [Matrix.toLpLin_mul_same,← Module.End.mul_eq_comp,euclidean_pow,
    Matrix.star_eq_conjTranspose,Matrix.toEuclideanLin_conjTranspose_eq_adjoint,signedAverage_linear]
  have hP : (isotypicProjection p ρ).toEuclideanLin=
      (isotypicSpan ρ (hilbertTensorRep p n)).starProjection.toLinearMap := by
    rw [hilbert_isotypic_eq]; exact projectionMatrix_linear _
  rw [hP]
  have hc := even_compatible ρ (hilbertTensorRep p n) w hρ (hilbertTensorRep_unitary p) q
  rw [trace_mul_projection _ _ (isotypic_invariant_of_compatible ρ _ _ _ hc),
    isotypic_trace ρ _ _ _ hc]
  simp only [evenMoment,Complex.mul_re,Complex.natCast_re,Complex.natCast_im,zero_mul,sub_zero]

lemma hilbert_multiplicity_bound (p : A → Bool)
    (ρ : Representation ℂ (Equiv.Perm (Fin n)) V) [ρ.IsIrreducible] :
    Module.finrank ℂ (IntertwiningMap ρ (hilbertTensorRep p n)) ≤ (n+1)^((Fintype.card A)^2) := by
  have hd : 0 < Module.finrank ℂ V := by
    let : Nontrivial ρ.asModule := IsSimpleModule.nontrivial ℂ[Equiv.Perm (Fin n)] ρ.asModule
    rw [← ρ.asModuleEquiv.finrank_eq]
    exact Module.finrank_pos
  have h := isotypicSpan_rank_bound p ρ
  rw [← hilbertSubspace_finrank,← hilbert_isotypic_eq p ρ,isotypicSpan_finrank_eq] at h
  exact Nat.le_of_mul_le_mul_left h hd

theorem local_projected_moment_le (p : A → Bool)
    (ρ : Representation ℂ (Equiv.Perm (Fin n)) V) [ρ.IsIrreducible]
    (hρ : ∀g v, ‖ρ g v‖=‖v‖) (w : Equiv.Perm (Fin n) → ℂ) {q : ℕ} (hq : 0 < q) :
    TraceHolder.matrixMoment q (isotypicProjection p ρ*signedAverage p w) ≤
      (n+1:ℝ)^((Fintype.card A)^2)*evenMoment q (groupAverage ρ w) := by
  rw [local_projected_moment p ρ hρ w hq]
  apply mul_le_mul_of_nonneg_right
  · exact_mod_cast hilbert_multiplicity_bound p ρ
  · exact (Complex.nonneg_iff.mp (positive_pow (LinearMap.isPositive_adjoint_comp_self _) q).trace_nonneg).1

end Signed
end BinaryCoordinateSweeps

end

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps.Fourier
open Representation

variable (G : Type*) [Group G] [Fintype G]

abbrev RegularSpace := EuclideanSpace ℂ G

def regularMap (g : G) : RegularSpace G →ₗ[ℂ] RegularSpace G where
  toFun v := WithLp.toLp 2 (fun x => v (g⁻¹*x))
  map_add' v w := by ext x; rfl
  map_smul' a v := by ext x; rfl

def regular : Representation ℂ G (RegularSpace G) where
  toFun := regularMap G
  map_one' := by ext v x; simp [regularMap]
  map_mul' g h := by ext v x; simp [regularMap,mul_assoc]

omit [Fintype G] in
@[simp] lemma regular_apply (g : G) (v : RegularSpace G) (x : G) :
    regular G g v x=v (g⁻¹*x) := rfl

lemma regular_unitary (g : G) (v : RegularSpace G) : ‖regular G g v‖=‖v‖ := by
  simp only [EuclideanSpace.norm_eq]
  congr 1
  exact Equiv.sum_comp (Equiv.mulLeft g⁻¹) (fun x => ‖v x‖^2)

lemma regular_character (g : G) :
    (regular G).character g=if g=1 then (Fintype.card G:ℂ) else 0 := by
  rw [Representation.character,LinearMap.trace_eq_sum_inner _ (EuclideanSpace.basisFun G ℂ)]
  by_cases hg : g=1
  · subst g; simp
  · rw [ite_eq_right hg]
    apply Finset.sum_eq_zero
    intro x _
    rw [EuclideanSpace.basisFun_inner,regular_apply,EuclideanSpace.basisFun_apply]
    simp only [PiLp.single_apply]
    have hh : g⁻¹*x≠x := by
      intro he
      have := mul_right_cancel (show g⁻¹*x=1*x from by simpa using he)
      exact hg (inv_eq_one.mp this)
    simp [hh]

lemma regular_multiplicity {V : Type*} [AddCommGroup V] [Module ℂ V]
    [FiniteDimensional ℂ V] (ρ : Representation ℂ G V) :
    Module.finrank ℂ (IntertwiningMap ρ (regular G))=Module.finrank ℂ V := by
  have hc : (Nat.card G:ℂ)≠0 := by
    rw [Nat.card_eq_fintype_card]
    exact_mod_cast Fintype.card_ne_zero
  let : Invertible (Nat.card G:ℂ) := invertibleOfNonzero hc
  have hh := card_inv_mul_sum_char_mul_char_eq_finrank ρ (regular G)
  simp only [regular_character,ite_mul,zero_mul] at hh
  simp only [Finset.sum_ite_eq',Finset.mem_univ,ite_true,inv_one,char_one] at hh
  rw [←Nat.card_eq_fintype_card,←mul_assoc,inv_mul_cancel₀ hc,one_mul] at hh
  exact_mod_cast hh.symm

lemma regular_average_apply (p : G → ℂ) (v : RegularSpace G) (x : G) :
    Irrep.groupAverage (regular G) p v x=∑g,p g*v (g⁻¹*x) := by
  simp [Irrep.groupAverage,LinearMap.sum_apply,LinearMap.smul_apply]

lemma regular_moment_one (p : G → ℂ) :
    Irrep.evenMoment 1 (Irrep.groupAverage (regular G) p)=
      (Fintype.card G:ℝ)*(∑g,‖p g‖^2) := by
  unfold Irrep.evenMoment
  rw [pow_one,LinearMap.trace_eq_sum_inner _ (EuclideanSpace.basisFun G ℂ)]
  simp only [Complex.re_sum,Module.End.mul_apply,LinearMap.adjoint_inner_right,inner_self_eq_norm_sq_to_K]
  have he (x : G) : ‖Irrep.groupAverage (regular G) p ((EuclideanSpace.basisFun G ℂ) x)‖^2=
      ∑g,‖p g‖^2 := by
    rw [EuclideanSpace.norm_sq_eq]
    have ha (y : G) : Irrep.groupAverage (regular G) p ((EuclideanSpace.basisFun G ℂ) x) y=p (y*x⁻¹) := by
      rw [regular_average_apply]
      simp only [EuclideanSpace.basisFun_apply,PiLp.single_apply]
      have hiff (g : G) : x=g⁻¹*y ↔ g=y*x⁻¹ := by
        constructor <;> intro hh
        · calc g=(g*x)*x⁻¹ := by group
                 _=y*x⁻¹ := by rw [hh]; simp
        · subst g; group
      simp_rw [eq_comm (a:=_⁻¹*y) (b:=x),hiff,mul_ite,mul_one,mul_zero]
      simp
    simp_rw [ha]
    exact Equiv.sum_comp (Equiv.mulRight x⁻¹) (fun g => ‖p g‖^2)
  change (∑i, ((‖Irrep.groupAverage (regular G) p ((EuclideanSpace.basisFun G ℂ) i)‖:ℂ)^2).re)=_
  simp only [←Complex.ofReal_pow,Complex.ofReal_re]
  simp_rw [he]
  simp

end BinaryCoordinateSweeps.Fourier

end

end OAI