import OAI.Analysis.InterpolatedFactors.AmbientSystem

namespace OAI

noncomputable section

namespace FreeGroupFactorMain

universe u_1 u_2 u_3 u_4 u_5 u_6 u_7 u_8 u_9 u_10 u_11 u_12
universe u_13 u_14 u_15 u_16 u_17 u_18 u_19 u_20 u_21 u_22 u_23 u_24
universe u_25 u_26 u_27 u_28 u_29 u_30 u_31 u_32 u_33 u_34 u_35 u_36
universe u_37 u_38 u_39 u_40 u_41 u_42 u_43 u_44 u_45 u_46 u_47 u_48
universe u_49

open Filter Topology

namespace FreeFock
open Filter Topology
open scoped ENNReal
variable {α : Type u_6} [DecidableEq α]

 theorem semicircular_no_eigenprojection (i : α) (z : ℂ) (E : gaussianAlgebra α)
    (hE : IsStarProjection (E : Operator α))
    (hA : semicircular i*(E : Operator α)=z • (E : Operator α)) : E=0 := by
  have he : semicircular i ((E : Operator α) vacuum)=z • ((E : Operator α) vacuum) :=
    DFunLike.congr_fun hA vacuum
  have hr := semicircular_eigen_root_zero i z _ he
  have hvac : (E : Operator α) vacuum=0 := by
    apply (inner_self_eq_zero (𝕜 := ℂ)).mp
    calc
      inner ℂ ((E : Operator α) vacuum) ((E : Operator α) vacuum)=
          inner ℂ vacuum (star (E : Operator α) ((E : Operator α) vacuum)) := by
        rw [ContinuousLinearMap.star_eq_adjoint,ContinuousLinearMap.adjoint_inner_right]
      _ = inner ℂ vacuum ((E : Operator α) vacuum) := by
        rw [hE.isSelfAdjoint.star_eq]
        have hh := DFunLike.congr_fun hE.isIdempotentElem.eq vacuum
        rw [mul_apply_eq_comp] at hh
        rw [hh]
      _ = 0 := by simp [vacuum,lp.inner_single_left,RCLike.inner_apply] at hr ⊢;exact hr
  exact gaussian_separating E hvac

end FreeFock
open MeasureTheory Set CompactlySupported
open scoped ENNReal
namespace CyclicSpectral
variable {H : Type u_7} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
local instance : InnerProductSpace ℝ H := InnerProductSpace.rclikeToReal ℂ H
variable (A : H →L[ℂ] H) (hA : IsSelfAdjoint A) (ξ : H)
end CyclicSpectral

open MeasureTheory ProbabilityTheory Filter Set Function
open scoped Topology ENNReal

namespace CyclicSpectral

section
open MeasureTheory
variable {H : Type u_19} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
local instance : InnerProductSpace ℝ H := InnerProductSpace.rclikeToReal ℂ H
variable (A : H →L[ℂ] H) (hA : IsSelfAdjoint A) (ξ : H)

end
section
open MeasureTheory Filter
variable {H : Type u_20} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
local instance : InnerProductSpace ℝ H := InnerProductSpace.rclikeToReal ℂ H
variable (A : H →L[ℂ] H) (hA : IsSelfAdjoint A) (ξ : H)

end
open MeasureTheory Filter
variable {H : Type u_21} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
local instance : InnerProductSpace ℝ H := InnerProductSpace.rclikeToReal ℂ H
variable (A : H →L[ℂ] H) (hA : IsSelfAdjoint A) (ξ : H)

end CyclicSpectral
namespace FreeFock

section
open MeasureTheory
variable {α : Type u_22} [DecidableEq α]
local instance : InnerProductSpace ℝ (Fock α) := InnerProductSpace.rclikeToReal ℂ (Fock α)

end
open MeasureTheory
variable {α : Type u_23} [DecidableEq α]

instance semicircular_spectral_probability (i : α) :
    IsProbabilityMeasure (CyclicSpectral.measure (semicircular i) (semicircular_selfAdjoint i) vacuum) := by
  apply CyclicSpectral.probability
  simp [vacuum,lp.norm_single]

instance semicircular_spectral_diffuse (i : α) :
    NullSingletonClass (CyclicSpectral.measure (semicircular i) (semicircular_selfAdjoint i) vacuum) :=
  semicircular_spectral_noAtoms i

 theorem spectralHaar_mem (i : α) :
    (CyclicSpectral.haarUnitary (semicircular i) (semicircular_selfAdjoint i) vacuum : Operator α)
      ∈ gaussianAlgebra α := by
  apply CyclicSpectral.complexHom_mem
  · rw [gaussianAlgebra,StarSubalgebra.coe_centralizer]
    exact Set.isClosed_centralizer _
  · exact StarAlgebra.adjoin_le_centralizer_centralizer ℂ _
      (StarAlgebra.subset_adjoin ℂ _ (Set.mem_range_self i))

def spectralHaar (i : α) : unitary (gaussianAlgebra α) := by
  let U := CyclicSpectral.haarUnitary (semicircular i) (semicircular_selfAdjoint i) vacuum
  refine ⟨⟨U,spectralHaar_mem i⟩,Unitary.mem_iff.mpr ⟨?_,?_⟩⟩
  · apply Subtype.ext
    exact (Unitary.mem_iff.mp U.property).1
  · apply Subtype.ext
    exact (Unitary.mem_iff.mp U.property).2

 theorem spectralHaar_moment (i : α) (n : ℕ) :
    vacuumTrace ((((spectralHaar i : gaussianAlgebra α) : Operator α)^n))=if n=0 then 1 else 0 :=
  CyclicSpectral.haarUnitary_moment (semicircular i) (semicircular_selfAdjoint i) vacuum n

end FreeFock
open Filter Topology
open scoped ENNReal
 theorem lp_strong_limit_of_bounded_basis {α : Type u_24} [DecidableEq α]
    (T : ℕ → lp (fun _ : α => ℂ) 2 →L[ℂ] lp (fun _ : α => ℂ) 2)
    (A : lp (fun _ : α => ℂ) 2 →L[ℂ] lp (fun _ : α => ℂ) 2)
    (C : ℝ) (hbound : ∀ n, ‖T n‖ ≤ C)
    (hbasis : ∀ a, Tendsto (fun n => T n (lp.single 2 a 1)) atTop (𝓝 (A (lp.single 2 a 1))))
    (ξ : lp (fun _ : α => ℂ) 2) : Tendsto (fun n => T n ξ) atTop (𝓝 (A ξ)) := by
  have heq : Equicontinuous (fun n => (T n : lp (fun _ : α => ℂ) 2 → lp (fun _ : α => ℂ) 2)) := by
    apply Metric.equicontinuous_of_continuity_modulus (fun r : ℝ => C*r)
      (by simpa using (tendsto_const_nhds.mul (tendsto_id : Tendsto (id : ℝ → ℝ) (𝓝 0) (𝓝 0))))
    intro x y n
    rw [dist_eq_norm,← map_sub]
    exact (T n).le_opNorm (x-y) |>.trans
      (by simpa only [dist_eq_norm] using mul_le_mul_of_nonneg_right (hbound n) (norm_nonneg (x-y)))
  have hc := heq.isClosed_setOfPred_tendsto (l := atTop) A.continuous
  apply hc.mem_of_tendsto (lp.hasSum_single (by norm_num : (2:ℝ≥0∞)≠⊤) ξ)
  filter_upwards [] with s
  have hs (a : α) : Tendsto (fun n => T n (lp.single 2 a (ξ a))) atTop (𝓝 (A (lp.single 2 a (ξ a)))) := by
    have h : lp.single (E := fun _ : α => ℂ) 2 a (ξ a)=(ξ a) • lp.single 2 a 1 := by
      ext b
      simp [lp.single_apply,Pi.single_apply]
    simpa only [h,map_smul] using (hbasis a).const_smul (ξ a)
  simpa only [map_sum] using tendsto_finsetSum s (fun a _ => hs a)
