lean/OAI/Analysis/InterpolatedFactors/Stabilization.lean

import OAI.Analysis.InterpolatedFactors.Subalgebras

namespace OAI

noncomputable section

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

namespace FreeGroupFactorMain
namespace InfiniteICC

 theorem reduced_append_fresh {α : Type u_1} {L : List (α × Bool)} (hL : FreeGroup.IsReduced L)
    (a : α) (b : Bool) (ha : ∀ x ∈ L, x.1 ≠ a) : FreeGroup.IsReduced (L++[(a,b)]) := by
  induction L with
  | nil => exact FreeGroup.IsReduced.singleton
  | cons x L ih =>
    cases L with
    | nil =>
      rw [List.cons_append,List.nil_append,FreeGroup.isReduced_cons_cons]
      exact ⟨fun he => (ha x (by simp) he).elim,FreeGroup.IsReduced.singleton⟩
    | cons y L =>
      rw [FreeGroup.isReduced_cons_cons] at hL
      simp only [List.cons_append]
      rw [FreeGroup.isReduced_cons_cons]
      exact ⟨hL.1,ih hL.2 (fun z hz => ha z (List.mem_cons_of_mem _ hz))⟩

 theorem reduced_conjugate_fresh {α : Type u_2} {L : List (α × Bool)} (hL : FreeGroup.IsReduced L)
    (hne : L ≠ []) (a : α) (ha : ∀ x ∈ L, x.1 ≠ a) :
    FreeGroup.IsReduced ((a,true)::(L++[(a,false)])) := by
  cases L with
  | nil => exact (hne rfl).elim
  | cons x L =>
    rw [List.cons_append,FreeGroup.isReduced_cons_cons]
    refine ⟨fun he => (ha x (by simp) he.symm).elim,?_⟩
    exact reduced_append_fresh hL a false ha

 theorem conjugate_word (g : FreeGroup ℕ) (hg : g ≠ 1) (a : ℕ)
    (ha : ∀ x ∈ g.toWord, x.1 ≠ a) :
    (FreeGroup.of a*g*(FreeGroup.of a)⁻¹).toWord=
      (a,true)::(g.toWord++[(a,false)]) := by
  have he : FreeGroup.of a*g*(FreeGroup.of a)⁻¹ =
      FreeGroup.mk ((a,true)::(g.toWord++[(a,false)])) := by
    rw [← List.singleton_append,← List.append_assoc,← FreeGroup.mul_mk,← FreeGroup.mul_mk,
      FreeGroup.mk_toWord]
    rfl
  rw [he,FreeGroup.toWord_mk]
  exact (reduced_conjugate_fresh FreeGroup.isReduced_toWord (FreeGroup.toWord_eq_nil_iff.not.mpr hg) a ha).reduce_eq

 theorem infinite_conjugates (g : FreeGroup ℕ) (hg : g ≠ 1) :
    ∃ c : ℕ → FreeGroup ℕ, Function.Injective c ∧ ∀ n, ∃ a, c n=a*g*a⁻¹ := by
  classical
  let S : Finset ℕ := (g.toWord.map Prod.fst).toFinset
  let M := S.sup id
  let a (n : ℕ) := M+1+n
  have hfresh (n : ℕ) (x) (hx : x ∈ g.toWord) : x.1 ≠ a n := by
    have hm : x.1 ≤ M := Finset.le_sup (f := id) (by simpa only [S,List.mem_toFinset,List.mem_map] using ⟨x,hx,rfl⟩)
    dsimp [a]
    omega
  refine ⟨fun n => FreeGroup.of (a n)*g*(FreeGroup.of (a n))⁻¹,?_,fun n => ⟨FreeGroup.of (a n),rfl⟩⟩
  intro m n h
  have hw := congrArg FreeGroup.toWord h
  rw [conjugate_word g hg (a m) (hfresh m),conjugate_word g hg (a n) (hfresh n)] at hw
  have he : a m=a n := congrArg Prod.fst (List.cons.inj hw).1
  dsimp [a] at he
  omega

