Download lean/OAI/Analysis/FreeGroupFactor/NormalExtension.lean from roseking/openAI-math-dataset: direct link, hf CLI and curl.
- Browser
- Download file 19.5 kB
-
https://huggingface.co/datasets/roseking/openAI-math-dataset/resolve/main/lean/OAI/Analysis/FreeGroupFactor/NormalExtension.lean
- Command line
-
hf download hf://datasets/roseking/openAI-math-dataset/lean/OAI/Analysis/FreeGroupFactor/NormalExtension.lean
-
curl -L -o NormalExtension.lean https://huggingface.co/datasets/roseking/openAI-math-dataset/resolve/main/lean/OAI/Analysis/FreeGroupFactor/NormalExtension.lean
19.5 kB
| import OAI.Analysis.FreeGroupFactor.MomentFlow | |
| namespace OAI | |
| namespace FreeGroupFactorMain | |
| noncomputable section | |
| universe uG uH | |
| open Set Metric Filter | |
| open scoped NNReal Topology BigOperators ContDiff | |
| open scoped ComplexConjugate | |
| abbrev deltaOne {G : Type uG} [Group G] : GroupHilbert G := by | |
| classical | |
| exact lp.single 2 1 1 | |
| theorem deltaOne_eq {G : Type uG} [Group G] [DecidableEq G] : | |
| (deltaOne : GroupHilbert G) = lp.single 2 1 1 := by | |
| ext x | |
| simp [deltaOne, lp.single_apply, Pi.single_apply] | |
| theorem groupVN_matrix {G : Type uG} [Group G] [DecidableEq G] | |
| (T : groupVonNeumann G) (x y : G) : | |
| ((T : GroupOperator G) (lp.single 2 y 1)) x = | |
| ((T : GroupOperator G) deltaOne) (x * y⁻¹) := by | |
| have hr : rightRegular y⁻¹ deltaOne = lp.single 2 y 1 := by | |
| ext b | |
| simp [deltaOne, lp.single_apply, Pi.single_apply, mul_inv_eq_one] | |
| rw [← hr] | |
| have hc := congrArg (fun f : GroupOperator G => f deltaOne) | |
| (groupVN_commute_right T y⁻¹) | |
| simpa only [mul_apply_eq_comp, rightRegular_apply] using | |
| congrArg (fun v : GroupHilbert G => v x) hc.symm | |
| theorem groupVN_star_coefficient {G : Type uG} [Group G] [DecidableEq G] | |
| (T : groupVonNeumann G) (x : G) : | |
| ((star T : GroupOperator G) deltaOne) x = | |
| conj (((T : GroupOperator G) deltaOne) x⁻¹) := by | |
| calc | |
| ((star T : GroupOperator G) deltaOne) x = | |
| inner ℂ (lp.single 2 x (1 : ℂ)) ((star T : GroupOperator G) deltaOne) := by | |
| simp only [lp.inner_single_left, RCLike.inner_apply, map_one, mul_one] | |
| _ = inner ℂ ((T : GroupOperator G) (lp.single 2 x 1)) deltaOne := by | |
| exact ContinuousLinearMap.adjoint_inner_right _ _ _ | |
| _ = conj (((T : GroupOperator G) (lp.single 2 x 1)) 1) := by | |
| simp only [deltaOne, lp.inner_single_right, RCLike.inner_apply, one_mul] | |
| _ = _ := by rw [groupVN_matrix]; simp | |
| theorem canonicalTrace_star_mul_inner {G : Type uG} [Group G] [DecidableEq G] | |
| (T U : groupVonNeumann G) : | |
| canonicalTrace (star T * U) = inner ℂ | |
| ((T : GroupOperator G) deltaOne) ((U : GroupOperator G) deltaOne) := by | |
| classical | |
| rw [canonicalTrace_eq_inner, ← deltaOne_eq] | |
| change inner ℂ deltaOne (star (T : GroupOperator G) ((U : GroupOperator G) deltaOne)) = _ | |
| rw [ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_right] | |
| theorem canonicalTrace_mul {G : Type uG} [Group G] [DecidableEq G] | |
| (T U : groupVonNeumann G) : canonicalTrace (T * U) = canonicalTrace (U * T) := by | |
| have he (T U : groupVonNeumann G) : | |
| canonicalTrace (T * U) = ∑' x : G, | |
| ((T : GroupOperator G) deltaOne) x⁻¹ * ((U : GroupOperator G) deltaOne) x := by | |
| rw [← star_star T, canonicalTrace_star_mul_inner] | |
| change (∑' x, inner ℂ (((star T : GroupOperator G) deltaOne) x) | |
| (((U : GroupOperator G) deltaOne) x)) = _ | |
| apply tsum_congr | |
| intro x | |
| rw [groupVN_star_coefficient] | |
| simp [RCLike.inner_apply, mul_comm] | |
| rw [he, he] | |
| simpa only [Equiv.inv_apply, inv_inv, mul_comm] using | |
| ((Equiv.inv G).tsum_eq (fun x => | |
| ((T : GroupOperator G) deltaOne) x⁻¹ * ((U : GroupOperator G) deltaOne) x)).symm | |
| def hilbertSequenceMap {G : Type uG} {H : Type uH} (e : GroupHilbert G ≃ₗᵢ[ℂ] GroupHilbert H) | |
| (ξ : lp (fun _ : ℕ => GroupHilbert G) 2) : | |
| lp (fun _ : ℕ => GroupHilbert H) 2 := | |
| ⟨fun n => e (ξ n), Memℓp.of_norm (by simpa only [e.norm_map] using (lp.memℓp ξ).norm)⟩ | |
| theorem spatial_ultraweak_continuous {G : Type uG} {H : Type uH} | |
| (e : GroupHilbert G ≃ₗᵢ[ℂ] GroupHilbert H) : | |
| @Continuous _ _ (ultraweakOperatorTopology G) (ultraweakOperatorTopology H) | |
| e.conjStarAlgEquiv := by | |
| apply continuous_iInf_rng.mpr | |
| intro ξ | |
| apply continuous_iInf_rng.mpr | |
| intro η | |
| apply continuous_induced_rng.mpr | |
| have heq : | |
| (fun T : GroupOperator G => ∑' k : ℕ, inner ℂ (η k) (e.conjStarAlgEquiv T (ξ k))) = | |
| (fun T : GroupOperator G => ∑' k : ℕ, | |
| inner ℂ (hilbertSequenceMap e.symm η k) (T (hilbertSequenceMap e.symm ξ k))) := by | |
| funext T | |
| apply tsum_congr | |
| intro k | |
| change inner ℂ (η k) (e (T (e.symm (ξ k)))) = | |
| inner ℂ (e.symm (η k)) (T (e.symm (ξ k))) | |
| rw [← e.inner_map_map] | |
| simp | |
| change @Continuous _ _ (ultraweakOperatorTopology G) _ | |
| (fun T : GroupOperator G => ∑' k : ℕ, inner ℂ (η k) (e.conjStarAlgEquiv T (ξ k))) | |
| rw [heq] | |
| exact continuous_iInf_dom (i := hilbertSequenceMap e.symm ξ) | |
| (continuous_iInf_dom (i := hilbertSequenceMap e.symm η) continuous_induced_dom) | |
| def spatialGroupIso {G : Type uG} {H : Type uH} [Group G] [Group H] | |
| (e : GroupHilbert G ≃ₗᵢ[ℂ] GroupHilbert H) | |
| (hVN : ∀ T : GroupOperator G, | |
| T ∈ groupVonNeumann G ↔ e.conjStarAlgEquiv T ∈ groupVonNeumann H) : | |
| groupVonNeumann G ≃⋆ₐ[ℂ] groupVonNeumann H where | |
| toFun T := ⟨e.conjStarAlgEquiv T, (hVN T).mp T.property⟩ | |
| invFun T := ⟨e.conjStarAlgEquiv.symm T, (hVN _).mpr (by rw [e.conjStarAlgEquiv.apply_symm_apply]; exact T.property)⟩ | |
| left_inv T := Subtype.ext (e.conjStarAlgEquiv.symm_apply_apply T) | |
| right_inv T := Subtype.ext (e.conjStarAlgEquiv.apply_symm_apply T) | |
| map_mul' T U := Subtype.ext (map_mul e.conjStarAlgEquiv (T : GroupOperator G) (U : GroupOperator G)) | |
| map_add' T U := Subtype.ext (map_add e.conjStarAlgEquiv (T : GroupOperator G) (U : GroupOperator G)) | |
| map_star' T := Subtype.ext (map_star e.conjStarAlgEquiv (T : GroupOperator G)) | |
| map_smul' c T := Subtype.ext (map_smul e.conjStarAlgEquiv c (T : GroupOperator G)) | |
| theorem spatialGroupIso_normal {G : Type uG} {H : Type uH} [Group G] [Group H] | |
| (e : GroupHilbert G ≃ₗᵢ[ℂ] GroupHilbert H) | |
| (hVN : ∀ T : GroupOperator G, | |
| T ∈ groupVonNeumann G ↔ e.conjStarAlgEquiv T ∈ groupVonNeumann H) : | |
| @Continuous _ _ (groupUltraweakTopology G) (groupUltraweakTopology H) | |
| (spatialGroupIso e hVN) := by | |
| let : TopologicalSpace (GroupOperator G) := ultraweakOperatorTopology G | |
| let : TopologicalSpace (GroupOperator H) := ultraweakOperatorTopology H | |
| let : TopologicalSpace (groupVonNeumann G) := groupUltraweakTopology G | |
| let : TopologicalSpace (groupVonNeumann H) := groupUltraweakTopology H | |
| apply continuous_induced_rng.mpr | |
| have hinc : Continuous (fun T : groupVonNeumann G => (T : GroupOperator G)) := | |
| continuous_induced_dom | |
| exact (spatial_ultraweak_continuous e).comp hinc | |
| theorem normalTracialIso_of_spatial {G : Type uG} {H : Type uH} [Group G] [Group H] | |
| (e : GroupHilbert G ≃ₗᵢ[ℂ] GroupHilbert H) | |
| (hδ : e deltaOne = deltaOne) | |
| (hVN : ∀ T : GroupOperator G, | |
| T ∈ groupVonNeumann G ↔ e.conjStarAlgEquiv T ∈ groupVonNeumann H) : | |
| HasNormalTracialIso G H := by | |
| classical | |
| refine ⟨spatialGroupIso e hVN, fun T => ?_, spatialGroupIso_normal e hVN⟩ | |
| rw [canonicalTrace_eq_inner, canonicalTrace_eq_inner] | |
| change inner ℂ deltaOne (e ((T : GroupOperator G) (e.symm deltaOne))) = | |
| inner ℂ deltaOne ((T : GroupOperator G) deltaOne) | |
| rw [← hδ, e.symm_apply_apply, e.inner_map_map] | |
| open scoped ComplexConjugate ENNReal | |
| theorem operator_matrix_ext {G : Type uG} [DecidableEq G] (T U : GroupOperator G) | |
| (h : ∀ g, T (lp.single 2 g 1) = U (lp.single 2 g 1)) : T = U := by | |
| classical | |
| apply ContinuousLinearMap.ext | |
| intro ξ | |
| have hT := (lp.hasSum_single (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) ξ).mapL T | |
| have hU := (lp.hasSum_single (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) ξ).mapL U | |
| have he (g : G) : T (lp.single 2 g (ξ g)) = U (lp.single 2 g (ξ g)) := by | |
| have hc : lp.single (E := fun _ : G => ℂ) 2 g (ξ g) = | |
| (ξ g) • lp.single (E := fun _ : G => ℂ) 2 g 1 := by | |
| ext b | |
| simp [lp.single_apply, Pi.single_apply] | |
| rw [hc, map_smul, map_smul, h] | |
| simp only [he] at hT | |
| exact hT.unique hU | |
| theorem operator_coeff_tsum {G : Type uG} [DecidableEq G] (T : GroupOperator G) | |
| (ξ : GroupHilbert G) (x : G) : | |
| (T ξ) x = ∑' y : G, (T (lp.single 2 y 1)) x * ξ y := by | |
| calc | |
| (T ξ) x = inner ℂ (lp.single 2 x 1) (T ξ) := by simp [lp.inner_single_left] | |
| _ = inner ℂ (star T (lp.single 2 x 1)) ξ := by | |
| rw [ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_left] | |
| _ = ∑' y : G, (T (lp.single 2 y 1)) x * ξ y := by | |
| rw [lp.inner_eq_tsum] | |
| apply tsum_congr | |
| intro y | |
| have he : conj ((star T (lp.single 2 x 1)) y) = (T (lp.single 2 y 1)) x := by | |
| calc | |
| _ = inner ℂ (star T (lp.single 2 x 1)) (lp.single 2 y 1) := by | |
| simp [lp.inner_single_right] | |
| _ = inner ℂ (lp.single 2 x 1) (T (lp.single 2 y 1)) := by | |
| rw [ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_left] | |
| _ = _ := by simp [lp.inner_single_left] | |
| simp only [RCLike.inner_apply, he, mul_comm] | |
| theorem matrix_of_commute_right {G : Type uG} [Group G] [DecidableEq G] | |
| (T : GroupOperator G) (hT : ∀ g, rightRegular g * T = T * rightRegular g) | |
| (x y : G) : | |
| (T (lp.single 2 y 1)) x = (T deltaOne) (x * y⁻¹) := by | |
| have hr : rightRegular y⁻¹ deltaOne = lp.single 2 y 1 := by | |
| ext b | |
| simp [deltaOne, lp.single_apply, Pi.single_apply, mul_inv_eq_one] | |
| rw [← hr] | |
| have hc := congrArg (fun f : GroupOperator G => f deltaOne) (hT y⁻¹) | |
| simpa only [mul_apply_eq_comp, rightRegular_apply] using | |
| congrArg (fun v : GroupHilbert G => v x) hc.symm | |
| theorem matrix_of_commute_left {G : Type uG} [Group G] [DecidableEq G] | |
| (T : GroupOperator G) (hT : ∀ g, leftRegular g * T = T * leftRegular g) | |
| (x y : G) : | |
| (T (lp.single 2 y 1)) x = (T deltaOne) (y⁻¹ * x) := by | |
| have hl : leftRegular y deltaOne = lp.single 2 y 1 := by | |
| ext b | |
| simp [deltaOne, lp.single_apply, Pi.single_apply, inv_mul_eq_one, eq_comm] | |
| rw [← hl] | |
| have hc := congrArg (fun f : GroupOperator G => f deltaOne) (hT y) | |
| simpa only [mul_apply_eq_comp, leftRegular_apply] using | |
| congrArg (fun v : GroupHilbert G => v x) hc.symm | |
| theorem mem_groupVN_iff_commute_right {G : Type uG} [Group G] | |
| (T : GroupOperator G) : T ∈ groupVonNeumann G ↔ | |
| ∀ g, rightRegular g * T = T * rightRegular g := by | |
| classical | |
| refine ⟨fun h g => groupVN_commute_right ⟨T,h⟩ g, ?_⟩ | |
| intro hT | |
| have hc (U : GroupOperator G) (hU : ∀ g, leftRegular g * U = U * leftRegular g) : | |
| U * T = T * U := by | |
| apply operator_matrix_ext | |
| intro k | |
| ext x | |
| have hleft : ((U * T) (lp.single 2 k 1)) x = | |
| ∑' y : G, (U deltaOne) (y⁻¹ * x) * (T deltaOne) (y * k⁻¹) := by | |
| change (U (T (lp.single 2 k 1))) x = _ | |
| rw [operator_coeff_tsum U] | |
| apply tsum_congr | |
| intro y | |
| rw [matrix_of_commute_left U hU x y, matrix_of_commute_right T hT y k] | |
| have hright : ((T * U) (lp.single 2 k 1)) x = | |
| ∑' y : G, (T deltaOne) (x * y⁻¹) * (U deltaOne) (k⁻¹ * y) := by | |
| change (T (U (lp.single 2 k 1))) x = _ | |
| rw [operator_coeff_tsum T] | |
| apply tsum_congr | |
| intro y | |
| rw [matrix_of_commute_right T hT x y, matrix_of_commute_left U hU y k] | |
| rw [hleft, hright] | |
| let e : G ≃ G := ((Equiv.inv G).trans (Equiv.mulLeft x)).trans (Equiv.mulRight k) | |
| have hs := e.tsum_eq (fun y => (U deltaOne) (y⁻¹ * x) * (T deltaOne) (y * k⁻¹)) | |
| change (∑' c : G, (U deltaOne) ((x * c⁻¹ * k)⁻¹ * x) * | |
| (T deltaOne) (x * c⁻¹ * k * k⁻¹)) = _ at hs | |
| simpa only [mul_inv_rev, inv_inv, mul_assoc, inv_mul_cancel, | |
| mul_inv_cancel, mul_one, mul_comm] using hs.symm | |
| rw [groupVonNeumann, StarSubalgebra.mem_centralizer_iff] | |
| intro U hU | |
| have hu : ∀ g, leftRegular g * U = U * leftRegular g := by | |
| intro g | |
| exact ((StarSubalgebra.mem_centralizer_iff ℂ).mp hU _ | |
| (leftRegular_mem_leftTranslations g)).1 | |
| refine ⟨hc U hu, hc (star U) ?_⟩ | |
| intro g | |
| have hh := congrArg star (hu g⁻¹) | |
| simpa only [star_mul, leftRegular_star, inv_inv] using hh.symm | |
| open scoped ComplexConjugate | |
| theorem rightRegular_single {G : Type uG} [Group G] [DecidableEq G] (g y : G) : | |
| rightRegular g (lp.single 2 y (1 : ℂ)) = lp.single 2 (y * g⁻¹) 1 := by | |
| ext x | |
| simp only [rightRegular_apply, lp.single_apply, Pi.single_apply] | |
| congr 1 | |
| exact propext (eq_mul_inv_iff_mul_eq.symm) | |
| theorem mem_groupVN_of_matrix_invariant {G : Type uG} [Group G] [DecidableEq G] | |
| (T : GroupOperator G) | |
| (hT : ∀ x y g : G, (T (lp.single 2 (y*g) 1)) (x*g) = | |
| (T (lp.single 2 y 1)) x) : T ∈ groupVonNeumann G := by | |
| rw [mem_groupVN_iff_commute_right] | |
| intro g | |
| apply operator_matrix_ext | |
| intro y | |
| ext x | |
| simp only [mul_apply_eq_comp, rightRegular_apply] | |
| change (T (lp.single 2 y 1)) (x*g) = (T (rightRegular g (lp.single 2 y 1))) x | |
| rw [rightRegular_single] | |
| simpa only [mul_inv_cancel_right] using (hT (x*g) y g⁻¹).symm | |
| theorem haar_orbit_orthonormal {G : Type uG} {H : Type uH} [Group G] [Group H] [DecidableEq G] | |
| (ρ : G →* groupVonNeumann H) | |
| (hstar : ∀ g, star (ρ g) = ρ g⁻¹) | |
| (htrace : ∀ g, canonicalTrace (ρ g) = if g = 1 then 1 else 0) : | |
| Orthonormal ℂ (fun g => ((ρ g : groupVonNeumann H) : GroupOperator H) deltaOne) := by | |
| classical | |
| rw [orthonormal_iff_ite] | |
| intro x y | |
| rw [← canonicalTrace_star_mul_inner, hstar, ← map_mul, htrace] | |
| simp only [inv_mul_eq_one] | |
| theorem spatial_of_haar_total {G : Type uG} {H : Type uH} [Group G] [Group H] [DecidableEq G] | |
| (ρ : G →* groupVonNeumann H) | |
| (hstar : ∀ g, star (ρ g) = ρ g⁻¹) | |
| (htrace : ∀ g, canonicalTrace (ρ g) = if g = 1 then 1 else 0) | |
| (htotal : ⊤ ≤ (Submodule.span ℂ (Set.range | |
| (fun g => ((ρ g : groupVonNeumann H) : GroupOperator H) deltaOne))).topologicalClosure) : | |
| ∃ e : GroupHilbert G ≃ₗᵢ[ℂ] GroupHilbert H, | |
| e deltaOne = deltaOne ∧ | |
| (∀ g, e.conjStarAlgEquiv (leftRegular g) = (ρ g : GroupOperator H)) ∧ | |
| ∀ T : GroupOperator G, T ∈ groupVonNeumann G ↔ | |
| e.conjStarAlgEquiv T ∈ groupVonNeumann H := by | |
| classical | |
| let v : G → GroupHilbert H := fun g => ((ρ g : groupVonNeumann H) : GroupOperator H) deltaOne | |
| have hon : Orthonormal ℂ v := haar_orbit_orthonormal ρ hstar htrace | |
| let e : GroupHilbert G ≃ₗᵢ[ℂ] GroupHilbert H := | |
| (hon.isHilbertSum htotal).linearIsometryEquiv.symm | |
| have he (g : G) : e (lp.single 2 g 1) = v g := | |
| hon.linearIsometryEquiv_symm_apply_single_one htotal g | |
| have hδ : e deltaOne = deltaOne := by | |
| rw [deltaOne_eq, he] | |
| simp [v] | |
| have hleft (g : G) : e.conjStarAlgEquiv (leftRegular g) = (ρ g : GroupOperator H) := by | |
| apply e.conjStarAlgEquiv.symm.injective | |
| change e.conjStarAlgEquiv.symm (e.conjStarAlgEquiv (leftRegular g)) = | |
| e.conjStarAlgEquiv.symm (ρ g : GroupOperator H) | |
| rw [e.conjStarAlgEquiv.symm_apply_apply] | |
| apply operator_matrix_ext | |
| intro y | |
| apply e.injective | |
| change e (leftRegular g (lp.single 2 y 1)) = | |
| e (e.symm ((ρ g : GroupOperator H) (e (lp.single 2 y 1)))) | |
| rw [e.apply_symm_apply, he] | |
| have hl : leftRegular g (lp.single 2 y (1 : ℂ)) = lp.single 2 (g*y) 1 := by | |
| ext x | |
| simp only [leftRegular_apply, lp.single_apply, Pi.single_apply] | |
| congr 1 | |
| exact propext (inv_mul_eq_iff_eq_mul) | |
| rw [hl, he] | |
| change ((ρ (g*y) : groupVonNeumann H) : GroupOperator H) deltaOne = _ | |
| rw [map_mul] | |
| rfl | |
| refine ⟨e, hδ, hleft, ?_⟩ | |
| intro T | |
| constructor | |
| · intro hT | |
| rw [mem_groupVN_iff_commute_right] | |
| intro g | |
| apply e.conjStarAlgEquiv.symm.injective | |
| change e.conjStarAlgEquiv.symm (rightRegular g * e.conjStarAlgEquiv T) = | |
| e.conjStarAlgEquiv.symm (e.conjStarAlgEquiv T * rightRegular g) | |
| rw [map_mul, map_mul, e.conjStarAlgEquiv.symm_apply_apply] | |
| have hc : e.conjStarAlgEquiv.symm (rightRegular g) ∈ | |
| StarSubalgebra.centralizer ℂ (leftTranslations G) := by | |
| rw [StarSubalgebra.mem_centralizer_iff, leftTranslations_eq_range] | |
| rintro _ ⟨x,rfl⟩ | |
| constructor | |
| · apply e.conjStarAlgEquiv.injective | |
| change e.conjStarAlgEquiv (leftRegular _ * e.conjStarAlgEquiv.symm (rightRegular g)) = | |
| e.conjStarAlgEquiv (e.conjStarAlgEquiv.symm (rightRegular g) * leftRegular _) | |
| rw [map_mul, map_mul, e.conjStarAlgEquiv.apply_symm_apply, hleft] | |
| exact (groupVN_commute_right (ρ x) g).symm | |
| · rw [leftRegular_star] | |
| apply e.conjStarAlgEquiv.injective | |
| change e.conjStarAlgEquiv (leftRegular _ * e.conjStarAlgEquiv.symm (rightRegular g)) = | |
| e.conjStarAlgEquiv (e.conjStarAlgEquiv.symm (rightRegular g) * leftRegular _) | |
| rw [map_mul, map_mul, e.conjStarAlgEquiv.apply_symm_apply, hleft] | |
| exact (groupVN_commute_right (ρ x⁻¹) g).symm | |
| exact ((StarSubalgebra.mem_centralizer_iff ℂ).mp hT _ hc).1 | |
| · intro hT | |
| let U : groupVonNeumann H := ⟨e.conjStarAlgEquiv T, hT⟩ | |
| have hm (x y : G) : (T (lp.single 2 y 1)) x = | |
| canonicalTrace (star (ρ x) * U * ρ y) := by | |
| calc | |
| (T (lp.single 2 y 1)) x = inner ℂ (lp.single 2 x 1) (T (lp.single 2 y 1)) := by | |
| simp [lp.inner_single_left] | |
| _ = inner ℂ (v x) ((U : GroupOperator H) (v y)) := by | |
| rw [← he x, ← he y, ← e.inner_map_map] | |
| change inner ℂ (e (lp.single 2 x 1)) (e (T (lp.single 2 y 1))) = | |
| inner ℂ (e (lp.single 2 x 1)) (e (T (e.symm (e (lp.single 2 y 1))))) | |
| rw [e.symm_apply_apply] | |
| _ = canonicalTrace (star (ρ x) * U * ρ y) := by | |
| rw [mul_assoc, canonicalTrace_star_mul_inner] | |
| rfl | |
| apply mem_groupVN_of_matrix_invariant T | |
| intro x y g | |
| rw [hm, hm, map_mul, map_mul, star_mul] | |
| have hc := canonicalTrace_mul (star (ρ g) * star (ρ x) * U * ρ y) (ρ g) | |
| simp only [← mul_assoc] | |
| rw [hc] | |
| simp only [hstar, ← mul_assoc, ← map_mul, mul_inv_cancel, one_mul] | |
| theorem normalTracialIso_of_haar_total {G : Type uG} {H : Type uH} [Group G] [Group H] [DecidableEq G] | |
| (ρ : G →* groupVonNeumann H) | |
| (hstar : ∀ g, star (ρ g) = ρ g⁻¹) | |
| (htrace : ∀ g, canonicalTrace (ρ g) = if g = 1 then 1 else 0) | |
| (htotal : ⊤ ≤ (Submodule.span ℂ (Set.range | |
| (fun g => ((ρ g : groupVonNeumann H) : GroupOperator H) deltaOne))).topologicalClosure) : | |
| HasNormalTracialIso G H := by | |
| obtain ⟨e,hδ,_hρ,hVN⟩ := spatial_of_haar_total ρ hstar htrace htotal | |
| exact normalTracialIso_of_spatial e hδ hVN | |
| theorem iso_extension_of_haar_total {G : Type uG} {H : Type uH} [Group G] [Group H] [DecidableEq G] | |
| (ρ : G →* groupVonNeumann H) | |
| (hstar : ∀ g, star (ρ g) = ρ g⁻¹) | |
| (htrace : ∀ g, canonicalTrace (ρ g) = if g = 1 then 1 else 0) | |
| (htotal : ⊤ ≤ (Submodule.span ℂ (Set.range | |
| (fun g => ((ρ g : groupVonNeumann H) : GroupOperator H) deltaOne))).topologicalClosure) : | |
| ∃ Φ : groupVonNeumann G ≃⋆ₐ[ℂ] groupVonNeumann H, | |
| (∀ T, canonicalTrace (Φ T) = canonicalTrace T) ∧ | |
| @Continuous _ _ (groupUltraweakTopology G) (groupUltraweakTopology H) Φ ∧ | |
| ∀ g, Φ (groupUnitary g) = ρ g := by | |
| classical | |
| obtain ⟨e,hδ,hρ,hVN⟩ := spatial_of_haar_total ρ hstar htrace htotal | |
| refine ⟨spatialGroupIso e hVN, ?_, spatialGroupIso_normal e hVN, ?_⟩ | |
| · intro T | |
| rw [canonicalTrace_eq_inner, canonicalTrace_eq_inner, ← deltaOne_eq, ← deltaOne_eq] | |
| change inner ℂ deltaOne (e ((T : GroupOperator G) (e.symm deltaOne))) = | |
| inner ℂ deltaOne ((T : GroupOperator G) deltaOne) | |
| rw [← hδ, e.symm_apply_apply, e.inner_map_map] | |
| · intro g | |
| apply Subtype.ext | |
| exact hρ g | |
| end | |
| end FreeGroupFactorMain | |
| end OAI | |