namespace FreeFock

section
open Filter Topology Set MeasureTheory
variable {α : Type u_25} [DecidableEq α]

 theorem semicircular_mem_haar_bicommutant (i : α) :
    semicircular i ∈ StarSubalgebra.centralizer ℂ
      (StarSubalgebra.centralizer ℂ ({(CyclicSpectral.haarUnitary (semicircular i)
        (semicircular_selfAdjoint i) vacuum : Operator α)} : Set (Operator α)) : Set (Operator α)) := by
  let : Nontrivial (Fock α) := ⟨⟨vacuum,0,by
    intro h
    have he := congrArg (fun v : Fock α => v []) h
    simp [vacuum,lp.single_apply] at he⟩⟩
  have hb (n : ℕ) := CyclicSpectral.bounded_haar_approx (semicircular i)
    (semicircular_selfAdjoint i) vacuum (1/((n:ℝ)+1)) (by positivity)
  choose T hmem hnorm herr using hb
  have hS : semicircular i ∈ gaussianAlgebra α :=
    StarAlgebra.adjoin_le_centralizer_centralizer ℂ _ (StarAlgebra.subset_adjoin ℂ _ (Set.mem_range_self i))
  have hG : IsClosed (gaussianAlgebra α : Set (Operator α)) := by
    rw [gaussianAlgebra,StarSubalgebra.coe_centralizer]
    exact Set.isClosed_centralizer _
  have hT (n : ℕ) : T n ∈ gaussianAlgebra α :=
    StarAlgebra.elemental.le_of_mem hG (spectralHaar_mem i) (hmem n)
  have hv : Tendsto (fun n => T n vacuum) atTop (𝓝 (semicircular i vacuum)) := by
    have h := squeeze_zero_norm (fun n => (herr n).le)
      (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ))
    have hh := h.add_const (semicircular i vacuum)
    simpa only [sub_add_cancel,zero_add] using hh
  have hstrong : ∀ ξ, Tendsto (fun n => T n ξ) atTop (𝓝 (semicircular i ξ)) := by
    apply lp_strong_limit_of_bounded_basis T (semicircular i) ‖semicircular i‖ hnorm
    intro w
    have he (D : Operator α) (hD : D ∈ gaussianAlgebra α) :
        D (lp.single 2 w 1)=rightWick w.reverse (D vacuum) := by
      have h := DFunLike.congr_fun (gaussian_commute_rightWick ⟨D,hD⟩ w.reverse) vacuum
      simpa only [mul_apply_eq_comp,rightWick_vacuum,List.reverse_reverse] using h.symm
    simpa only [he _ (hT _),he _ hS,Function.comp_def] using (rightWick w.reverse).continuous.continuousAt.tendsto.comp hv
  let B := StarSubalgebra.centralizer ℂ
      (StarSubalgebra.centralizer ℂ ({(CyclicSpectral.haarUnitary (semicircular i)
        (semicircular_selfAdjoint i) vacuum : Operator α)} : Set (Operator α)) : Set (Operator α))
  have hB : IsClosed (B : Set (Operator α)) := by
    dsimp [B]
    exact Set.isClosed_centralizer _
  have hU : (CyclicSpectral.haarUnitary (semicircular i) (semicircular_selfAdjoint i) vacuum : Operator α) ∈ B :=
    StarAlgebra.adjoin_le_centralizer_centralizer ℂ _ (StarAlgebra.subset_adjoin ℂ _ (Set.mem_singleton _))
  have hTB (n : ℕ) : T n ∈ B := StarAlgebra.elemental.le_of_mem hB hU (hmem n)
  rw [StarSubalgebra.mem_centralizer_iff]
  intro C hC
  have hl (D : Operator α) (hD : D ∈ StarSubalgebra.centralizer ℂ
      ({(CyclicSpectral.haarUnitary (semicircular i) (semicircular_selfAdjoint i) vacuum : Operator α)} : Set (Operator α))) :
      D*semicircular i=semicircular i*D := by
    apply ContinuousLinearMap.ext
    intro ξ
    have he n := congrArg (fun Q : Operator α => Q ξ)
      ((StarSubalgebra.mem_centralizer_iff ℂ).mp (hTB n) D hD).1
    exact tendsto_nhds_unique ((D.continuous.continuousAt.tendsto.comp (hstrong ξ)).congr
      (fun n => he n)) (hstrong (D ξ))
  exact ⟨hl C hC,hl (star C) (star_mem hC)⟩
end
section
open Set
variable {α : Type u_26} [DecidableEq α]

def spectralHaarOperator (i : α) : Operator α :=
  CyclicSpectral.haarUnitary (semicircular i) (semicircular_selfAdjoint i) vacuum

theorem haar_gaussian_commutant :
    StarSubalgebra.centralizer ℂ (Set.range (spectralHaarOperator : α → Operator α))=gaussianCommutant α := by
  ext C
  constructor
  · intro hC
    rw [gaussianCommutant,StarSubalgebra.mem_centralizer_iff]
    rintro _ ⟨i,rfl⟩
    have hi : C ∈ StarSubalgebra.centralizer ℂ ({spectralHaarOperator i} : Set (Operator α)) :=
      StarSubalgebra.centralizer_le ℂ _ _ (Set.singleton_subset_iff.mpr (Set.mem_range_self i)) hC
    have hh := ((StarSubalgebra.mem_centralizer_iff ℂ).mp (semicircular_mem_haar_bicommutant i) C hi).1
    exact ⟨hh.symm,by rw [(semicircular_selfAdjoint i).star_eq]; exact hh.symm⟩
  · intro hC
    rw [StarSubalgebra.mem_centralizer_iff]
    rintro _ ⟨i,rfl⟩
    have hi : spectralHaarOperator i ∈ gaussianAlgebra α := spectralHaar_mem i
    exact ⟨((StarSubalgebra.mem_centralizer_iff ℂ).mp hi C hC).1.symm,
      ((StarSubalgebra.mem_centralizer_iff ℂ).mp (show star (spectralHaarOperator i) ∈ gaussianAlgebra α from star_mem hi) C hC).1.symm⟩