end InfiniteICC

 theorem central_coefficient_conjugate {G : Type u_3} [Group G] [DecidableEq G]
    (T : groupVonNeumann G) (hT : ∀ S : groupVonNeumann G, Commute T S) (a g : G) :
    ((T : GroupOperator G) deltaOne) (a*g*a⁻¹)=((T : GroupOperator G) deltaOne) g := by
  have he : (T : GroupOperator G)*leftRegular a=leftRegular a*(T : GroupOperator G) :=
    congrArg (fun A : groupVonNeumann G => (A : GroupOperator G)) (hT (groupUnitary a)).eq
  have hd : leftRegular a deltaOne=lp.single 2 a 1 := by
    ext x
    simp [leftRegular_apply,deltaOne,lp.single_apply,Pi.single_apply,inv_mul_eq_one,eq_comm]
  have hx := congrArg (fun A : GroupOperator G => A deltaOne (a*g)) he
  simp only [mul_apply_eq_comp,hd,leftRegular_apply,inv_mul_cancel_left] at hx
  rw [groupVN_matrix] at hx
  exact hx

 theorem group_center_scalar_of_infinite_conjugates {G : Type u_4} [Group G]
    (hICC : ∀ g : G, g ≠ 1 → ∃ c : ℕ → G, Function.Injective c ∧ ∀ n, ∃ a, c n=a*g*a⁻¹)
    (T : groupVonNeumann G) (hT : ∀ S : groupVonNeumann G, Commute T S) :
    T=canonicalTrace T • (1 : groupVonNeumann G) := by
  classical
  have hz (g : G) (hg : g ≠ 1) : ((T : GroupOperator G) deltaOne) g=0 := by
    obtain ⟨c,hc,hconj⟩ := hICC g hg
    have hs : Summable (fun x : G => ‖((T : GroupOperator G) deltaOne) x‖^2) := by
      simpa only [ENNReal.toReal_ofNat,Real.rpow_two] using
        (lp.memℓp ((T : GroupOperator G) deltaOne)).summable (by norm_num)
    have hcst : Summable (fun _ : ℕ => ‖((T : GroupOperator G) deltaOne) g‖^2) := by
      have hh := hs.comp_injective hc
      change Summable (fun n : ℕ => ‖((T : GroupOperator G) deltaOne) (c n)‖^2) at hh
      have he : (fun n : ℕ => ‖((T : GroupOperator G) deltaOne) (c n)‖^2) =
          (fun _ : ℕ => ‖((T : GroupOperator G) deltaOne) g‖^2) := by
        funext n
        obtain ⟨a,ha⟩ := hconj n
        rw [ha,central_coefficient_conjugate T hT]
      rwa [he] at hh
    have hh := (summable_const_iff _).mp hcst
    exact norm_eq_zero.mp (by nlinarith [norm_nonneg (((T : GroupOperator G) deltaOne) g)])
  apply sub_eq_zero.mp
  apply groupVN_separating
  rw [← deltaOne_eq]
  ext g
  change ((T : GroupOperator G) deltaOne) g-canonicalTrace T*deltaOne g=(0 : ℂ)
  by_cases hg : g=1
  · subst g
    simp only [deltaOne,lp.single_apply,Pi.single_eq_same,mul_one,canonicalTrace]
    exact sub_self _
  · rw [hz g hg]
    simp [deltaOne,lp.single_apply,hg]

 theorem infinite_free_group_center_scalar (T : groupVonNeumann (FreeGroup ℕ))
    (hT : ∀ S : groupVonNeumann (FreeGroup ℕ), Commute T S) :
    T=canonicalTrace T • (1 : groupVonNeumann (FreeGroup ℕ)) :=
  group_center_scalar_of_infinite_conjugates InfiniteICC.infinite_conjugates T hT

end FreeGroupFactorMain

namespace FreeGroupFactorMain.Amplification

section
variable {A : Type u_9} [CStarAlgebra A]

