| import OAI.Analysis.FreeGroupFactor.Operators |
| import Mathlib.Analysis.InnerProductSpace.l2Space |
| import Mathlib.Analysis.VonNeumannAlgebra.Basic |
| import Mathlib.Tactic.Linarith |
| import Mathlib.Tactic.NormNum |
| import Mathlib.Topology.Order |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace UltrapowerBridge |
|
|
| section |
| open scoped ENNReal Pointwise |
| local instance groupAlgebraDecEq (G : Type*) : DecidableEq G := Classical.decEq _ |
| abbrev Ell2 (G : Type*) := FreeGroupFactorMain.GroupHilbert G |
| abbrev Operator (G : Type*) := FreeGroupFactorMain.GroupOperator G |
| / |
| abbrev reindexVector {G : Type*} (e : G ≃ G) (f : Ell2 G) : Ell2 G := |
| FreeGroupFactorMain.hilbertReindex e f |
|
|
| @[simp] theorem reindexVector_apply {G : Type*} (e : G ≃ G) (f : Ell2 G) (g : G) : |
| reindexVector e f g = f (e.symm g) := rfl |
|
|
| theorem reindexVector_norm {G : Type*} (e : G ≃ G) (f : Ell2 G) : |
| ‖reindexVector e f‖ = ‖f‖ := by |
| exact (FreeGroupFactorMain.hilbertReindex e).norm_map f |
|
|
| / |
| abbrev reindex {G : Type*} (e : G ≃ G) : Ell2 G ≃ₗᵢ[ℂ] Ell2 G := |
| FreeGroupFactorMain.hilbertReindex e |
|
|
| / |
| abbrev leftRegular {G : Type*} [Group G] (g : G) : Ell2 G →L[ℂ] Ell2 G := |
| FreeGroupFactorMain.leftRegular g |
|
|
| @[simp] theorem leftRegular_apply {G : Type*} [Group G] (g b : G) (f : Ell2 G) : |
| leftRegular g f b = f (g⁻¹ * b) := rfl |
|
|
| @[simp] theorem leftRegular_one {G : Type*} [Group G] : leftRegular (1 : G) = 1 := by |
| ext f b |
| simp |
|
|
| @[simp] theorem leftRegular_mul {G : Type*} [Group G] (g h : G) : |
| leftRegular (g * h) = leftRegular g * leftRegular h := by |
| ext f b |
| simp |
|
|
| theorem leftRegular_norm_vector {G : Type*} [Group G] (g : G) (f : Ell2 G) : |
| ‖leftRegular g f‖ = ‖f‖ := reindexVector_norm (Equiv.mulLeft g) f |
|
|
| variable (G : Type*) [Group G] |
|
|
| abbrev regularOperators : Set (Operator G) := FreeGroupFactorMain.leftTranslations G |
| abbrev groupAlgebra : StarSubalgebra ℂ (Operator G) := |
| FreeGroupFactorMain.groupVonNeumann G |
|
|
| def delta : Ell2 G := by |
| classical |
| exact lp.single 2 (1 : G) 1 |
| def trace (T : groupAlgebra G) : ℂ := inner ℂ (delta G) ((T : Operator G) (delta G)) |
|
|
| @[simp] theorem leftRegular_trace (g : G) : |
| inner ℂ (delta G) (leftRegular g (delta G)) = if g = 1 then 1 else 0 := by |
| classical |
| rw [delta, lp.inner_single_left] |
| simp [lp.single_apply, Pi.single_apply] |
|
|
| variable {G} |
| @[simp] theorem leftRegular_star {G : Type*} [Group G] (g : G) : |
| star (leftRegular g) = leftRegular g⁻¹ := by |
| change star ((reindex (Equiv.mulLeft g)) : Ell2 G →L[ℂ] Ell2 G) = _ |
| rw [LinearIsometryEquiv.star_eq_symm] |
| ext f b |
| change f (g * b) = f ((g⁻¹)⁻¹ * b) |
| simp |
|
|
| / |
| def rightRegular {G : Type*} [Group G] (g : G) : Ell2 G →L[ℂ] Ell2 G := |
| (reindex (Equiv.mulRight g)).toContinuousLinearEquiv.toContinuousLinearMap |
|
|
| @[simp] theorem rightRegular_apply {G : Type*} [Group G] (g b : G) (f : Ell2 G) : |
| rightRegular g f b = f (b * g⁻¹) := rfl |
|
|
| theorem left_right_commute {G : Type*} [Group G] (g h : G) : |
| leftRegular g * rightRegular h = rightRegular h * leftRegular g := by |
| ext f b |
| simp [mul_assoc] |
|
|
| theorem regularOperators_star (G : Type*) [Group G] : |
| star (regularOperators G) = regularOperators G := by |
| rw [regularOperators, FreeGroupFactorMain.leftTranslations_eq_range] |
| ext T |
| simp only [Set.mem_star, Set.mem_range] |
| constructor |
| · rintro ⟨g, hg⟩ |
| exact ⟨g⁻¹, by simpa only [leftRegular_star, star_star] using congrArg star hg⟩ |
| · rintro ⟨g, rfl⟩ |
| exact ⟨g⁻¹, (leftRegular_star g).symm⟩ |
|
|
| / |
| theorem groupAlgebra_carrier (G : Type*) [Group G] : |
| (groupAlgebra G : Set (Operator G)) = |
| Set.centralizer (Set.centralizer (regularOperators G)) := by |
| rw [groupAlgebra, FreeGroupFactorMain.groupVonNeumann, |
| StarSubalgebra.coe_centralizer_centralizer, |
| regularOperators_star, Set.union_self] |
|
|
| / |
| abbrev concreteGroupAlgebra (G : Type*) [Group G] : VonNeumannAlgebra (Ell2 G) := |
| FreeGroupFactorMain.groupVonNeumannBundled G |
|
|
| theorem rightRegular_mem_commutant (G : Type*) [Group G] (g : G) : |
| rightRegular g ∈ StarSubalgebra.centralizer ℂ (regularOperators G) := by |
| rw [StarSubalgebra.mem_centralizer_iff] |
| intro T hT |
| rw [regularOperators, FreeGroupFactorMain.leftTranslations_eq_range] at hT |
| obtain ⟨h, rfl⟩ := hT |
| exact ⟨left_right_commute h g, by rw [leftRegular_star]; exact left_right_commute h⁻¹ g⟩ |
|
|
| theorem algebra_right_commute (G : Type*) [Group G] (T : groupAlgebra G) |
| (g : G) : |
| (T : Operator G) * rightRegular g = |
| rightRegular g * (T : Operator G) := by |
| have ht := T.property |
| change (T : Operator G) ∈ StarSubalgebra.centralizer ℂ |
| (StarSubalgebra.centralizer ℂ (regularOperators G) : Set (Operator G)) at ht |
| rw [StarSubalgebra.mem_centralizer_iff] at ht |
| exact (ht (rightRegular g) (rightRegular_mem_commutant G g)).1.symm |
|
|
| theorem rightRegular_delta (G : Type*) [Group G] (g : G) : |
| rightRegular g (delta G) = lp.single 2 g (1 : ℂ) := by |
| classical |
| ext b |
| simp [delta, lp.single_apply, Pi.single_apply, mul_inv_eq_one] |
|
|
| / |
| by commuting with right translations and using the density of finitely supported vectors. -/ |
| theorem delta_separating (G : Type*) [Group G] (T : groupAlgebra G) |
| (hT : (T : Operator G) (delta G) = 0) : T = 0 := by |
| classical |
| apply Subtype.ext |
| change (T : Operator G) = 0 |
| apply lp.ext_continuousLinearMap (by simp) |
| intro g |
| apply ContinuousLinearMap.ext |
| intro c |
| change (T : Operator G) (lp.single 2 g c) = 0 |
| have hs : lp.single 2 g c = c • rightRegular g (delta G) := by |
| rw [rightRegular_delta, ← lp.single_smul] |
| simp |
| have hz : (T : Operator G) (rightRegular g (delta G)) = 0 := by |
| change ((T : Operator G) * rightRegular g) (delta G) = 0 |
| rw [algebra_right_commute] |
| change rightRegular g ((T : Operator G) (delta G)) = 0 |
| rw [hT, map_zero] |
| rw [hs, map_smul, hz, smul_zero] |
|
|
| / |
| theorem trace_star_mul_self (G : Type*) [Group G] (T : groupAlgebra G) : |
| trace G (star T * T) = |
| inner ℂ ((T : Operator G) (delta G)) |
| ((T : Operator G) (delta G)) := by |
| exact ContinuousLinearMap.adjoint_inner_right (T : Operator G) |
| (delta G) ((T : Operator G) (delta G)) |
|
|
| / |
| theorem trace_faithful (G : Type*) [Group G] (T : groupAlgebra G) : |
| trace G (star T * T) = 0 ↔ T = 0 := by |
| rw [trace_star_mul_self, inner_self_eq_zero] |
| constructor |
| · exact delta_separating G T |
| · intro h |
| subst T |
| simp |
|
|
| end |
|
|
| section |
| local instance traceDecEq (G : Type*) : DecidableEq G := Classical.decEq _ |
| open scoped ComplexConjugate |
| variable {G : Type*} [Group G] |
|
|
| @[simp] theorem delta_inner (ξ : Ell2 G) : inner ℂ (delta G) ξ = ξ 1 := by |
| classical |
| simp [delta, lp.inner_single_left] |
|
|
| theorem algebra_apply_single (T : groupAlgebra G) (g b : G) : |
| (T : Operator G) (lp.single 2 g (1 : ℂ)) b = |
| (T : Operator G) (delta G) (b * g⁻¹) := by |
| rw [← rightRegular_delta G g] |
| have h := congrArg (fun S : Operator G => S (delta G) b) (algebra_right_commute G T g) |
| exact h |
|
|
| theorem adjoint_coefficient (T : groupAlgebra G) (g : G) : |
| star (((star T : groupAlgebra G) : Operator G) (delta G) g) = |
| (T : Operator G) (delta G) g⁻¹ := by |
| classical |
| have h := ContinuousLinearMap.adjoint_inner_left (T : Operator G) |
| (lp.single 2 g (1 : ℂ)) (delta G) |
| simpa [lp.inner_single_right, delta_inner, algebra_apply_single, |
| RCLike.inner_apply, ContinuousLinearMap.star_eq_adjoint] using h |
|
|
| theorem trace_mul_formula (S T : groupAlgebra G) : |
| trace G (S * T) = ∑' g : G, |
| (S : Operator G) (delta G) g⁻¹ * (T : Operator G) (delta G) g := by |
| change inner ℂ (delta G) ((S : Operator G) ((T : Operator G) (delta G))) = _ |
| rw [← ContinuousLinearMap.adjoint_inner_left, lp.inner_eq_tsum] |
| apply tsum_congr |
| intro g |
| rw [RCLike.inner_apply] |
| change _ * star (((star S : groupAlgebra G) : Operator G) (delta G) g) = _ |
| rw [adjoint_coefficient, mul_comm] |
|
|
| / |
| theorem trace_mul_comm (S T : groupAlgebra G) : trace G (S * T) = trace G (T * S) := by |
| rw [trace_mul_formula, trace_mul_formula] |
| rw [← (Equiv.inv G).tsum_eq (fun g : G => |
| (T : Operator G) (delta G) g⁻¹ * (S : Operator G) (delta G) g)] |
| apply tsum_congr |
| intro g |
| simp [mul_comm] |
|
|
| @[simp] theorem trace_one : trace G (1 : groupAlgebra G) = 1 := by |
| classical |
| simp [trace, delta] |
|
|
| @[simp] theorem trace_add (S T : groupAlgebra G) : trace G (S + T) = trace G S + trace G T := by |
| exact inner_add_right _ _ _ |
|
|
| @[simp] theorem trace_smul (c : ℂ) (T : groupAlgebra G) : trace G (c • T) = c * trace G T := by |
| exact inner_smul_right _ _ _ |
|
|
| def traceLinear : groupAlgebra G →ₗ[ℂ] ℂ where |
| toFun := trace G |
| map_add' := trace_add |
| map_smul' := trace_smul |
|
|
| / |
| def traceNorm (T : groupAlgebra G) : ℝ := ‖(T : Operator G) (delta G)‖ |
|
|
| theorem traceNorm_sq (T : groupAlgebra G) : |
| traceNorm T ^ 2 = (trace G (star T * T)).re := by |
| rw [trace_star_mul_self] |
| simp [traceNorm, inner_self_eq_norm_sq_to_K, ← Complex.ofReal_pow] |
|
|
| end |
|
|
| section |
| open scoped Topology |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
|
|
| / |
| representation. These are operator-algebra data, without approximation assumptions. -/ |
| structure TracialRepresentation (M : VonNeumannAlgebra H) where |
| vector : H |
| norm_vector : ‖vector‖ = 1 |
| cyclic : ∀ S T : M.toStarSubalgebra, |
| inner ℂ vector ((S : H →L[ℂ] H) ((T : H →L[ℂ] H) vector)) = |
| inner ℂ vector ((T : H →L[ℂ] H) ((S : H →L[ℂ] H) vector)) |
| separating : ∀ T : M.toStarSubalgebra, (T : H →L[ℂ] H) vector = 0 → T = 0 |
|
|
| namespace TracialRepresentation |
| variable {M : VonNeumannAlgebra H} (τ : TracialRepresentation M) |
| abbrev Algebra := M.toStarSubalgebra |
|
|
| def trace (T : Algebra (M := M)) : ℂ := inner ℂ τ.vector ((T : H →L[ℂ] H) τ.vector) |
| def norm₂ (T : Algebra (M := M)) : ℝ := ‖(T : H →L[ℂ] H) τ.vector‖ |
|
|
| @[simp] theorem trace_one : τ.trace 1 = 1 := by |
| simp [trace, inner_self_eq_norm_sq_to_K, τ.norm_vector] |
|
|
| theorem trace_mul_comm (S T : Algebra (M := M)) : τ.trace (S*T) = τ.trace (T*S) := |
| τ.cyclic S T |
|
|
| theorem trace_star_mul (T : Algebra (M := M)) : |
| τ.trace (star T*T) = (τ.norm₂ T : ℂ)^2 := by |
| unfold trace norm₂ |
| change inner ℂ τ.vector ((star (T : H →L[ℂ] H)) ((T : H →L[ℂ] H) τ.vector)) = _ |
| rw [ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_right, inner_self_eq_norm_sq_to_K] |
| norm_cast |
|
|
| theorem norm₂_star (T : Algebra (M := M)) : τ.norm₂ (star T) = τ.norm₂ T := by |
| have h := τ.trace_mul_comm (star T) T |
| have h2 := τ.trace_star_mul (star T) |
| simp only [star_star] at h2 |
| rw [τ.trace_star_mul, h2] at h |
| have hr := congrArg Complex.re h |
| simp only [← Complex.ofReal_pow, Complex.ofReal_re] at hr |
| have hn : 0 ≤ τ.norm₂ T := norm_nonneg _ |
| have hs : 0 ≤ τ.norm₂ (star T) := norm_nonneg _ |
| nlinarith |
|
|
| @[simp] theorem norm₂_zero : τ.norm₂ 0 = 0 := by simp [norm₂] |
| @[simp] theorem norm₂_sub (S T : Algebra (M := M)) : |
| τ.norm₂ (S-T) = ‖(S : H →L[ℂ] H) τ.vector - (T : H →L[ℂ] H) τ.vector‖ := rfl |
|
|
| theorem norm₂_add_le (S T : Algebra (M := M)) : τ.norm₂ (S+T) ≤ τ.norm₂ S+τ.norm₂ T := |
| norm_add_le _ _ |
|
|
| theorem norm₂_smul (c : ℂ) (T : Algebra (M := M)) : τ.norm₂ (c • T) = ‖c‖*τ.norm₂ T := |
| norm_smul _ _ |
|
|
| theorem norm₂_mul_le (S T : Algebra (M := M)) : τ.norm₂ (S*T) ≤ ‖S‖ * τ.norm₂ T := |
| (S : H →L[ℂ] H).le_opNorm ((T : H →L[ℂ] H) τ.vector) |
|
|
| theorem norm₂_mul_le_right (S T : Algebra (M := M)) : τ.norm₂ (S*T) ≤ τ.norm₂ S * ‖T‖ := by |
| rw [← τ.norm₂_star (S*T), star_mul] |
| have h := τ.norm₂_mul_le (star T) (star S) |
| simpa [τ.norm₂_star, mul_comm, ContinuousLinearMap.star_eq_adjoint] using h |
|
|
| theorem norm₂_le_norm (T : Algebra (M := M)) : τ.norm₂ T ≤ ‖T‖ := by |
| have h := (T : H →L[ℂ] H).le_opNorm τ.vector |
| simpa [norm₂, τ.norm_vector] using h |
|
|
| theorem norm_trace_le_norm₂ (T : Algebra (M := M)) : ‖τ.trace T‖ ≤ τ.norm₂ T := by |
| simpa [trace, norm₂, τ.norm_vector] using norm_inner_le_norm τ.vector ((T : H →L[ℂ] H) τ.vector) |
|
|
| theorem norm₂_eq_zero_iff (T : Algebra (M := M)) : τ.norm₂ T = 0 ↔ T = 0 := by |
| constructor |
| · intro h |
| exact τ.separating T (norm_eq_zero.mp h) |
| · rintro rfl |
| exact τ.norm₂_zero |
|
|
| end TracialRepresentation |
|
|
| local instance finiteTraceDecEq (G : Type*) : DecidableEq G := Classical.decEq _ |
| / |
| approximation, ICC, factor, or countability premise occurs. -/ |
| def groupTracialRepresentation (G : Type*) [Group G] : |
| TracialRepresentation (concreteGroupAlgebra G) where |
| vector := delta G |
| norm_vector := by simp [delta, lp.norm_single] |
| cyclic := trace_mul_comm |
| separating := delta_separating G |
|
|
| end |
|
|
| variable (H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H] |
|
|
| / |
| functionals. No continuity of a chosen trace is built into this definition. -/ |
| @[instance_reducible] def ultraweakTopology : TopologicalSpace (H →L[ℂ] H) := |
| ⨅ (ξ : ℕ → H) (η : ℕ → H) (_ : Summable (fun n => ‖ξ n‖ * ‖η n‖)), |
| TopologicalSpace.induced (fun T : H →L[ℂ] H => ∑' n, inner ℂ (ξ n) (T (η n))) |
| inferInstance |
|
|
| variable {H} |
| omit [CompleteSpace H] in |
| theorem vectorFunctional_ultraweak_continuous (ξ η : H) : |
| @Continuous _ _ (ultraweakTopology H) inferInstance |
| (fun T : H →L[ℂ] H => inner ℂ ξ (T η)) := by |
| let x : ℕ → H := fun n => if n = 0 then ξ else 0 |
| let y : ℕ → H := fun n => if n = 0 then η else 0 |
| have hs : Summable (fun n => ‖x n‖ * ‖y n‖) := by |
| exact (hasSum_ite_eq (0 : ℕ) (‖ξ‖ * ‖η‖)).summable.congr (by intro n; by_cases h : n = 0 <;> simp [x,y,h]) |
| have hc : @Continuous _ _ (ultraweakTopology H) inferInstance |
| (fun T : H →L[ℂ] H => ∑' n, inner ℂ (x n) (T (y n))) := |
| continuous_iInf_dom (i := x) (continuous_iInf_dom (i := y) |
| (continuous_iInf_dom (i := hs) continuous_induced_dom)) |
| have he (T : H →L[ℂ] H) : |
| (fun n => inner ℂ (x n) (T (y n))) = |
| (fun n => if n = 0 then inner ℂ ξ (T η) else 0) := by |
| funext n |
| by_cases h : n = 0 <;> simp [x,y,h] |
| have hf : (fun T : H →L[ℂ] H => ∑' n, inner ℂ (x n) (T (y n))) = |
| (fun T => inner ℂ ξ (T η)) := by |
| funext T |
| rw [he] |
| exact tsum_ite_eq 0 _ |
| rw [hf] at hc |
| exact hc |
|
|
| @[instance_reducible] def algebraUltraweakTopology (M : VonNeumannAlgebra H) : |
| TopologicalSpace M.toStarSubalgebra := |
| TopologicalSpace.induced (fun T : M.toStarSubalgebra => (T : H →L[ℂ] H)) (ultraweakTopology H) |
|
|
| / |
| theorem TracialRepresentation.trace_normal {M : VonNeumannAlgebra H} |
| (τ : TracialRepresentation M) : |
| @Continuous _ _ (algebraUltraweakTopology M) inferInstance τ.trace := |
| @Continuous.comp _ _ _ (algebraUltraweakTopology M) (ultraweakTopology H) _ |
| _ _ (vectorFunctional_ultraweak_continuous τ.vector τ.vector) continuous_induced_dom |
|
|
| end UltrapowerBridge |
|
|
| end |
|
|
| end OAI |
|
|