theorem haar_generated_gaussian :
    StarSubalgebra.centralizer ℂ
      (StarSubalgebra.centralizer ℂ (Set.range (spectralHaarOperator : α → Operator α)) : Set (Operator α))=
    gaussianAlgebra α := by
  rw [haar_gaussian_commutant]
  rfl
end

section
open Filter Topology
open scoped ENNReal
variable {α : Type u_28} [DecidableEq α]

 theorem spectralHaar_cyclic_total :
    (algebraCyclic (StarAlgebra.adjoin ℂ (Set.range (spectralHaarOperator : α → Operator α)))
      vacuum).topologicalClosure=⊤ := by
  let A := StarAlgebra.adjoin ℂ (Set.range (spectralHaarOperator : α → Operator α))
  let K := (algebraCyclic A vacuum).topologicalClosure
  have hδ (w : List α) : lp.single 2 w (1:ℂ) ∈ K := by
    have hw : wick w ∈ gaussianAlgebra α := wick_mem_any _
      (fun i => StarAlgebra.adjoin_le_centralizer_centralizer ℂ _
        (StarAlgebra.subset_adjoin ℂ _ (Set.mem_range_self i))) w
    rw [← haar_generated_gaussian] at hw
    have hh := bicommutant_vector_mem_cyclic (Set.range (spectralHaarOperator : α → Operator α))
      vacuum (wick w) hw
    simpa only [wick_vacuum] using hh
  apply top_unique
  intro ξ _
  apply (algebraCyclic A vacuum).isClosed_topologicalClosure.mem_of_tendsto
    (lp.hasSum_single (by norm_num : (2:ℝ≥0∞)≠⊤) ξ)
  filter_upwards [] with s
  apply K.sum_mem
  intro w _
  have he : lp.single (E := fun _ : List α => ℂ) 2 w (ξ w)=(ξ w) • lp.single 2 w 1 := by
    ext v
    simp [lp.single_apply,Pi.single_apply]
  rw [he]
  exact K.smul_mem _ (hδ w)

end
section
open scoped ComplexConjugate
variable {α : Type u_29} [DecidableEq α]

 theorem vacuumTrace_star (T : Operator α) : vacuumTrace (star T)=conj (vacuumTrace T) := by
  unfold vacuumTrace
  rw [ContinuousLinearMap.star_eq_adjoint,ContinuousLinearMap.adjoint_inner_right]
  exact (inner_conj_symm (𝕜 := ℂ) (T vacuum) vacuum).symm

 theorem spectralHaar_integer_moment (i : α) (k : ℤ) :
    vacuumTrace (((spectralHaar i ^ k : unitary (gaussianAlgebra α)) : gaussianAlgebra α) : Operator α)=
      if k=0 then 1 else 0 := by
  cases k with
  | ofNat n =>
    simpa using spectralHaar_moment i n
  | negSucc n =>
    rw [ite_eq_right (Int.negSucc_ne_zero n),zpow_negSucc,← Unitary.star_eq_inv]
    change vacuumTrace (star ((((spectralHaar i : gaussianAlgebra α) : Operator α)^(n+1))))=0
    rw [vacuumTrace_star,spectralHaar_moment]
    simp

end
section
variable {α : Type u_30} [DecidableEq α]

 theorem wick_replicate_boundary (i j : α) (hij : i≠j) (w : List α) (n : ℕ) :
    wick (List.replicate n i)*wick (j::w)=wick (List.replicate n i++j::w) := by
  suffices ∀ n, (wick (List.replicate n i)*wick (j::w)=wick (List.replicate n i++j::w)) ∧
      (wick (List.replicate (n+1) i)*wick (j::w)=wick (List.replicate (n+1) i++j::w)) from (this n).1
  intro n
  induction n with
  | zero =>
    constructor
    · simp
    · simp only [Nat.zero_add,List.replicate_one,List.cons_append,List.nil_append]
      rw [wick_semicircular_cons i [],wick_nil,mul_one,sub_zero,
        wick_semicircular_cons i (j::w)]
      simp only [hij,ite_false,sub_zero]
  | succ n ih =>
    refine ⟨ih.2,?_⟩
    have hleft : wick (List.replicate (n+1+1) i)=
        semicircular i*wick (List.replicate (n+1) i)-wick (List.replicate n i) := by
      conv_lhs => rw [List.replicate_succ,wick_semicircular_cons]
      simp only [List.replicate_succ,ite_true]
    have hright : wick (List.replicate (n+1+1) i++j::w)=
        semicircular i*wick (List.replicate (n+1) i++j::w)-wick (List.replicate n i++j::w) := by
      conv_lhs => rw [List.replicate_succ,List.cons_append,wick_semicircular_cons]
      simp only [List.replicate_succ,List.cons_append,ite_true]
    rw [hleft,sub_mul,mul_assoc,ih.1,ih.2,hright]
end
variable {α : Type u_31} [DecidableEq α]

def blockLetters (L : List (α × ℕ)) : List α :=
  L.flatMap (fun p => List.replicate p.2 p.1)

def blockProduct : List (α × ℕ) → Operator α
  | [] => 1
  | (i,n)::L => wick (List.replicate n i)*blockProduct L

def blocksReduced : List (α × ℕ) → Prop
  | [] => True
  | (i,n)::L => 0 < n ∧ blocksReduced L ∧
    match L with | [] => True | (j,_)::_ => i≠j

 theorem wick_blocks_concatenate (L : List (α × ℕ)) (hL : blocksReduced L) :
    blockProduct L=wick (blockLetters L) := by
  induction L with
  | nil => simp [blockProduct,blockLetters]
  | cons p L ih =>
    rcases p with ⟨i,n⟩
    obtain ⟨hn,hL,hsep⟩ := hL
    cases L with
    | nil => simp [blockProduct,blockLetters]
    | cons q L =>
      rcases q with ⟨j,m⟩
      have hm : 0 < m := hL.1
      obtain ⟨k,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hm)
      rw [blockProduct,ih hL]
      change wick (List.replicate n i)*wick ((List.replicate (k+1) j)++blockLetters L)=
        wick (List.replicate n i++(List.replicate (k+1) j++blockLetters L))
      simpa only [List.replicate_succ,List.cons_append] using
        wick_replicate_boundary i j hsep (List.replicate k j++blockLetters L) n

 omit [DecidableEq α] in
 theorem blockLetters_nonempty {L : List (α × ℕ)} (hL : blocksReduced L) (h : L≠[]) :
    blockLetters L≠[] := by
  cases L with
  | nil => exact False.elim (h rfl)
  | cons p L =>
    rcases p with ⟨i,n⟩
    have hn : 0 < n := hL.1
    obtain ⟨k,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hn)
    simp [blockLetters,List.replicate_succ]

 theorem wick_blocks_centered_moment (L : List (α × ℕ)) (hL : blocksReduced L) (h : L≠[]) :
    vacuumTrace (blockProduct L)=0 := by
  rw [wick_blocks_concatenate L hL]
  have hne := blockLetters_nonempty hL h
  unfold vacuumTrace
  rw [wick_vacuum]
  simp [vacuum,lp.inner_single_left,lp.single_apply,hne]
end FreeFock
section