def equivalentCorner (p q : A) (hp : IsStarProjection p) (hq : IsStarProjection q)
    (u : A) (hu : star u*u=p) (hu' : u*star u=q) : Corner p hp ≃⋆ₐ[ℂ] Corner q hq where
  toFun x := ⟨u*(x : A)*star u,by
    constructor
    · rw [← hu']
      calc
        (u*star u)*(u*(x : A)*star u) = u*((star u*u)*(x : A))*star u := by noncomm_ring
        _ = u*(x : A)*star u := by rw [hu,x.property.1]
    · rw [← hu']
      calc
        (u*(x : A)*star u)*(u*star u) = u*((x : A)*(star u*u))*star u := by noncomm_ring
        _ = u*(x : A)*star u := by rw [hu,x.property.2]⟩
  invFun y := ⟨star u*(y : A)*u,by
    constructor
    · rw [← hu]
      calc
        (star u*u)*(star u*(y : A)*u) = star u*((u*star u)*(y : A))*u := by noncomm_ring
        _ = star u*(y : A)*u := by rw [hu',y.property.1]
    · rw [← hu]
      calc
        (star u*(y : A)*u)*(star u*u) = star u*((y : A)*(u*star u))*u := by noncomm_ring
        _ = star u*(y : A)*u := by rw [hu',y.property.2]⟩
  left_inv x := by
    apply Subtype.ext
    change star u*(u*(x : A)*star u)*u = (x : A)
    rw [← mul_assoc,← mul_assoc,hu,x.property.1,mul_assoc,hu,x.property.2]
  right_inv y := by
    apply Subtype.ext
    change u*(star u*(y : A)*u)*star u = (y : A)
    rw [← mul_assoc,← mul_assoc,hu',y.property.1,mul_assoc,hu',y.property.2]
  map_mul' x y := by
    apply Subtype.ext
    change u*((x : A)*(y : A))*star u = (u*(x : A)*star u)*(u*(y : A)*star u)
    simp only [mul_assoc]
    rw [← mul_assoc (star u),hu,← mul_assoc p,y.property.1]
  map_add' x y := by
    apply Subtype.ext
    change u*((x : A)+(y : A))*star u = _
    simp only [mul_add,add_mul]
    rfl
  map_smul' z x := by
    apply Subtype.ext
    change u*(z • (x : A))*star u = _
    simp only [mul_smul_comm,smul_mul_assoc]
    rfl
  map_star' x := by
    apply Subtype.ext
    change u*star (x : A)*star u = star (u*(x : A)*star u)
    simp only [star_mul,star_star,mul_assoc]

 theorem equivalentCorner_trace (p q : A) (hp : IsStarProjection p) (hq : IsStarProjection q)
    (u : A) (hu : star u*u=p) (hu' : u*star u=q)
    (τ : A → ℂ) (hτ : ∀ x y, τ (x*y)=τ (y*x)) (t : ℝ) (x : Corner p hp) :
    normalizedCornerTrace τ t q hq (equivalentCorner p q hp hq u hu hu' x) =
      normalizedCornerTrace τ t p hp x := by
  change (t : ℂ)⁻¹ * τ (u*(x : A)*star u) = (t : ℂ)⁻¹ * τ (x : A)
  rw [hτ,← mul_assoc,hu,x.property.1]

 theorem equivalentCorner_normal (p q : A) (hp : IsStarProjection p) (hq : IsStarProjection q)
    (u : A) (hu : star u*u=p) (hu' : u*star u=q)
    (𝒯 : TopologicalSpace A)
    (hmul : @Continuous _ _ 𝒯 𝒯 (fun x : A => u*x*star u)) :
    @Continuous _ _ (cornerTopology 𝒯 p hp) (cornerTopology 𝒯 q hq)
      (equivalentCorner p q hp hq u hu hu') := by
  let : TopologicalSpace A := 𝒯
  let : TopologicalSpace (Corner p hp) := cornerTopology 𝒯 p hp
  let : TopologicalSpace (Corner q hq) := cornerTopology 𝒯 q hq
  exact (hmul.comp continuous_subtype_val).subtype_mk _

end
section
open scoped ENNReal ComplexConjugate
local instance (α : Type u_10) : DecidableEq α := Classical.decEq α

variable {I : Type u_11} {J : Type u_12}
end
section
open scoped ENNReal

local instance (α : Type u_13) : DecidableEq α := Classical.decEq α
variable {I : Type u_14} {J : Type u_15}

def contractionFamilyValue (A : I → GroupOperator J) (hA : ∀ i, ‖A i‖ ≤ 1)
    (ξ : NestedHilbert I J) : NestedHilbert I J :=
  ⟨fun i => A i (ξ i),(lp.memℓp ξ).norm.mono (fun i =>
    ((A i).le_opNorm (ξ i)).trans (by simpa using mul_le_mul_of_nonneg_right (hA i) (norm_nonneg (ξ i))))⟩

theorem contractionFamilyValue_norm_le (A : I → GroupOperator J) (hA : ∀ i, ‖A i‖ ≤ 1)
    (ξ : NestedHilbert I J) : ‖contractionFamilyValue A hA ξ‖ ≤ ‖ξ‖ := by
  apply lp.norm_mono (by norm_num : (2 : ℝ≥0∞) ≠ 0)
  intro i
  exact ((A i).le_opNorm (ξ i)).trans (by simpa using mul_le_mul_of_nonneg_right (hA i) (norm_nonneg (ξ i)))

def contractionFamily (A : I → GroupOperator J) (hA : ∀ i, ‖A i‖ ≤ 1) :
    NestedHilbert I J →L[ℂ] NestedHilbert I J :=
  LinearMap.mkContinuous
    { toFun := contractionFamilyValue A hA
      map_add' := fun ξ η => by ext i j; exact congrArg (fun v : GroupHilbert J => v j) (map_add (A i) (ξ i) (η i))
      map_smul' := fun z ξ => by ext i j; exact congrArg (fun v : GroupHilbert J => v j) (map_smul (A i) z (ξ i)) }
    1 (fun ξ => by simpa using contractionFamilyValue_norm_le A hA ξ)

@[simp] theorem contractionFamily_apply (A : I → GroupOperator J) (hA : ∀ i, ‖A i‖ ≤ 1)
    (ξ : NestedHilbert I J) (i : I) : contractionFamily A hA ξ i = A i (ξ i) := rfl

theorem contractionFamily_star (A : I → GroupOperator J) (hA : ∀ i, ‖A i‖ ≤ 1) :
    contractionFamily (fun i => star (A i)) (by intro i; exact (norm_star (A i)).le.trans (hA i)) =
      star (contractionFamily A hA) := by
  apply ContinuousLinearMap.ext
  intro ξ
  apply ext_inner_right ℂ
  intro η
  change inner ℂ (contractionFamily (fun i => star (A i)) _ ξ) η =
    inner ℂ ((ContinuousLinearMap.adjoint (contractionFamily A hA)) ξ) η
  rw [ContinuousLinearMap.adjoint_inner_left]
  simp only [lp.inner_eq_tsum,contractionFamily_apply]
  apply tsum_congr
  intro i
  simpa only [ContinuousLinearMap.star_eq_adjoint,lp.inner_eq_tsum] using
    ContinuousLinearMap.adjoint_inner_left (A i) (η i) (ξ i)

theorem contractionFamily_projection (A : I → GroupOperator J) (hA : ∀ i, ‖A i‖ ≤ 1)
    (hp : ∀ i, IsStarProjection (A i)) : IsStarProjection (contractionFamily A hA) := by
  constructor
  · apply ContinuousLinearMap.ext
    intro ξ
    ext i j
    change (A i) (A i (ξ i)) j = A i (ξ i) j
    exact congrArg (fun B : GroupOperator J => B (ξ i) j) (hp i).isIdempotentElem.eq
  · change star (contractionFamily A hA) = contractionFamily A hA
    rw [← contractionFamily_star]
    congr 1
    funext i
    exact (hp i).isSelfAdjoint.star_eq

def productFamily (A : I → GroupOperator J) (hA : ∀ i, ‖A i‖ ≤ 1) : GroupOperator (I × J) :=
  (hilbertFlatten I J).conjStarAlgEquiv (contractionFamily A hA)

@[simp] theorem productFamily_apply (A : I → GroupOperator J) (hA : ∀ i, ‖A i‖ ≤ 1)
    (ξ : GroupHilbert (I × J)) (i : I) (j : J) :
    productFamily A hA ξ (i,j) = A i ((hilbertFlatten I J).symm ξ i) j := by
  change hilbertFlatten I J (contractionFamily A hA ((hilbertFlatten I J).symm ξ)) (i,j) = _
  rw [hilbertFlatten_apply,contractionFamily_apply]

theorem productFamily_projection (A : I → GroupOperator J) (hA : ∀ i, ‖A i‖ ≤ 1)
    (hp : ∀ i, IsStarProjection (A i)) : IsStarProjection (productFamily A hA) :=
  (contractionFamily_projection A hA hp).map (hilbertFlatten I J).conjStarAlgEquiv

variable {G : Type u_16} [Group G]

theorem productFamily_mem_stabilization (A : ℕ → groupVonNeumann G)
    (hA : ∀ i, ‖(A i : GroupOperator G)‖ ≤ 1) :
    productFamily (fun i => (A i : GroupOperator G)) hA ∈ stabilization G := by
  rw [stabilization,StarSubalgebra.mem_centralizer_iff,stabilizedRightTranslations_eq_range]
  intro S hS
  obtain ⟨g,rfl⟩ := hS
  have hc (g : G) : productAmplification ℕ G (rightRegular g) *
      productFamily (fun i => (A i : GroupOperator G)) hA =
      productFamily (fun i => (A i : GroupOperator G)) hA *
        productAmplification ℕ G (rightRegular g) := by
    apply ContinuousLinearMap.ext
    intro ξ
    ext x
    rcases x with ⟨i,j⟩
    simp only [mul_apply_eq_comp,productAmplification_apply,productFamily_apply,
      rightRegular_apply,hilbertFlatten_symm_apply]
    have he : (hilbertFlatten ℕ G).symm (productAmplification ℕ G (rightRegular g) ξ) i =
        rightRegular g ((hilbertFlatten ℕ G).symm ξ i) := by
      ext k
      simp only [productAmplification_apply,hilbertFlatten_symm_apply,rightRegular_apply]
    rw [he]
    simpa only [mul_apply_eq_comp,rightRegular_apply] using congrArg
      (fun B : GroupOperator G => B ((hilbertFlatten ℕ G).symm ξ i) j)
      (groupVN_commute_right (A i) g)
  constructor
  · exact hc g
  · rw [← map_star,rightRegular_star]
    exact hc g⁻¹

end
section
open scoped ENNReal
variable {I : Type u_17} {J : Type u_18}

def productSingle (I : Type u_19) (J : Type u_20) (j : I) : GroupHilbert J →L[ℂ] GroupHilbert (I × J) := by
  classical
  exact (hilbertFlatten I J).toContinuousLinearEquiv.toContinuousLinearMap.comp
    (lp.singleContinuousLinearMap ℂ (fun _ : I => GroupHilbert J) 2 j)

@[simp] theorem productSingle_apply [DecidableEq I] (j i : I) (ξ : GroupHilbert J) (k : J) :
    productSingle I J j ξ (i,k) = if i = j then ξ k else 0 := by
  classical
  by_cases hi : i = j <;> simp [productSingle,hilbertFlatten_apply,lp.single_apply,hi]

def matrixEntry (T : GroupOperator (I × J)) (i j : I) : GroupOperator J :=
  (lp.evalCLM ℂ (fun _ : I => GroupHilbert J) 2 i).comp
    ((hilbertFlatten I J).symm.toContinuousLinearEquiv.toContinuousLinearMap.comp
      (T.comp (productSingle I J j)))

@[simp] theorem matrixEntry_apply (T : GroupOperator (I × J)) (i j : I)
    (ξ : GroupHilbert J) (k : J) :
    matrixEntry T i j ξ k = T (productSingle I J j ξ) (i,k) := by
  exact hilbertFlatten_symm_apply _ _ _

theorem productSingle_single [DecidableEq I] [DecidableEq J] [DecidableEq (I × J)]
    (j : I) (g : J) : productSingle I J j (lp.single 2 g 1) = lp.single 2 (j,g) 1 := by
  classical
  ext x
  rcases x with ⟨i,k⟩
  simp only [productSingle_apply,lp.single_apply,Pi.single_apply,Prod.mk.injEq]
  split_ifs <;> simp_all

theorem matrixEntry_ext (T U : GroupOperator (I × J))
    (h : ∀ i j, matrixEntry T i j = matrixEntry U i j) : T = U := by
  classical
  apply operator_matrix_ext
  intro x
  rcases x with ⟨j,g⟩
  rw [← productSingle_single]
  ext y
  rcases y with ⟨i,k⟩
  simpa only [matrixEntry_apply] using congrArg (fun A : GroupOperator J => A (lp.single 2 g 1) k) (h i j)

theorem productAmplification_productSingle (S : GroupOperator J) (j : I) (ξ : GroupHilbert J) :
    productAmplification I J S (productSingle I J j ξ) = productSingle I J j (S ξ) := by
  classical
  ext x
  rcases x with ⟨i,k⟩
  rw [productAmplification_apply,productSingle_apply]
  have he : (hilbertFlatten I J).symm (productSingle I J j ξ) i = if i=j then ξ else 0 := by
    ext l
    simp only [hilbertFlatten_symm_apply,productSingle_apply]
    split_ifs <;> rfl
  rw [he]
  split_ifs <;> simp

theorem matrixEntry_diagonal_mul (S : GroupOperator J) (T : GroupOperator (I × J)) (i j : I) :
    matrixEntry (productAmplification I J S * T) i j = S * matrixEntry T i j := by
  apply ContinuousLinearMap.ext
  intro ξ
  ext k
  simp only [matrixEntry_apply,mul_apply_eq_comp,productAmplification_apply]
  rfl

theorem matrixEntry_mul_diagonal (S : GroupOperator J) (T : GroupOperator (I × J)) (i j : I) :
    matrixEntry (T * productAmplification I J S) i j = matrixEntry T i j * S := by
  apply ContinuousLinearMap.ext
  intro ξ
  ext k
  simp only [matrixEntry_apply,mul_apply_eq_comp,productAmplification_productSingle]

variable {G : Type u_21} [Group G]

theorem mem_stabilization_iff_matrix (T : GroupOperator (ℕ × G)) :
    T ∈ stabilization G ↔ ∀ i j, matrixEntry T i j ∈ groupVonNeumann G := by
  rw [stabilization,StarSubalgebra.mem_centralizer_iff,stabilizedRightTranslations_eq_range]
  constructor
  · intro h i j
    rw [mem_groupVN_iff_commute_right]
    intro g
    have hh := (h _ ⟨g,rfl⟩).1
    have he := congrArg (fun A => matrixEntry A i j) hh
    simpa only [matrixEntry_diagonal_mul,matrixEntry_mul_diagonal] using he
  · intro h S hS
    obtain ⟨g,rfl⟩ := hS
    have hc (g : G) : productAmplification ℕ G (rightRegular g) * T =
        T * productAmplification ℕ G (rightRegular g) := by
      apply matrixEntry_ext
      intro i j
      rw [matrixEntry_diagonal_mul,matrixEntry_mul_diagonal]
      exact (mem_groupVN_iff_commute_right _).mp (h i j) g
    exact ⟨hc g,by rw [← map_star,rightRegular_star]; exact hc g⁻¹⟩

end
section
variable {I : Type u_22} {J : Type u_23}

 def productCoordinate (I : Type u_24) (J : Type u_25) (i : I) : GroupHilbert (I × J) →L[ℂ] GroupHilbert J :=
  (lp.evalCLM ℂ (fun _ : I => GroupHilbert J) 2 i).comp
    (hilbertFlatten I J).symm.toContinuousLinearEquiv.toContinuousLinearMap

 theorem productCoordinate_apply (i : I) (ξ : GroupHilbert (I × J)) (j : J) :
    productCoordinate I J i ξ j=ξ (i,j) := hilbertFlatten_symm_apply _ _ _

 def matrixUnit (I : Type u_26) (J : Type u_27) (i j : I) : GroupOperator (I × J) :=
  (productSingle I J i).comp (productCoordinate I J j)

 theorem matrixUnit_apply [DecidableEq I] (i j k : I) (ξ : GroupHilbert (I × J)) (g : J) :
    matrixUnit I J i j ξ (k,g)=if k=i then ξ (j,g) else 0 := by
  simp only [matrixUnit,ContinuousLinearMap.comp_apply,productSingle_apply,productCoordinate_apply]

 theorem matrixUnit_productSingle [DecidableEq I] (i j l : I) (ξ : GroupHilbert J) :
    matrixUnit I J i j (productSingle I J l ξ)=if j=l then productSingle I J i ξ else 0 := by
  by_cases h : j=l
  · subst l
    rw [ite_eq_left rfl]
    ext x
    rcases x with ⟨k,g⟩
    simp only [matrixUnit_apply,productSingle_apply,ite_true]
  · rw [ite_eq_right h]
    ext x
    rcases x with ⟨k,g⟩
    simp only [matrixUnit_apply,productSingle_apply,ite_eq_right h,ite_self,lp.coeFn_zero,Pi.zero_apply]

 theorem matrixEntry_matrixUnit_mul [DecidableEq I] (i j k l : I) (T : GroupOperator (I × J)) :
    matrixEntry (matrixUnit I J i j*T) k l=if k=i then matrixEntry T j l else 0 := by
  apply ContinuousLinearMap.ext
  intro ξ
  ext g
  simp only [matrixEntry_apply,mul_apply_eq_comp,matrixUnit_apply]
  split_ifs <;> simp only [matrixEntry_apply,zero_apply,lp.coeFn_zero,Pi.zero_apply]

 theorem matrixEntry_mul_matrixUnit [DecidableEq I] (i j k l : I) (T : GroupOperator (I × J)) :
    matrixEntry (T*matrixUnit I J i j) k l=if j=l then matrixEntry T k i else 0 := by
  apply ContinuousLinearMap.ext
  intro ξ
  ext g
  simp only [matrixEntry_apply,mul_apply_eq_comp,matrixUnit_productSingle]
  split_ifs <;> simp

 theorem matrixEntry_matrixUnit [DecidableEq I] (i j k l : I) :
    matrixEntry (matrixUnit I J i j) k l=if k=i ∧ j=l then 1 else 0 := by
  apply ContinuousLinearMap.ext
  intro ξ
  ext g
  simp only [matrixEntry_apply,matrixUnit_apply,productSingle_apply]
  split_ifs <;> simp_all

 theorem matrixEntry_productAmplification [DecidableEq I] (S : GroupOperator J) (i j : I) :
    matrixEntry (productAmplification I J S) i j=if i=j then S else 0 := by
  apply ContinuousLinearMap.ext
  intro ξ
  ext g
  rw [matrixEntry_apply,productAmplification_productSingle,productSingle_apply]
  split_ifs <;> rfl

 variable {G : Type u_28} [Group G]

 theorem matrixUnit_mem_stabilization (i j : ℕ) : matrixUnit ℕ G i j ∈ stabilization G := by
  rw [mem_stabilization_iff_matrix]
  intro k l
  rw [matrixEntry_matrixUnit]
  split_ifs
  · exact one_mem _
  · exact zero_mem _

 theorem diagonal_mem_stabilization (S : groupVonNeumann G) :
    productAmplification ℕ G (S : GroupOperator G) ∈ stabilization G := by
  rw [mem_stabilization_iff_matrix]
  intro k l
  rw [matrixEntry_productAmplification]
  split_ifs
  · exact S.property
  · exact zero_mem _

 theorem stabilization_center_diagonal (T : stabilization G)
    (hc : ∀ S : stabilization G, Commute T S) :
    (T : GroupOperator (ℕ × G))=productAmplification ℕ G (matrixEntry (T : GroupOperator (ℕ × G)) 0 0) := by
  have hm (i j : ℕ) : (T : GroupOperator (ℕ × G))*matrixUnit ℕ G i j=
      matrixUnit ℕ G i j*(T : GroupOperator (ℕ × G)) :=
    congrArg (fun A : stabilization G => (A : GroupOperator (ℕ × G))) (hc ⟨_,matrixUnit_mem_stabilization i j⟩).eq
  have hoff (i j : ℕ) (hij : i ≠ j) : matrixEntry (T : GroupOperator (ℕ × G)) i j=0 := by
    have he := congrArg (fun A => matrixEntry A i j) (hm j j)
    simpa only [matrixEntry_mul_matrixUnit,matrixEntry_matrixUnit_mul,ite_true,ite_eq_right hij] using he
  have hdiag (i : ℕ) : matrixEntry (T : GroupOperator (ℕ × G)) i i=matrixEntry (T : GroupOperator (ℕ × G)) 0 0 := by
    have he := congrArg (fun A => matrixEntry A i 0) (hm i 0)
    simpa only [matrixEntry_mul_matrixUnit,matrixEntry_matrixUnit_mul,ite_true] using he
  apply matrixEntry_ext
  intro i j
  rw [matrixEntry_productAmplification]
  split_ifs with hij
  · subst j
    exact hdiag i
  · exact hoff i j hij

 theorem stabilization_center_scalar
    (hbase : ∀ T : groupVonNeumann G, (∀ S : groupVonNeumann G, Commute T S) →
      ∃ c : ℂ, T=c • (1 : groupVonNeumann G))
    (T : stabilization G) (hc : ∀ S : stabilization G, Commute T S) :
    ∃ c : ℂ, (T : GroupOperator (ℕ × G))=c • (1 : GroupOperator (ℕ × G)) := by
  let A : groupVonNeumann G := ⟨matrixEntry (T : GroupOperator (ℕ × G)) 0 0,
    (mem_stabilization_iff_matrix _).mp T.property 0 0⟩
  have hA : ∀ S : groupVonNeumann G, Commute A S := by
    intro S
    apply Subtype.ext
    have he := congrArg (fun U : stabilization G => matrixEntry (U : GroupOperator (ℕ × G)) 0 0)
      (hc ⟨_,diagonal_mem_stabilization S⟩).eq
    change matrixEntry ((T : GroupOperator (ℕ × G))*productAmplification ℕ G (S : GroupOperator G)) 0 0=
      matrixEntry (productAmplification ℕ G (S : GroupOperator G)*(T : GroupOperator (ℕ × G))) 0 0 at he
    change matrixEntry (T : GroupOperator (ℕ × G)) 0 0*(S : GroupOperator G)=
      (S : GroupOperator G)*matrixEntry (T : GroupOperator (ℕ × G)) 0 0
    simpa only [matrixEntry_mul_diagonal,matrixEntry_diagonal_mul] using he
  obtain ⟨c,hcA⟩ := hbase A hA
  refine ⟨c,?_⟩
  rw [stabilization_center_diagonal T hc]
  have he : matrixEntry (T : GroupOperator (ℕ × G)) 0 0=c • (1 : GroupOperator G) :=
    congrArg (fun U : groupVonNeumann G => (U : GroupOperator G)) hcA
  rw [he,map_smul,map_one]

 theorem stabilization_center_projection
    (hbase : ∀ T : groupVonNeumann G, (∀ S : groupVonNeumann G, Commute T S) →
      ∃ c : ℂ, T=c • (1 : groupVonNeumann G))
    (P : GroupOperator (ℕ × G)) (hP : P ∈ stabilization G) (hp : IsStarProjection P)
    (hc : ∀ S ∈ stabilization G, Commute P S) : P=0 ∨ P=1 := by
  classical
  have hc' : ∀ S : stabilization G, Commute (⟨P,hP⟩ : stabilization G) S :=
    fun S => Subtype.ext (hc S S.property).eq
  obtain ⟨c,he⟩ := stabilization_center_scalar hbase ⟨P,hP⟩ hc'
  change P=c • (1 : GroupOperator (ℕ × G)) at he
  have hh := congrArg (fun A : GroupOperator (ℕ × G) => A (lp.single 2 (0,1) (1 : ℂ)) (0,1)) hp.isIdempotentElem
  rw [he] at hh
  have hcc : c*c=c := by
    change c*(c*(lp.single 2 (0,1) (1 : ℂ) : GroupHilbert (ℕ × G)) (0,1))=
      c*(lp.single 2 (0,1) (1 : ℂ) : GroupHilbert (ℕ × G)) (0,1) at hh
    simpa only [lp.single_apply,Pi.single_eq_same,mul_one] using hh
  have hzero : c*(c-1)=0 := by linear_combination hcc
  rcases mul_eq_zero.mp hzero with hz|ho
  · left
    simpa only [hz,zero_smul ℂ (A := GroupOperator (ℕ × G))] using he
  · right
    have ho : c=1 := sub_eq_zero.mp ho
    simpa only [ho,one_smul] using he

 theorem infinite_stabilization_center_projection (P : GroupOperator (ℕ × FreeGroup ℕ))
    (hP : P ∈ stabilization (FreeGroup ℕ)) (hp : IsStarProjection P)
    (hc : ∀ S ∈ stabilization (FreeGroup ℕ), Commute P S) : P=0 ∨ P=1 :=
  stabilization_center_projection (fun T hT => ⟨canonicalTrace T,infinite_free_group_center_scalar T hT⟩) P hP hp hc

end
open scoped ENNReal
variable {I : Type u_29} {J : Type u_30}

 theorem hilbert_ofReal_norm_sq (ξ : lp (fun _ : I => GroupHilbert J) 2) :
    ENNReal.ofReal (‖ξ‖^2)=∑' i, ENNReal.ofReal (‖ξ i‖^2) := by
  have hs : HasSum (fun i => ‖ξ i‖^2) (‖ξ‖^2) := by
    simpa only [ENNReal.toReal_ofNat,Real.rpow_two] using lp.hasSum_norm (by norm_num : (0:ℝ)<(2:ℝ≥0∞).toReal) ξ
  rw [← hs.tsum_eq,ENNReal.ofReal_tsum_of_nonneg (fun i => sq_nonneg _) hs.summable]

 theorem productSingle_inner_right (i : I) (ξ : GroupHilbert (I × J)) (η : GroupHilbert J) :
    inner ℂ ξ (productSingle I J i η)=inner ℂ (productCoordinate I J i ξ) η := by
  classical
  change inner ℂ ξ ((hilbertFlatten I J) (lp.single 2 i η))=
    inner ℂ (((hilbertFlatten I J).symm ξ) i) η
  have he := (hilbertFlatten I J).inner_map_map ((hilbertFlatten I J).symm ξ) (lp.single 2 i η)
  simpa only [LinearIsometryEquiv.apply_symm_apply,lp.inner_single_right] using he

 theorem productSingle_inner_left (i : I) (ξ : GroupHilbert (I × J)) (η : GroupHilbert J) :
    inner ℂ (productSingle I J i η) ξ=inner ℂ η (productCoordinate I J i ξ) := by
  have he := congrArg (star : ℂ → ℂ) (productSingle_inner_right i ξ η)
  change (starRingEnd ℂ) (inner ℂ ξ (productSingle I J i η))=
    (starRingEnd ℂ) (inner ℂ (productCoordinate I J i ξ) η) at he
  simpa only [inner_conj_symm] using he

 theorem matrixEntry_star (T : GroupOperator (I × J)) (i j : I) :
    matrixEntry (star T) i j=star (matrixEntry T j i) := by
  apply ContinuousLinearMap.ext
  intro ξ
  apply ext_inner_left ℂ
  intro η
  have he (T : GroupOperator (I × J)) (i j : I) (ξ : GroupHilbert J) :
      matrixEntry T i j ξ=productCoordinate I J i (T (productSingle I J j ξ)) := rfl
  rw [he,← productSingle_inner_left,ContinuousLinearMap.star_eq_adjoint,
    ContinuousLinearMap.adjoint_inner_right,productSingle_inner_right]
  change inner ℂ (matrixEntry T j i η) ξ=inner ℂ η (star (matrixEntry T j i) ξ)
  rw [ContinuousLinearMap.star_eq_adjoint,ContinuousLinearMap.adjoint_inner_right]

 variable {G : Type u_31} [Group G] [DecidableEq G]

 theorem stabilizedProjectionTrace_eq_matrix (T : stabilization G) :
    stabilizedProjectionTrace T=∑' j : ℕ, ∑' i : ℕ,
      ENNReal.ofReal (‖matrixEntry (T : GroupOperator (ℕ × G)) i j (lp.single 2 (1 : G) (1 : ℂ))‖^2) := by
  classical
  apply tsum_congr
  intro j
  rw [← (hilbertFlatten ℕ G).symm.norm_map,hilbert_ofReal_norm_sq]
  apply tsum_congr
  intro i
  congr 2
  congr 1
  ext g
  rw [matrixEntry_apply,productSingle_single,hilbertFlatten_symm_apply]
  apply congrArg (fun ξ : GroupHilbert (ℕ × G) => (T : GroupOperator (ℕ × G)) ξ (i,g))
  ext x
  simp only [lp.single_apply,Pi.single_apply]
  split_ifs <;> rfl

 theorem groupVN_adjoint_delta_norm (T : groupVonNeumann G) :
    ‖(star T : GroupOperator G) (lp.single 2 (1 : G) (1 : ℂ))‖^2=
    ‖(T : GroupOperator G) (lp.single 2 (1 : G) (1 : ℂ))‖^2 := by
  classical
  have ht : canonicalTrace (T*star T)=(‖(star T : GroupOperator G) (lp.single 2 (1 : G) (1 : ℂ))‖^2 : ℂ) := by
    simpa only [star_star,StarMemClass.coe_star] using canonicalTrace_star_mul (star T)
  have he' : (‖(T : GroupOperator G) (lp.single 2 (1 : G) (1 : ℂ))‖^2 : ℂ)=
      (‖(star T : GroupOperator G) (lp.single 2 (1 : G) (1 : ℂ))‖^2 : ℂ) := by
    rw [← canonicalTrace_star_mul,← ht]
    exact canonicalTrace_mul (star T) T
  have hh := congrArg Complex.re he'
  simpa only [← Complex.ofReal_pow,Complex.ofReal_re] using hh.symm

 theorem stabilizedProjectionTrace_star (T : stabilization G) :
    stabilizedProjectionTrace (star T)=stabilizedProjectionTrace T := by
  classical
  rw [stabilizedProjectionTrace_eq_matrix,stabilizedProjectionTrace_eq_matrix,ENNReal.tsum_comm]
  apply tsum_congr
  intro i
  apply tsum_congr
  intro j
  congr 1
  simp only [StarMemClass.coe_star]
  rw [matrixEntry_star]
  exact groupVN_adjoint_delta_norm ⟨_,(mem_stabilization_iff_matrix _).mp T.property j i⟩

end FreeGroupFactorMain.Amplification

end

end OAI