variable {A : Type u_32} [NormedRing A] [NormedAlgebra ℂ A]

theorem mul_mem_closed_span_image2 (s t : Set A) (x y : A)
    (hx : x∈(Submodule.span ℂ s).topologicalClosure)
    (hy : y∈(Submodule.span ℂ t).topologicalClosure) :
    x*y∈(Submodule.span ℂ (Set.image2 (·*·) s t)).topologicalClosure := by
  let K := (Submodule.span ℂ (Set.image2 (·*·) s t)).topologicalClosure
  have hbase (b : A) (hb : b∈t) : x*b∈K := by
    have hc : IsClosed {a : A | a*b∈K} :=
      (Submodule.isClosed_topologicalClosure _).preimage (continuous_id.mul continuous_const)
    apply closure_minimal (t := {a : A | a*b∈K}) ?_ hc hx
    intro a ha
    induction ha using Submodule.span_induction with
    | mem a ha =>
      exact Submodule.le_topologicalClosure _
        (Submodule.subset_span ⟨a,ha,b,hb,rfl⟩)
    | zero => simp
    | add a c _ _ ha hc => simpa only [Set.mem_ofPred_eq,add_mul] using K.add_mem ha hc
    | smul z a _ ha => simpa only [Set.mem_ofPred_eq,smul_mul_assoc] using K.smul_mem z ha
  have hc : IsClosed {b : A | x*b∈K} :=
    (Submodule.isClosed_topologicalClosure _).preimage (continuous_const.mul continuous_id)
  apply closure_minimal (t := {b : A | x*b∈K}) ?_ hc hy
  intro b hb
  induction hb using Submodule.span_induction with
  | mem b hb => exact hbase b hb
  | zero => simp
  | add b c _ _ hb hc => simpa only [Set.mem_ofPred_eq,mul_add] using K.add_mem hb hc
  | smul z b _ hb => simpa only [Set.mem_ofPred_eq,mul_smul_comm] using K.smul_mem z hb

end
namespace FreeFock

section
variable {α : Type u_33} [DecidableEq α]

 theorem center_run_mem (i : α) (x : Operator α) (hx : x∈runSpan i) :
    x-vacuumTrace x • 1∈positiveRunSpan i := by
  induction hx using Submodule.span_induction with
  | mem x hx =>
    obtain ⟨n,rfl⟩ := hx
    cases n with
    | zero => simp [vacuumTrace_one]
    | succ n =>
      rw [vacuumTrace_run,ite_eq_right (Nat.succ_ne_zero n),zero_smul ℂ (A := Operator α),sub_zero]
      exact Submodule.subset_span (Set.mem_range_self n)
  | zero => simpa only [vacuumTrace_linear.map_zero,zero_smul ℂ (A := Operator α),sub_self] using (positiveRunSpan i).zero_mem
  | add x y _ _ hx hy =>
    rw [vacuumTrace_linear.map_add,add_smul (R := ℂ) (M := Operator α),add_sub_add_comm]
    exact (positiveRunSpan i).add_mem hx hy
  | smul c x _ hx =>
    rw [vacuumTrace_linear.map_smul,smul_eq_mul,← smul_smul,← smul_sub]
    exact (positiveRunSpan i).smul_mem c hx

 theorem center_run_closure (i : α) (x : Operator α)
    (hx : x∈(runSpan i).topologicalClosure) :
    x-vacuumTrace x • 1∈(positiveRunSpan i).topologicalClosure := by
  have hc : Continuous (fun x : Operator α => x-vacuumTrace x • 1) :=
    continuous_id.sub (vacuumTrace_continuous.smul continuous_const)
  apply closure_minimal (t := {x | x-vacuumTrace x • 1∈(positiveRunSpan i).topologicalClosure}) ?_ ?_ hx
  · intro a ha
    exact (positiveRunSpan i).le_topologicalClosure (center_run_mem i a ha)
  · exact (positiveRunSpan i).isClosed_topologicalClosure.preimage hc

 theorem spectralHaar_run_closure (i : α) :
    spectralHaarOperator i ∈ (runSpan i).topologicalClosure := by
  change spectralHaarOperator i ∈ (runAlgebra i).topologicalClosure
  apply CyclicSpectral.complexHom_mem
  · exact StarSubalgebra.isClosed_topologicalClosure _
  · apply StarSubalgebra.le_topologicalClosure
    change semicircular i∈runSpan i
    simpa [wick_semicircular_cons] using run_mem i 1

 theorem spectralHaar_power_positive_run_closure (i : α) (k : ℤ) (hk : k≠0) :
    ((((spectralHaar i)^k : unitary (gaussianAlgebra α)) : gaussianAlgebra α) : Operator α) ∈
      (positiveRunSpan i).topologicalClosure := by
  have hrun : ((((spectralHaar i)^k : unitary (gaussianAlgebra α)) : gaussianAlgebra α) : Operator α) ∈
      (runSpan i).topologicalClosure := by
    change ((↑((spectralHaar i)^k) : gaussianAlgebra α) : Operator α) ∈
      (runAlgebra i).topologicalClosure
    have hh : spectralHaarOperator i∈(runAlgebra i).topologicalClosure := spectralHaar_run_closure i
    cases k with
    | ofNat n =>
      rw [Int.ofNat_eq_natCast,zpow_natCast]
      change spectralHaarOperator i^n ∈ (runAlgebra i).topologicalClosure
      exact pow_mem hh n
    | negSucc n =>
      rw [zpow_negSucc,← Unitary.star_eq_inv]
      change star (spectralHaarOperator i^(n+1))∈(runAlgebra i).topologicalClosure
      exact star_mem (pow_mem hh (n+1))
  have hc := center_run_closure i _ hrun
  rw [spectralHaar_integer_moment,ite_eq_right hk,zero_smul ℂ (A := Operator α),sub_zero] at hc
  exact hc

end
variable {α : Type u_34} [DecidableEq α]

def colorsReduced : List α → Prop
  | [] => True
  | i::L => colorsReduced L ∧ (match L with | [] => True | j::_ => i≠j)

def runProducts : List α → Set (Operator α)
  | [] => {1}
  | i::L => Set.image2 (·*·) (Set.range (fun n : ℕ => wick (List.replicate (n+1) i))) (runProducts L)

 theorem runProducts_blocks (L : List α) (X : Operator α) (hX : X∈runProducts L) :
    ∃ K : List (α×ℕ), K.map Prod.fst=L ∧ (∀ p∈K,0<p.2) ∧ X=blockProduct K := by
  induction L generalizing X with
  | nil => exact ⟨[],rfl,by simp,by simpa [runProducts,blockProduct] using hX⟩
  | cons i L ih =>
    obtain ⟨a,⟨n,rfl⟩,b,hb,rfl⟩ := hX
    obtain ⟨K,hK,hpos,rfl⟩ := ih b hb
    refine ⟨(i,n+1)::K,by simp [hK],?_,rfl⟩
    intro p hp
    rcases List.mem_cons.mp hp with rfl | hp
    · exact Nat.succ_pos n
    · exact hpos p hp

 omit [DecidableEq α] in
 theorem blocksReduced_of_colors (K : List (α×ℕ))
    (h : colorsReduced (K.map Prod.fst)) (hpos : ∀ p∈K,0<p.2) : blocksReduced K := by
  induction K with
  | nil => trivial
  | cons p K ih =>
    rcases p with ⟨i,n⟩
    refine ⟨hpos (i,n) (by simp),ih h.1 (fun p hp => hpos p (by simp [hp])),?_⟩
    cases K with
    | nil => trivial
    | cons q K => exact h.2

 theorem runProducts_trace_zero (L : List α) (h : colorsReduced L) (hne : L≠[])
    (X : Operator α) (hX : X∈runProducts L) : vacuumTrace X=0 := by
  obtain ⟨K,hK,hpos,rfl⟩ := runProducts_blocks L X hX
  apply wick_blocks_centered_moment
  · apply blocksReduced_of_colors K
    · simpa only [hK] using h
    · exact hpos
  · intro he
    apply hne
    simpa only [he,List.map_nil] using hK.symm

 theorem vacuumTrace_span_zero (S : Set (Operator α)) (hS : ∀ X∈S,vacuumTrace X=0)
    (X : Operator α) (hX : X∈(Submodule.span ℂ S).topologicalClosure) : vacuumTrace X=0 := by
  apply closure_minimal (t := {X : Operator α | vacuumTrace X=0}) ?_
    (isClosed_eq vacuumTrace_continuous continuous_const) hX
  intro X hX
  induction hX using Submodule.span_induction with
  | mem X hX => exact hS X hX
  | zero => exact vacuumTrace_linear.map_zero
  | add X Y _ _ hX hY =>
    change vacuumTrace X=0 at hX
    change vacuumTrace Y=0 at hY
    simp only [Set.mem_ofPred_eq,vacuumTrace_linear.map_add,hX,hY,add_zero]
  | smul c X _ hX =>
    change vacuumTrace X=0 at hX
    simp only [Set.mem_ofPred_eq,vacuumTrace_linear.map_smul,hX,smul_zero]

def haarProduct : List (α×ℤ) → Operator α
  | [] => 1
  | (i,k)::L => (((spectralHaar i ^ k : unitary (gaussianAlgebra α)) : gaussianAlgebra α) : Operator α)*haarProduct L

 theorem haarProduct_mem_runProducts (L : List (α×ℤ)) (hL : ∀ p∈L,p.2≠0) :
    haarProduct L∈(Submodule.span ℂ (runProducts (L.map Prod.fst))).topologicalClosure := by
  induction L with
  | nil =>
    exact Submodule.le_topologicalClosure _ (Submodule.subset_span (by simp [runProducts,haarProduct]))
  | cons p L ih =>
    rcases p with ⟨i,k⟩
    exact mul_mem_closed_span_image2 _ _ _ _
      (spectralHaar_power_positive_run_closure i k (hL (i,k) (by simp)))
      (ih (fun p hp => hL p (by simp [hp])))

 theorem spectralHaar_mixed_moment (L : List (α×ℤ))
    (hL : ∀ p∈L,p.2≠0) (hred : colorsReduced (L.map Prod.fst)) (hne : L≠[]) :
    vacuumTrace (haarProduct L)=0 := by
  apply vacuumTrace_span_zero (runProducts (L.map Prod.fst))
  · exact runProducts_trace_zero _ hred (by simpa using hne)
  · exact haarProduct_mem_runProducts L hL

end FreeFock

section
variable {α : Type u_35}

def adjacentDistinct : List α → Prop
  | [] => True
  | i::L => adjacentDistinct L ∧ (match L with | [] => True | j::_ => i≠j)

def expandSignedRuns (R : List ((α×Bool)×ℕ)) : List (α×Bool) :=
  R.flatMap (fun p => List.replicate p.2 p.1)

theorem reduced_signed_runs (L : List (α×Bool)) (hL : FreeGroup.IsReduced L) :
    ∃ R : List ((α×Bool)×ℕ), L=expandSignedRuns R ∧
      (∀ p∈R,0<p.2) ∧ adjacentDistinct (R.map (fun p => p.1.1)) := by
  classical
  induction L with
  | nil => exact ⟨[],rfl,by simp,by trivial⟩
  | cons x L ih =>
    have ht : FreeGroup.IsReduced L := hL.tail
    obtain ⟨R,hR,hpos,hred⟩ := ih ht
    rcases x with ⟨i,b⟩
    cases R with
    | nil =>
      have hnil : L=[] := hR
      subst L
      exact ⟨[((i,b),1)],by simp [expandSignedRuns],by simp,by trivial⟩
    | cons p R =>
      rcases p with ⟨⟨j,c⟩,m⟩
      have hm := hpos ((j,c),m) (by simp)
      obtain ⟨n,rfl⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hm)
      have he : L=(j,c)::(List.replicate n (j,c)++expandSignedRuns R) := by
        simpa [expandSignedRuns,List.replicate_succ] using hR
      by_cases hij : i=j
      · subst j
        have hpair : FreeGroup.IsReduced ((i,b)::(i,c)::(List.replicate n (i,c)++expandSignedRuns R)) := by
          simpa only [he] using hL
        have hbc : b=c := (FreeGroup.isReduced_cons_cons.mp hpair).1 rfl
        subst c
        refine ⟨((i,b),n+2)::R,?_,?_,hred⟩
        · simp only [expandSignedRuns,List.flatMap_cons,List.replicate_succ,List.cons_append,he]
        · intro p hp
          rcases List.mem_cons.mp hp with rfl | hp
          · omega
          · exact hpos p (List.mem_cons_of_mem _ hp)
      · refine ⟨((i,b),1)::((j,c),n+1)::R,?_,?_,?_⟩
        · simpa [expandSignedRuns] using congrArg (List.cons (i,b)) hR
        · intro p hp
          rcases List.mem_cons.mp hp with rfl | hp
          · exact Nat.zero_lt_one
          · exact hpos p hp
        · exact ⟨hred,hij⟩

end
section
variable {α : Type u_36} {G : Type u_37} [Group G]

def signedExponent (b : Bool) (n : ℕ) : ℤ := bif b then (n : ℤ) else -(n : ℤ)

theorem signedExponent_ne_zero (b : Bool) (n : ℕ) (hn : 0<n) : signedExponent b n≠0 := by
  cases b <;> simp [signedExponent,ne_of_gt hn]

theorem signedPower (b : Bool) (n : ℕ) (x : G) :
    x^signedExponent b n = (bif b then x else x⁻¹)^n := by
  cases b <;> simp [signedExponent]

def signedRunBlocks (R : List ((α×Bool)×ℕ)) : List (α×ℤ) :=
  R.map (fun p => (p.1.1,signedExponent p.1.2 p.2))

theorem lift_expandSignedRuns (f : α→G) (R : List ((α×Bool)×ℕ)) :
    FreeGroup.lift f (FreeGroup.mk (expandSignedRuns R))=
      ((signedRunBlocks R).map (fun p => f p.1^p.2)).prod := by
  rw [FreeGroup.lift_mk]
  induction R with
  | nil => rfl
  | cons p R ih =>
    rcases p with ⟨⟨i,b⟩,n⟩
    simpa only [expandSignedRuns,List.flatMap_cons,List.map_append,List.prod_append,
      List.map_replicate,List.prod_replicate,signedRunBlocks,List.map_cons,List.prod_cons,
      signedPower] using congrArg (fun x : G => (bif b then f i else (f i)⁻¹)^n*x) ih

end
namespace FreeFock
variable {α : Type u_38} [DecidableEq α]

def haarRepresentation : FreeGroup α →* unitary (gaussianAlgebra α) :=
  FreeGroup.lift spectralHaar

def haarOperatorRepresentation : FreeGroup α →* Operator α :=
  (gaussianAlgebra α).subtype.toMonoidHom.comp
    ((unitary (gaussianAlgebra α)).subtype.comp haarRepresentation)

 theorem haarProduct_eq_prod (L : List (α×ℤ)) :
    haarProduct L = (((L.map (fun p => (spectralHaar p.1)^p.2)).prod : unitary (gaussianAlgebra α)) : gaussianAlgebra α) := by
  induction L with
  | nil => rfl
  | cons p L ih =>
    rcases p with ⟨i,k⟩
    change ((spectralHaar i ^ k : unitary (gaussianAlgebra α)) : gaussianAlgebra α) * haarProduct L = _
    change ((spectralHaar i ^ k : unitary (gaussianAlgebra α)) : gaussianAlgebra α) * haarProduct L =
      (((spectralHaar i ^ k : unitary (gaussianAlgebra α)) : gaussianAlgebra α) : Operator α) * _
    exact congrArg (fun x : Operator α =>
      (((spectralHaar i ^ k : unitary (gaussianAlgebra α)) : gaussianAlgebra α) : Operator α)*x) ih

 theorem haarRepresentation_run_moment (R : List ((α×Bool)×ℕ))
    (hpos : ∀p∈R,0<p.2) (hred : adjacentDistinct (R.map (fun p => p.1.1))) (hne : R≠[]) :
    vacuumTrace (haarOperatorRepresentation (FreeGroup.mk (expandSignedRuns R)))=0 := by
  change vacuumTrace (((FreeGroup.lift (spectralHaar (α := α)) (FreeGroup.mk (expandSignedRuns R)) : unitary (gaussianAlgebra α)) : gaussianAlgebra α) : Operator α)=0
  rw [lift_expandSignedRuns,← haarProduct_eq_prod]
  apply spectralHaar_mixed_moment
  · intro p hp
    obtain ⟨q,hq,rfl⟩ := List.mem_map.mp hp
    exact signedExponent_ne_zero _ _ (hpos q hq)
  · have he : ∀ L : List α, colorsReduced L=adjacentDistinct L := by
      intro L
      induction L with
      | nil => rfl
      | cons i L ih => simp only [colorsReduced,adjacentDistinct,ih]
    rw [he]
    simpa only [signedRunBlocks,List.map_map,Function.comp_def] using hred
  · simpa [signedRunBlocks] using hne

 theorem haarRepresentation_moment (g : FreeGroup α) :
    vacuumTrace (haarOperatorRepresentation g)=if g=1 then 1 else 0 := by
  classical
  by_cases hg : g=1
  · subst g
    simp only [map_one,ite_true,vacuumTrace_one]
  · rw [ite_eq_right hg]
    obtain ⟨R,hR,hpos,hred⟩ := reduced_signed_runs g.toWord FreeGroup.isReduced_toWord
    have hne : R≠[] := by
      intro he
      have hn : g.toWord=[] := by simpa only [he,expandSignedRuns,List.flatMap_nil] using hR
      apply hg
      rw [← FreeGroup.mk_toWord (x := g),hn]
      rfl
    rw [← FreeGroup.mk_toWord (x := g),hR]
    exact haarRepresentation_run_moment R hpos hred hne

end FreeFock

namespace CyclicUnitary
open scoped ENNReal
variable {G : Type u_42} {E : Type u_43} [Group G] [DecidableEq G]
variable [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]
variable (ρ : G →* (E →L[ℂ] E)) (hstar : ∀ g,star (ρ g)=ρ g⁻¹) (ξ : E)

omit [DecidableEq G] in
include hstar in

theorem adjoin_range_span :
    (StarAlgebra.adjoin ℂ (Set.range ρ)).toSubalgebra.toSubmodule=
      Submodule.span ℂ (Set.range ρ) := by
  rw [StarAlgebra.adjoin_eq_span]
  have hs : star (Set.range ρ)=Set.range ρ := by
    ext T
    change (star T∈Set.range ρ) ↔ T∈Set.range ρ
    constructor
    · rintro ⟨g,hg⟩
      refine ⟨g⁻¹,?_⟩
      rw [← hstar,hg,star_star]
    · rintro ⟨g,rfl⟩
      exact ⟨g⁻¹,(hstar g).symm⟩
  rw [hs,Set.union_self]
  let M : Submonoid (E →L[ℂ] E) :=
    { carrier := Set.range ρ
      one_mem' := ⟨1,map_one ρ⟩
      mul_mem' := by
        rintro _ _ ⟨g,rfl⟩ ⟨h,rfl⟩
        exact ⟨g*h,map_mul ρ g h⟩ }
  change Submodule.span ℂ ((Submonoid.closure (M : Set (E →L[ℂ] E))) : Set (E →L[ℂ] E))=_
  rw [Submonoid.closure_eq]
  rfl

def orbitSpan : Submodule ℂ E := Submodule.span ℂ (Set.range (fun g => ρ g ξ))

omit [DecidableEq G] in
include hstar in
theorem apply_mem_orbitSpan (T : (E →L[ℂ] E)) (hT : T∈StarAlgebra.adjoin ℂ (Set.range ρ)) :
    T ξ∈orbitSpan ρ ξ := by
  change T∈(StarAlgebra.adjoin ℂ (Set.range ρ)).toSubalgebra.toSubmodule at hT
  rw [adjoin_range_span ρ hstar] at hT
  induction hT using Submodule.span_induction with
  | mem T hT =>
    obtain ⟨g,rfl⟩ := hT
    exact Submodule.subset_span (Set.mem_range_self g)
  | zero => exact (orbitSpan ρ ξ).zero_mem
  | add T U _ _ hT hU => exact (orbitSpan ρ ξ).add_mem hT hU
  | smul c T _ hT => exact (orbitSpan ρ ξ).smul_mem c hT

include hstar in
theorem orbit_inner (htrace : ∀ g,inner ℂ ξ (ρ g ξ)=if g=1 then 1 else 0) (g h : G) :
    inner ℂ (ρ g ξ) (ρ h ξ)=if g=h then 1 else 0 := by
  classical
  calc
    _ = inner ℂ ξ (star (ρ g) (ρ h ξ)) :=
      (ContinuousLinearMap.adjoint_inner_right (ρ g) ξ (ρ h ξ)).symm
    _ = inner ℂ ξ (ρ (g⁻¹*h) ξ) := by rw [hstar,map_mul]; rfl
    _ = _ := by rw [htrace]; simp only [inv_mul_eq_one]

def basis (g : G) : lp (fun _ : G => ℂ) 2 := lp.single 2 g 1

omit [Group G] [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] in
 theorem basis_inner (g h : G) :
    inner ℂ (basis g) (basis h)=if g=h then 1 else 0 := by
  simp [basis,lp.inner_single_left,lp.single_apply,Pi.single_apply]

omit [Group G] [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] in
 theorem basis_total : (Submodule.span ℂ (Set.range (basis (G := G)))).topologicalClosure=⊤ := by
  let K := (Submodule.span ℂ (Set.range (basis (G := G)))).topologicalClosure
  apply top_unique
  intro η _
  apply (Submodule.span ℂ (Set.range (basis (G := G)))).isClosed_topologicalClosure.mem_of_tendsto
    (lp.hasSum_single (by norm_num : (2:ℝ≥0∞)≠⊤) η)
  filter_upwards [] with s
  apply K.sum_mem
  intro g _
  have he : lp.single (E := fun _ : G => ℂ) 2 g (η g)=(η g) • basis g := by
    ext h
    simp [basis,lp.single_apply,Pi.single_apply]
  rw [he]
  exact K.smul_mem _ (Submodule.le_topologicalClosure _ (Submodule.subset_span (Set.mem_range_self g)))

def spatial (htrace : ∀ g,inner ℂ ξ (ρ g ξ)=if g=1 then 1 else 0)
    (htotal : (orbitSpan ρ ξ).topologicalClosure=⊤) :
    lp (fun _ : G => ℂ) 2 ≃ₗᵢ[ℂ] E :=
  GramSpatial.spatial basis (fun g => ρ g ξ)
    (fun g h => (orbit_inner ρ hstar ξ htrace g h).trans (basis_inner g h).symm)
    basis_total htotal

theorem spatial_basis (htrace : ∀ g,inner ℂ ξ (ρ g ξ)=if g=1 then 1 else 0)
    (htotal : (orbitSpan ρ ξ).topologicalClosure=⊤) (g : G) :
    spatial ρ hstar ξ htrace htotal (basis g)=ρ g ξ :=
  GramSpatial.spatial_family _ _ _ _ _ g

end CyclicUnitary
namespace FreeFock
variable {α : Type u_44} [DecidableEq α]

 theorem haarOperatorRepresentation_star (g : FreeGroup α) :
    star (haarOperatorRepresentation g)=haarOperatorRepresentation g⁻¹ := by
  change star (((haarRepresentation g : unitary (gaussianAlgebra α)) : gaussianAlgebra α) : Operator α) =
    (((haarRepresentation g⁻¹ : unitary (gaussianAlgebra α)) : gaussianAlgebra α) : Operator α)
  rw [map_inv]
  rfl

 theorem haarOperatorRepresentation_of (i : α) :
    haarOperatorRepresentation (FreeGroup.of i)=spectralHaarOperator i := by
  change ((((FreeGroup.lift (spectralHaar (α := α))) (FreeGroup.of i) : unitary (gaussianAlgebra α)) : gaussianAlgebra α) : Operator α) = _
  rw [FreeGroup.lift_apply_of]
  rfl

 theorem haarGroup_cyclic_total :
    (CyclicUnitary.orbitSpan (haarOperatorRepresentation (α := α)) vacuum).topologicalClosure=⊤ := by
  apply top_unique
  rw [← spectralHaar_cyclic_total (α := α)]
  apply Submodule.topologicalClosure_mono
  rintro η ⟨T,hT,rfl⟩
  apply CyclicUnitary.apply_mem_orbitSpan haarOperatorRepresentation haarOperatorRepresentation_star
  apply StarAlgebra.adjoin_mono _ hT
  rintro _ ⟨i,rfl⟩
  exact ⟨FreeGroup.of i,haarOperatorRepresentation_of i⟩

def haarSpatial : lp (fun _ : FreeGroup α => ℂ) 2 ≃ₗᵢ[ℂ] Fock α :=
  CyclicUnitary.spatial haarOperatorRepresentation haarOperatorRepresentation_star vacuum
    haarRepresentation_moment haarGroup_cyclic_total

 theorem haarSpatial_basis (g : FreeGroup α) :
    haarSpatial (CyclicUnitary.basis g)=haarOperatorRepresentation g vacuum :=
  CyclicUnitary.spatial_basis _ _ _ _ _ g

 theorem haarSpatial_vacuum : haarSpatial (CyclicUnitary.basis (1 : FreeGroup α))=vacuum := by
  rw [haarSpatial_basis,map_one]
  rfl

end FreeFock

section

variable {A : Type u_45} {B : Type u_46} [Ring A] [Ring B] [Algebra ℂ A] [Algebra ℂ B]
  [StarRing A] [StarRing B] [StarModule ℂ A] [StarModule ℂ B]

theorem equiv_mem_centralizer (e : A ≃⋆ₐ[ℂ] B) (S : Set A) (T : A) :
    e T∈StarSubalgebra.centralizer ℂ (e '' S) ↔ T∈StarSubalgebra.centralizer ℂ S := by
  simp only [StarSubalgebra.mem_centralizer_iff]
  constructor
  · intro h U hU
    have h := h (e U) ⟨U,hU,rfl⟩
    constructor
    · apply (EquivLike.injective e); simpa only [map_mul] using h.1
    · apply (EquivLike.injective e); simpa only [map_mul,map_star] using h.2
  · rintro h _ ⟨U,hU,rfl⟩
    have h := h U hU
    constructor
    · simpa only [map_mul] using congrArg e h.1
    · simpa only [map_mul,map_star] using congrArg e h.2

theorem equiv_image_centralizer (e : A ≃⋆ₐ[ℂ] B) (S : Set A) :
    e '' (StarSubalgebra.centralizer ℂ S : Set A)=
      (StarSubalgebra.centralizer ℂ (e '' S) : Set B) := by
  ext T
  constructor
  · rintro ⟨U,hU,rfl⟩
    exact (equiv_mem_centralizer e S U).mpr hU
  · intro hT
    refine ⟨e.symm T,?_,e.apply_symm_apply T⟩
    apply (equiv_mem_centralizer e S _).mp
    rw [e.apply_symm_apply]
    exact hT

theorem equiv_mem_bicommutant (e : A ≃⋆ₐ[ℂ] B) (S : Set A) (T : A) :
    e T∈StarSubalgebra.centralizer ℂ
      (StarSubalgebra.centralizer ℂ (e '' S) : Set B) ↔
    T∈StarSubalgebra.centralizer ℂ (StarSubalgebra.centralizer ℂ S : Set A) := by
  rw [← equiv_image_centralizer]
  exact equiv_mem_centralizer e _ T
def restrictStarAlgEquiv (e : A ≃⋆ₐ[ℂ] B) (S : StarSubalgebra ℂ A) (T : StarSubalgebra ℂ B)
    (he : ∀ a,e a∈T ↔ a∈S) : S ≃⋆ₐ[ℂ] T where
  toFun a := ⟨e a,(he a).mpr a.property⟩
  invFun b := ⟨e.symm b,(he _).mp (by rw [e.apply_symm_apply]; exact b.property)⟩
  left_inv a := Subtype.ext (e.symm_apply_apply a)
  right_inv b := Subtype.ext (e.apply_symm_apply b)
  map_mul' a b := Subtype.ext (map_mul e (a : A) (b : A))
  map_add' a b := Subtype.ext (map_add e (a : A) (b : A))
  map_smul' c a := Subtype.ext (map_smul e c (a : A))
  map_star' a := Subtype.ext (map_star e (a : A))

end
open scoped ENNReal
variable {G : Type u_47} [Group G] [DecidableEq G]

theorem leftRegular_basis (g h : G) :
    leftRegular g (CyclicUnitary.basis h)=CyclicUnitary.basis (g*h) := by
  ext k
  simp only [leftRegular_apply,CyclicUnitary.basis,lp.single_apply,Pi.single_apply]
  congr 1
  exact propext (inv_mul_eq_iff_eq_mul)

namespace FreeFock
variable {α : Type u_48} [DecidableEq α]

theorem haarSpatial_intertwines (g : FreeGroup α) :
    haarSpatial.conjStarAlgEquiv (leftRegular g)=haarOperatorRepresentation g := by
  have h : (haarSpatial (α := α)).toContinuousLinearEquiv.toContinuousLinearMap.comp (leftRegular g)=
      (haarOperatorRepresentation g).comp haarSpatial.toContinuousLinearEquiv.toContinuousLinearMap := by
    apply lp.ext_continuousLinearMap (by norm_num : (2:ℝ≥0∞)≠⊤)
    intro h
    apply ContinuousLinearMap.ext
    intro z
    have hz : lp.single (E := fun _ : FreeGroup α => ℂ) 2 h z=z • CyclicUnitary.basis h := by
      ext k
      simp [CyclicUnitary.basis,lp.single_apply,Pi.single_apply]
    change haarSpatial (leftRegular g (lp.single 2 h z))=
      haarOperatorRepresentation g (haarSpatial (lp.single 2 h z))
    rw [hz,map_smul,map_smul,map_smul,map_smul]
    congr 1
    rw [leftRegular_basis,haarSpatial_basis,haarSpatial_basis]
    exact DFunLike.congr_fun (map_mul haarOperatorRepresentation g h) vacuum
  apply ContinuousLinearMap.ext
  intro ξ
  have h := DFunLike.congr_fun h (haarSpatial.symm ξ)
  simpa only [LinearIsometryEquiv.conjStarAlgEquiv_apply_apply,ContinuousLinearMap.comp_apply,LinearIsometryEquiv.coe_toContinuousLinearEquiv,
    ContinuousLinearEquiv.coe_coe,LinearIsometryEquiv.apply_symm_apply] using h

theorem haarRepresentation_commutant :
    StarSubalgebra.centralizer ℂ (Set.range (haarOperatorRepresentation (α := α)))=
      gaussianCommutant α := by
  rw [← haar_gaussian_commutant]
  apply le_antisymm
  · apply StarSubalgebra.centralizer_le ℂ
    rintro _ ⟨i,rfl⟩
    exact ⟨FreeGroup.of i,haarOperatorRepresentation_of i⟩
  · intro C hC
    rw [haar_gaussian_commutant] at hC
    rw [StarSubalgebra.mem_centralizer_iff]
    rintro _ ⟨g,rfl⟩
    have hg : haarOperatorRepresentation g∈gaussianAlgebra α :=
      (haarRepresentation g : gaussianAlgebra α).property
    exact ⟨((StarSubalgebra.mem_centralizer_iff ℂ).mp hg C hC).1.symm,
      ((StarSubalgebra.mem_centralizer_iff ℂ).mp (star_mem hg) C hC).1.symm⟩

theorem haarSpatial_mem_vonNeumann (T : GroupOperator (FreeGroup α)) :
    haarSpatial.conjStarAlgEquiv T∈gaussianAlgebra α ↔ T∈groupVonNeumann (FreeGroup α) := by
  have he : haarSpatial.conjStarAlgEquiv '' leftTranslations (FreeGroup α)=
      Set.range (haarOperatorRepresentation (α := α)) := by
    rw [leftTranslations_eq_range,← Set.range_comp]
    congr 1
    funext g
    exact haarSpatial_intertwines g
  have h := equiv_mem_bicommutant haarSpatial.conjStarAlgEquiv (leftTranslations (FreeGroup α)) T
  rw [he,haarRepresentation_commutant] at h
  exact h

def gaussianGroupIso : groupVonNeumann (FreeGroup α) ≃⋆ₐ[ℂ] gaussianAlgebra α :=
  restrictStarAlgEquiv haarSpatial.conjStarAlgEquiv _ _ haarSpatial_mem_vonNeumann

theorem gaussianGroupIso_trace (T : groupVonNeumann (FreeGroup α)) :
    vacuumTrace ((gaussianGroupIso T : gaussianAlgebra α) : Operator α)=canonicalTrace T := by
  have hcoe : ((gaussianGroupIso T : gaussianAlgebra α) : Operator α)=
      (haarSpatial (α := α)).conjStarAlgEquiv (T : GroupOperator (FreeGroup α)) := rfl
  rw [hcoe]
  unfold vacuumTrace
  rw [← haarSpatial_vacuum (α := α),LinearIsometryEquiv.conjStarAlgEquiv_apply_apply,
    haarSpatial.symm_apply_apply,haarSpatial.inner_map_map]
  simp only [CyclicUnitary.basis,lp.inner_single_left,RCLike.inner_apply,map_one,mul_one]
  unfold canonicalTrace
  exact congrArg (fun ξ : GroupHilbert (FreeGroup α) => ((T : GroupOperator (FreeGroup α)) ξ) 1) (by
    ext g
    simp only [lp.single_apply,Pi.single_apply]
    split_ifs <;> rfl)

@[instance_reducible] def gaussianUltraweakTopology (α : Type u_49) [DecidableEq α] :
    TopologicalSpace (gaussianAlgebra α) :=
  TopologicalSpace.induced (fun T : gaussianAlgebra α => (T : Operator α))
    (ultraweakOperatorTopology (List α))

theorem gaussianGroupIso_normal :
    @Continuous _ _ (groupUltraweakTopology (FreeGroup α)) (gaussianUltraweakTopology α)
      (gaussianGroupIso (α := α)) := by
  let : TopologicalSpace (GroupOperator (FreeGroup α)) := ultraweakOperatorTopology (FreeGroup α)
  let : TopologicalSpace (Operator α) := ultraweakOperatorTopology (List α)
  let : TopologicalSpace (groupVonNeumann (FreeGroup α)) := groupUltraweakTopology (FreeGroup α)
  let : TopologicalSpace (gaussianAlgebra α) := gaussianUltraweakTopology α
  exact ((spatial_ultraweak_continuous haarSpatial).comp continuous_subtype_val).subtype_mk _

end FreeFock

end FreeGroupFactorMain

end

end OAI