Download data/lean/OAI/Analysis/CharacterCriterion/FactorIndependence.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 25.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/FactorIndependence.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/CharacterCriterion/FactorIndependence.lean
-
curl -L -o FactorIndependence.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/FactorIndependence.lean
25.2 kB
| import OAI.Analysis.CharacterCriterion.MaxTensor | |
| namespace OAI | |
| noncomputable section | |
| open scoped TensorProduct | |
| open scoped InnerProductSpace | |
| namespace KirchbergRordam.GenericRW | |
| namespace FactorIndependence | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| variable {ΞΉ : Type*} [Fintype ΞΉ] | |
| def IsFactor (M : VonNeumannAlgebra H) : Prop := | |
| β T : H βL[β] H, T β M β T β M.commutant β β z : β, T = z β’ 1 | |
| abbrev SumHilbert (ΞΉ : Type*) (H : Type*) := PiLp 2 (fun _ : ΞΉ => H) | |
| def diagonal (T : H βL[β] H) : SumHilbert ΞΉ H βL[β] SumHilbert ΞΉ H := | |
| (PiLp.continuousLinearEquiv 2 β (fun _ : ΞΉ => H)).symm.toContinuousLinearMap.comp | |
| (ContinuousLinearMap.pi fun i => T.comp (PiLp.proj 2 (fun _ : ΞΉ => H) i)) | |
| omit [CompleteSpace H] [Fintype ΞΉ] in | |
| @[simp] lemma diagonal_apply (T : H βL[β] H) (x : SumHilbert ΞΉ H) (i : ΞΉ) : | |
| diagonal T x i = T (x i) := rfl | |
| lemma star_diagonal (T : H βL[β] H) : star (diagonal (ΞΉ := ΞΉ) T) = diagonal (star T) := by | |
| apply ContinuousLinearMap.ext | |
| intro x | |
| apply ext_inner_right β | |
| intro y | |
| rw [ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_left] | |
| simp only [PiLp.inner_apply, diagonal_apply] | |
| congr 1 | |
| funext i | |
| exact (ContinuousLinearMap.adjoint_inner_left T (y i) (x i)).symm | |
| lemma projection_commutes (K : Submodule β H) [K.HasOrthogonalProjection] | |
| (T : H βL[β] H) | |
| (hT : β x β K, T x β K) (hTs : β x β K, star T x β K) : | |
| Commute K.starProjection T := by | |
| have hp (S : H βL[β] H) (hS : β x β K, S x β K) : | |
| K.starProjection * S * K.starProjection = S * K.starProjection := by | |
| ext x | |
| exact K.starProjection_eq_self_iff.mpr (hS _ (by simp)) | |
| have hβ := hp T hT | |
| have hβ := congrArg star (hp (star T) hTs) | |
| simp only [star_mul, star_star, (isSelfAdjoint_starProjection K).star_eq] at hβ | |
| exact hβ.symm.trans (by rwa [mul_assoc] at hβ) | |
| variable [DecidableEq ΞΉ] | |
| def injection (i : ΞΉ) : H βL[β] SumHilbert ΞΉ H := | |
| (PiLp.continuousLinearEquiv 2 β (fun _ : ΞΉ => H)).symm.toContinuousLinearMap.comp | |
| (ContinuousLinearMap.single β (fun _ : ΞΉ => H) i) | |
| omit [CompleteSpace H] [Fintype ΞΉ] in | |
| @[simp] lemma injection_apply (i j : ΞΉ) (x : H) : | |
| injection i x j = if j = i then x else 0 := by | |
| simp [injection] | |
| omit [CompleteSpace H] in | |
| lemma sum_injection (x : SumHilbert ΞΉ H) : β i, injection i (x i) = x := by | |
| apply PiLp.ext | |
| intro j | |
| simp | |
| omit [CompleteSpace H] [Fintype ΞΉ] in | |
| lemma diagonal_injection (T : H βL[β] H) (i : ΞΉ) (x : H) : | |
| diagonal T (injection (ΞΉ := ΞΉ) i x) = injection i (T x) := by | |
| ext j | |
| by_cases hj : j = i <;> simp [hj] | |
| def entry (P : SumHilbert ΞΉ H βL[β] SumHilbert ΞΉ H) (i j : ΞΉ) : H βL[β] H := | |
| (PiLp.proj 2 (fun _ : ΞΉ => H) i).comp (P.comp (injection j)) | |
| omit [CompleteSpace H] [Fintype ΞΉ] in | |
| @[simp] lemma entry_apply (P : SumHilbert ΞΉ H βL[β] SumHilbert ΞΉ H) | |
| (i j : ΞΉ) (x : H) : entry P i j x = P (injection j x) i := rfl | |
| omit [CompleteSpace H] [Fintype ΞΉ] in | |
| lemma entry_commutes (P : SumHilbert ΞΉ H βL[β] SumHilbert ΞΉ H) (T : H βL[β] H) | |
| (hc : Commute P (diagonal T)) (i j : ΞΉ) : Commute (entry P i j) T := by | |
| ext x | |
| have hh := congrArg (fun S : SumHilbert ΞΉ H βL[β] SumHilbert ΞΉ H => S (injection j x) i) hc.eq | |
| simpa [mul_apply_eq_comp, diagonal_injection] using hh | |
| omit [CompleteSpace H] in | |
| lemma apply_eq_sum_entries (P : SumHilbert ΞΉ H βL[β] SumHilbert ΞΉ H) | |
| (x : SumHilbert ΞΉ H) (i : ΞΉ) : P x i = β j, entry P i j (x j) := by | |
| conv_lhs => rw [β sum_injection x] | |
| simp | |
| omit [CompleteSpace H] in | |
| lemma invariant_closure (K : Submodule β H) (T : H βL[β] H) | |
| (h : β x β K, T x β K) : β x β K.topologicalClosure, T x β K.topologicalClosure := | |
| Set.MapsTo.closure h T.continuous | |
| def column (b : ΞΉ β H βL[β] H) (ΞΎ : H) : SumHilbert ΞΉ H := | |
| WithLp.toLp 2 (fun i => b i ΞΎ) | |
| omit [CompleteSpace H] [Fintype ΞΉ] [DecidableEq ΞΉ] in | |
| @[simp] lemma column_apply (b : ΞΉ β H βL[β] H) (ΞΎ : H) (i : ΞΉ) : column b ΞΎ i = b i ΞΎ := rfl | |
| def columnSpace (M : VonNeumannAlgebra H) (b : ΞΉ β H βL[β] H) : | |
| Submodule β (SumHilbert ΞΉ H) := | |
| (Submodule.span β {v | β c : H βL[β] H, c β M.commutant β§ | |
| β ΞΎ : H, v = diagonal c (column b ΞΎ)}).topologicalClosure | |
| omit [DecidableEq ΞΉ] in | |
| lemma columnSpace_closed (M : VonNeumannAlgebra H) (b : ΞΉ β H βL[β] H) : | |
| IsClosed (columnSpace M b : Set (SumHilbert ΞΉ H)) := | |
| Submodule.isClosed_topologicalClosure _ | |
| omit [DecidableEq ΞΉ] in | |
| lemma generator_mem (M : VonNeumannAlgebra H) (b : ΞΉ β H βL[β] H) | |
| (c : H βL[β] H) (hc : c β M.commutant) (ΞΎ : H) : | |
| diagonal c (column b ΞΎ) β columnSpace M b := | |
| Submodule.le_topologicalClosure _ (Submodule.subset_span β¨c, hc, ΞΎ, rflβ©) | |
| omit [DecidableEq ΞΉ] in | |
| lemma column_mem (M : VonNeumannAlgebra H) (b : ΞΉ β H βL[β] H) (ΞΎ : H) : | |
| column b ΞΎ β columnSpace M b := by | |
| simpa only [show diagonal (ΞΉ := ΞΉ) (1 : H βL[β] H) = 1 by ext; rfl, | |
| one_apply_eq_self] using generator_mem M b 1 (one_mem _) ΞΎ | |
| omit [CompleteSpace H] in | |
| lemma invariant_span_closure (S : Set H) (T : H βL[β] H) | |
| (h : β x β S, T x β Submodule.span β S) : | |
| β x β (Submodule.span β S).topologicalClosure, | |
| T x β (Submodule.span β S).topologicalClosure := by | |
| apply invariant_closure | |
| have hh : Submodule.span β S β€ (Submodule.span β S).comap T.toLinearMap := | |
| Submodule.span_le.mpr h | |
| exact hh | |
| omit [DecidableEq ΞΉ] in | |
| lemma commutant_invariant (M : VonNeumannAlgebra H) (b : ΞΉ β H βL[β] H) | |
| (T : H βL[β] H) (hT : T β M.commutant) : | |
| β x β columnSpace M b, diagonal T x β columnSpace M b := by | |
| apply invariant_span_closure | |
| rintro x β¨c, hc, ΞΎ, rflβ© | |
| apply Submodule.subset_span | |
| refine β¨T * c, mul_mem hT hc, ΞΎ, ?_β© | |
| rfl | |
| omit [DecidableEq ΞΉ] in | |
| lemma algebra_invariant (M : VonNeumannAlgebra H) (b : ΞΉ β H βL[β] H) | |
| (hb : β i, b i β M.commutant) (T : H βL[β] H) (hT : T β M) : | |
| β x β columnSpace M b, diagonal T x β columnSpace M b := by | |
| apply invariant_span_closure | |
| rintro x β¨c, hc, ΞΎ, rflβ© | |
| apply Submodule.subset_span | |
| refine β¨c, hc, T ΞΎ, ?_β© | |
| ext i | |
| have hβ := congrArg (fun S : H βL[β] H => S (b i ΞΎ)) | |
| (VonNeumannAlgebra.mem_commutant_iff.mp hc T hT) | |
| have hβ := congrArg (fun S : H βL[β] H => S ΞΎ) | |
| (VonNeumannAlgebra.mem_commutant_iff.mp (hb i) T hT) | |
| change T (c (b i ΞΎ)) = c (b i (T ΞΎ)) | |
| exact hβ.trans (congrArg c hβ) | |
| lemma columnSpace_eq_top (M : VonNeumannAlgebra H) (hM : IsFactor M) | |
| (b : ΞΉ β H βL[β] H) (hb : β i, b i β M.commutant) | |
| (hli : LinearIndependent β b) : columnSpace M b = β€ := by | |
| let K := columnSpace M b | |
| let : CompleteSpace K := (columnSpace_closed M b).completeSpace_coe | |
| let p : SumHilbert ΞΉ H βL[β] SumHilbert ΞΉ H := 1 - K.starProjection | |
| have hp (T : H βL[β] H) | |
| (hT : β x β K, diagonal T x β K) | |
| (hTs : β x β K, diagonal (star T) x β K) : Commute p (diagonal T) := by | |
| have hc := projection_commutes K (diagonal T) hT (by rwa [star_diagonal]) | |
| change (1 - K.starProjection) * diagonal T = diagonal T * (1 - K.starProjection) | |
| simp only [sub_mul, mul_sub, one_mul, mul_one, hc.eq] | |
| have he (i j : ΞΉ) : β z : β, entry p i j = z β’ 1 := by | |
| apply hM | |
| Β· rw [β M.commutant_commutant] | |
| apply VonNeumannAlgebra.mem_commutant_iff.mpr | |
| intro T hT | |
| exact (entry_commutes p T (hp T (commutant_invariant M b T hT) | |
| (commutant_invariant M b (star T) (star_mem hT))) i j).eq.symm | |
| Β· apply VonNeumannAlgebra.mem_commutant_iff.mpr | |
| intro T hT | |
| exact (entry_commutes p T (hp T (algebra_invariant M b hb T hT) | |
| (algebra_invariant M b hb (star T) (star_mem hT))) i j).eq.symm | |
| choose z hz using he | |
| have hpcol (ΞΎ : H) : p (column b ΞΎ) = 0 := by | |
| change column b ΞΎ - K.starProjection (column b ΞΎ) = 0 | |
| rw [K.starProjection_eq_self_iff.mpr (column_mem M b ΞΎ), sub_self] | |
| have hz0 (i : ΞΉ) : β j, z i j = 0 := by | |
| apply (Fintype.linearIndependent_iff.mp hli) (z i) | |
| ext ΞΎ | |
| have hh := congrArg (fun v : SumHilbert ΞΉ H => v i) (hpcol ΞΎ) | |
| rw [apply_eq_sum_entries] at hh | |
| simpa [hz] using hh | |
| have hp0 : p = 0 := by | |
| ext x i | |
| rw [apply_eq_sum_entries] | |
| simp [hz, hz0] | |
| apply top_unique | |
| intro x _ | |
| apply K.starProjection_eq_self_iff.mp | |
| have hh := congrArg (fun P : SumHilbert ΞΉ H βL[β] SumHilbert ΞΉ H => P x) hp0 | |
| change x - K.starProjection x = 0 at hh | |
| exact (sub_eq_zero.mp hh).symm | |
| def row (a : ΞΉ β H βL[β] H) : SumHilbert ΞΉ H βL[β] H := | |
| β i, (a i).comp (PiLp.proj 2 (fun _ : ΞΉ => H) i) | |
| omit [CompleteSpace H] [DecidableEq ΞΉ] in | |
| @[simp] lemma row_apply (a : ΞΉ β H βL[β] H) (x : SumHilbert ΞΉ H) : | |
| row a x = β i, a i (x i) := by simp [row] | |
| omit [CompleteSpace H] in | |
| lemma row_injection (a : ΞΉ β H βL[β] H) (i : ΞΉ) (x : H) : | |
| row a (injection i x) = a i x := by | |
| simp only [row_apply, injection_apply, apply_ite, map_zero] | |
| simp | |
| omit [DecidableEq ΞΉ] in | |
| theorem relation_coefficients_zero (M : VonNeumannAlgebra H) (hM : IsFactor M) | |
| (a b : ΞΉ β H βL[β] H) (ha : β i, a i β M) (hb : β i, b i β M.commutant) | |
| (hli : LinearIndependent β b) (hrel : β i, a i * b i = 0) : β i, a i = 0 := by | |
| classical | |
| have hK : columnSpace M b β€ (row a).ker := by | |
| apply Submodule.topologicalClosure_minimal _ _ (row a).isClosed_ker | |
| apply Submodule.span_le.mpr | |
| rintro x β¨c, hc, ΞΎ, rflβ© | |
| change row a (diagonal c (column b ΞΎ)) = 0 | |
| rw [row_apply] | |
| simp only [diagonal_apply, column_apply] | |
| calc | |
| β i, a i (c (b i ΞΎ)) = β i, c (a i (b i ΞΎ)) := by | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| exact congrArg (fun S : H βL[β] H => S (b i ΞΎ)) | |
| (VonNeumannAlgebra.mem_commutant_iff.mp hc (a i) (ha i)) | |
| _ = c ((β i, a i * b i) ΞΎ) := by simp | |
| _ = 0 := by rw [hrel]; simp | |
| rw [columnSpace_eq_top M hM b hb hli] at hK | |
| intro i | |
| ext ΞΎ | |
| have hh := hK (show injection i ΞΎ β (β€ : Submodule β (SumHilbert ΞΉ H)) from trivial) | |
| change row a (injection i ΞΎ) = 0 at hh | |
| rwa [row_injection] at hh | |
| end FactorIndependence | |
| end KirchbergRordam.GenericRW | |
| namespace KirchbergRordam.GenericRW.GroupedFactors | |
| open scoped Pointwise | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| def commutantOf (S : StarSubalgebra β (H βL[β] H)) : VonNeumannAlgebra H where | |
| toStarSubalgebra := StarSubalgebra.centralizer β (S : Set (H βL[β] H)) | |
| centralizer_centralizer' := by | |
| change Set.centralizer (Set.centralizer | |
| (StarSubalgebra.centralizer β (S : Set (H βL[β] H)) : Set (H βL[β] H))) = | |
| (StarSubalgebra.centralizer β (S : Set (H βL[β] H)) : Set (H βL[β] H)) | |
| simp only [StarSubalgebra.coe_centralizer, StarMemClass.star_coe_eq, Set.union_self] | |
| exact Set.centralizer_centralizer_centralizer _ | |
| def bicommutant (S : StarSubalgebra β (H βL[β] H)) : VonNeumannAlgebra H := | |
| (commutantOf S).commutant | |
| lemma mem_commutantOf_iff (S : StarSubalgebra β (H βL[β] H)) (T : H βL[β] H) : | |
| T β commutantOf S β β a β S, Commute a T := by | |
| change T β StarSubalgebra.centralizer β (S : Set (H βL[β] H)) β _ | |
| rw [β SetLike.mem_coe, StarSubalgebra.coe_centralizer, StarMemClass.star_coe_eq, | |
| Set.union_self] | |
| rfl | |
| lemma subset_bicommutant (S : StarSubalgebra β (H βL[β] H)) : | |
| β a β S, a β bicommutant S := by | |
| intro a ha | |
| apply VonNeumannAlgebra.mem_commutant_iff.mpr | |
| intro T hT | |
| exact ((mem_commutantOf_iff S T).mp hT a ha).eq.symm | |
| lemma closures_commute (S T : StarSubalgebra β (H βL[β] H)) | |
| (hc : β a β S, β b β T, Commute a b) : | |
| β a β bicommutant S, β b β bicommutant T, Commute a b := by | |
| intro a ha b hb | |
| apply VonNeumannAlgebra.mem_commutant_iff.mp hb | |
| apply (mem_commutantOf_iff T a).mpr | |
| intro t ht | |
| exact VonNeumannAlgebra.mem_commutant_iff.mp ha t | |
| ((mem_commutantOf_iff S t).mpr (fun s hs => hc s hs t ht)) | |
| theorem isFactor_of_total (S T : StarSubalgebra β (H βL[β] H)) | |
| (hc : β a β S, β b β T, Commute a b) | |
| (htotal : β U : H βL[β] H, | |
| (β a β S, Commute U a) β (β b β T, Commute U b) β β z : β, U = z β’ 1) : | |
| FactorIndependence.IsFactor (bicommutant S) := by | |
| intro U hU hUc | |
| apply htotal U | |
| Β· intro a ha | |
| exact (VonNeumannAlgebra.mem_commutant_iff.mp hUc a (subset_bicommutant S a ha)).symm | |
| Β· intro b hb | |
| exact (VonNeumannAlgebra.mem_commutant_iff.mp hU b | |
| ((mem_commutantOf_iff S b).mpr (fun a ha => hc a ha b hb))).symm | |
| end KirchbergRordam.GenericRW.GroupedFactors | |
| namespace KirchbergRordam.GenericRW.MaxTensor | |
| variable {A B C : Type*} [CStarAlgebra A] [CStarAlgebra B] [CStarAlgebra C] | |
| open scoped CStarAlgebra | |
| lemma commute_of_legs (Ο : Algebra A B βββ[β] C) (T : C) | |
| (hL : β a, Commute T (Ο (includeLeft a))) | |
| (hR : β b, Commute T (Ο (includeRight b))) : | |
| β x, Commute T (Ο x) := by | |
| intro x | |
| induction x using UniformSpace.Completion.induction_on with | |
| | hp => | |
| change IsClosed {x | T * Ο x = Ο x * T} | |
| exact isClosed_eq (continuous_const.mul (map_continuous Ο)) | |
| ((map_continuous Ο).mul continuous_const) | |
| | ih x => | |
| suffices β tensor : A β[β] B, Commute T (Ο (of (rawEquiv tensor))) from this x | |
| intro tensor | |
| induction tensor using TensorProduct.inductionOn with | |
| | add x y hx hy => simpa only [map_add] using hx.add_right hy | |
| | tmul a b => | |
| change Commute T (Ο (of (a ββ[β] b))) | |
| rw [of_tmul, map_mul] | |
| exact (hL a).mul_right (hR b) | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| theorem left_factor (Ο : Algebra A B βββ[β] (H βL[β] H)) | |
| (hs : β T : H βL[β] H, (β x, Commute T (Ο x)) β β z : β, T = z β’ 1) : | |
| FactorIndependence.IsFactor | |
| (GroupedFactors.bicommutant (Ο.comp (includeLeft (A := A) (B := B))).range) := by | |
| apply GroupedFactors.isFactor_of_total _ (Ο.comp (includeRight (A := A) (B := B))).range | |
| Β· rintro a β¨x, rflβ© b β¨y, rflβ© | |
| exact (legs_commute x y).map Ο | |
| Β· intro T hL hR | |
| apply hs T | |
| exact commute_of_legs Ο T (fun a => hL _ β¨a, rflβ©) (fun b => hR _ β¨b, rflβ©) | |
| theorem right_factor (Ο : Algebra A B βββ[β] (H βL[β] H)) | |
| (hs : β T : H βL[β] H, (β x, Commute T (Ο x)) β β z : β, T = z β’ 1) : | |
| FactorIndependence.IsFactor | |
| (GroupedFactors.bicommutant (Ο.comp (includeRight (A := A) (B := B))).range) := by | |
| apply GroupedFactors.isFactor_of_total _ (Ο.comp (includeLeft (A := A) (B := B))).range | |
| Β· rintro b β¨y, rflβ© a β¨x, rflβ© | |
| exact ((legs_commute x y).map Ο).symm | |
| Β· intro T hR hL | |
| apply hs T | |
| exact commute_of_legs Ο T (fun a => hL _ β¨a, rflβ©) (fun b => hR _ β¨b, rflβ©) | |
| end KirchbergRordam.GenericRW.MaxTensor | |
| namespace KirchbergRordam.GenericRW.MaxTensor | |
| section | |
| universe u | |
| variable (D : Type u) [CStarAlgebra D] | |
| def leg : (n : β) β Fin (n + 1) β D βββ[β] (powerPack D n) | |
| | 0 => fun _ => StarAlgHom.id β D | |
| | n + 1 => Fin.cases includeLeft (fun j => includeRight.comp (leg n j)) | |
| @[simp] lemma leg_zero (i : Fin 1) (a : D) : leg D 0 i a = a := rfl | |
| @[simp] lemma leg_succ_zero (n : β) : leg D (n+1) 0 = includeLeft := rfl | |
| @[simp] lemma leg_succ_succ (n : β) (i : Fin (n+1)) : | |
| leg D (n+1) i.succ = (includeRight (A := D)).comp (leg D n i) := rfl | |
| lemma commute_legs (n : β) (i j : Fin (n+1)) (hij : i β j) (a b : D) : | |
| Commute (leg D n i a) (leg D n j b) := by | |
| induction n with | |
| | zero => exact (hij ((Fin.eq_zero i).trans (Fin.eq_zero j).symm)).elim | |
| | succ n ih => | |
| induction i using Fin.cases with | |
| | zero => | |
| induction j using Fin.cases with | |
| | zero => exact (hij rfl).elim | |
| | succ j => exact legs_commute a (leg D n j b) | |
| | succ i => | |
| induction j using Fin.cases with | |
| | zero => exact (legs_commute b (leg D n i a)).symm | |
| | succ j => exact (ih i j (fun h => hij (congrArg Fin.succ h))).map includeRight | |
| variable {D} {C : Type*} [CStarAlgebra C] | |
| lemma commute_of_power_legs (n : β) (Ο : (powerPack D n) βββ[β] C) (T : C) | |
| (h : β i a, Commute T (Ο (leg D n i a))) : β x, Commute T (Ο x) := by | |
| induction n with | |
| | zero => exact fun x => h 0 x | |
| | succ n ih => | |
| apply commute_of_legs Ο T | |
| Β· exact fun a => h 0 a | |
| Β· exact ih (Ο.comp includeRight) (fun i a => h i.succ a) | |
| end | |
| variable {D C : Type*} [CStarAlgebra D] [CStarAlgebra C] | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| lemma power_leg_factor (n : β) (Ο : (powerPack D n) βββ[β] (H βL[β] H)) | |
| (Ο : C βββ[β] (H βL[β] H)) | |
| (hc : β a b, Commute (Ο a) (Ο b)) | |
| (hs : β T : H βL[β] H, (β a, Commute T (Ο a)) β | |
| (β b, Commute T (Ο b)) β β z : β, T = z β’ 1) | |
| (i : Fin (n+1)) : | |
| FactorIndependence.IsFactor (GroupedFactors.bicommutant (Ο.comp (leg D n i)).range) := by | |
| intro U hU hUc | |
| apply hs U | |
| Β· apply commute_of_power_legs n Ο U | |
| intro j a | |
| by_cases hij : i = j | |
| Β· subst j | |
| exact (VonNeumannAlgebra.mem_commutant_iff.mp hUc _ | |
| (GroupedFactors.subset_bicommutant _ _ β¨a, rflβ©)).symm | |
| Β· apply (VonNeumannAlgebra.mem_commutant_iff.mp hU _ ?_).symm | |
| apply (GroupedFactors.mem_commutantOf_iff _ _).mpr | |
| rintro b β¨d, rflβ© | |
| exact (commute_legs D n i j hij d a).map Ο | |
| Β· intro b | |
| apply (VonNeumannAlgebra.mem_commutant_iff.mp hU _ ?_).symm | |
| apply (GroupedFactors.mem_commutantOf_iff _ _).mpr | |
| rintro a β¨d, rflβ© | |
| exact hc _ _ | |
| lemma power_leg_factors_commute (n : β) (Ο : (powerPack D n) βββ[β] (H βL[β] H)) | |
| (i j : Fin (n+1)) (hij : i β j) : | |
| β b β GroupedFactors.bicommutant (Ο.comp (leg D n j)).range, | |
| b β (GroupedFactors.bicommutant (Ο.comp (leg D n i)).range).commutant := by | |
| intro b hb | |
| apply VonNeumannAlgebra.mem_commutant_iff.mpr | |
| intro a ha | |
| exact (GroupedFactors.closures_commute _ _ (by | |
| rintro x β¨c, rflβ© y β¨d, rflβ© | |
| exact (commute_legs D n i j hij c d).map Ο) a ha b hb).eq | |
| end KirchbergRordam.GenericRW.MaxTensor | |
| namespace KirchbergRordam.GenericRW.ProductIndependence | |
| variable {A : Type*} [CStarAlgebra A] | |
| variable {ΞΉ ΞΊ : Type*} [Fintype ΞΉ] [Fintype ΞΊ] | |
| lemma selfAdjoint_complex_independent (v : ΞΉ β A) (hv : β i, IsSelfAdjoint (v i)) | |
| (hli : LinearIndependent β v) : LinearIndependent β v := by | |
| classical | |
| apply Fintype.linearIndependent_iff.mpr | |
| intro c hc | |
| have hr : β i, (c i).re β’ v i = 0 := by | |
| have h := congrArg (fun x : A => (realPart x : A)) hc | |
| simpa only [map_sum, realPart_smul, (hv _).imaginaryPart, smul_zero, sub_zero, | |
| AddSubmonoidClass.coe_finsetSum, selfAdjoint.val_smul, (hv _).coe_realPart, map_zero, | |
| AddSubgroup.coe_zero] using h | |
| have hi : β i, (c i).im β’ v i = 0 := by | |
| have h := congrArg (fun x : A => (imaginaryPart x : A)) hc | |
| simpa only [map_sum, imaginaryPart_smul, (hv _).imaginaryPart, smul_zero, zero_add, | |
| AddSubmonoidClass.coe_finsetSum, selfAdjoint.val_smul, (hv _).coe_realPart, map_zero, | |
| AddSubgroup.coe_zero] using h | |
| have hr0 := (Fintype.linearIndependent_iff.mp hli) _ hr | |
| have hi0 := (Fintype.linearIndependent_iff.mp hli) _ hi | |
| intro i | |
| exact Complex.ext (hr0 i) (hi0 i) | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| lemma pair_independent (M : VonNeumannAlgebra H) (hM : FactorIndependence.IsFactor M) | |
| (a : ΞΉ β H βL[β] H) (b : ΞΊ β H βL[β] H) | |
| (ha : β i, a i β M) (hb : β j, b j β M.commutant) | |
| (hia : LinearIndependent β a) (hib : LinearIndependent β b) : | |
| LinearIndependent β (fun p : ΞΉ Γ ΞΊ => a p.1 * b p.2) := by | |
| classical | |
| apply Fintype.linearIndependent_iff.mpr | |
| intro c hc | |
| have hrel : β j, (β i, c (i,j) β’ a i) * b j = 0 := by | |
| rw [β hc, Fintype.sum_prod_type_right] | |
| apply Finset.sum_congr rfl | |
| intro j _ | |
| simp only [Finset.sum_mul, smul_mul_assoc] | |
| have hcoeff := FactorIndependence.relation_coefficients_zero M hM | |
| (fun j => β i, c (i,j) β’ a i) b | |
| (fun j => M.toStarSubalgebra.sum_mem fun i _ => M.toStarSubalgebra.smul_mem (ha i) _) | |
| hb hib hrel | |
| intro p | |
| exact (Fintype.linearIndependent_iff.mp hia _ (hcoeff p.2)) p.1 | |
| variable [Nontrivial H] | |
| theorem many_independent (n : β) (ΞΊ : Fin n β Type*) [β i, Fintype (ΞΊ i)] | |
| (M : Fin n β VonNeumannAlgebra H) (hM : β i, FactorIndependence.IsFactor (M i)) | |
| (hc : β i j, i β j β β b β M j, b β (M i).commutant) | |
| (a : β i, ΞΊ i β H βL[β] H) (ha : β i j, a i j β M i) | |
| (hia : β i, LinearIndependent β (a i)) : | |
| LinearIndependent β (fun p : β i, ΞΊ i => (List.ofFn (fun i => a i (p i))).prod) := by | |
| classical | |
| induction n with | |
| | zero => | |
| apply linearIndependent_unique_iff.mpr | |
| simp | |
| | succ n ih => | |
| have htail := ih (fun i => ΞΊ i.succ) (fun i => M i.succ) (fun i => hM i.succ) | |
| (fun i j hij => hc i.succ j.succ (fun h => hij (Fin.succ_injective _ h))) | |
| (fun i => a i.succ) (fun i => ha i.succ) (fun i => hia i.succ) | |
| have htailmem (p : β i : Fin n, ΞΊ i.succ) : | |
| (List.ofFn (fun i => a i.succ (p i))).prod β (M 0).commutant := by | |
| apply list_prod_mem | |
| intro x hx | |
| obtain β¨i, rflβ© := List.mem_ofFn.mp hx | |
| exact hc 0 i.succ (Fin.succ_ne_zero i).symm _ (ha _ _) | |
| have hp := pair_independent (M 0) (hM 0) (a 0) | |
| (fun p : β i : Fin n, ΞΊ i.succ => (List.ofFn (fun i => a i.succ (p i))).prod) | |
| (ha 0) htailmem (hia 0) htail | |
| have h := hp.comp (Fin.consEquiv ΞΊ).symm (Fin.consEquiv ΞΊ).symm.injective | |
| simpa only [Function.comp_def, Fin.consEquiv_symm_apply, Fin.tail, List.ofFn_succ, List.prod_cons] | |
| using h | |
| end KirchbergRordam.GenericRW.ProductIndependence | |
| namespace KirchbergRordam.GenericRW.RealProduct | |
| open scoped TensorProduct | |
| open Module | |
| variable {A : Type*} [CStarAlgebra A] {n : β} | |
| variable {V : Fin n β Type*} [β i, AddCommGroup (V i)] [β i, Module β (V i)] | |
| def multiply (f : β i, V i ββ[β] A) : (β¨[β] i, V i) ββ[β] A := | |
| PiTensorProduct.lift ((MultilinearMap.mkPiAlgebraFin β n A).compLinearMap f) | |
| @[simp] lemma multiply_tprod (f : β i, V i ββ[β] A) (v : β i, V i) : | |
| multiply f (β¨β[β] i, v i) = (List.ofFn fun i => f i (v i)).prod := by | |
| simp [multiply] | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| [Nontrivial H] | |
| lemma multiply_injective [β i, FiniteDimensional β (V i)] | |
| (f : β i, V i ββ[β] (H βL[β] H)) | |
| (hf : β i, Function.Injective (f i)) (hsa : β i v, IsSelfAdjoint (f i v)) | |
| (M : Fin n β VonNeumannAlgebra H) (hM : β i, FactorIndependence.IsFactor (M i)) | |
| (hc : β i j, i β j β β b β M j, b β (M i).commutant) | |
| (hmem : β i v, f i v β M i) : Function.Injective (multiply f) := by | |
| classical | |
| let b (i : Fin n) := Module.finBasis β (V i) | |
| let B := Basis.piTensorProduct b | |
| apply LinearMap.injective_of_linearIndependent B.span_eq | |
| have hi (i : Fin n) : LinearIndependent β (fun j => f i (b i j)) := by | |
| apply ProductIndependence.selfAdjoint_complex_independent _ (fun j => hsa _ _) | |
| exact (b i).linearIndependent.map' (f i) (LinearMap.ker_eq_bot.mpr (hf i)) | |
| have hp := ProductIndependence.many_independent n _ M hM hc | |
| (fun i j => f i (b i j)) (fun i j => hmem i _) hi | |
| have hpR := hp.restrict_scalars' β | |
| simpa only [Function.comp_def, B, Basis.piTensorProduct_apply, multiply_tprod] using hpR | |
| lemma selfAdjoint_product (a : Fin n β A) (ha : β i, IsSelfAdjoint (a i)) | |
| (hc : β i j, i β j β Commute (a i) (a j)) : | |
| IsSelfAdjoint (List.ofFn a).prod := by | |
| induction n with | |
| | zero => simp [IsSelfAdjoint] | |
| | succ n ih => | |
| rw [List.ofFn_succ, List.prod_cons] | |
| have ht := ih (fun i => a i.succ) (fun i => ha i.succ) | |
| (fun i j hij => hc i.succ j.succ (fun h => hij (Fin.succ_injective _ h))) | |
| have hcomm : Commute (a 0) (List.ofFn (fun i : Fin n => a i.succ)).prod := by | |
| apply Commute.list_prod_right | |
| intro x hx | |
| obtain β¨i, rflβ© := List.mem_ofFn.mp hx | |
| exact hc 0 i.succ (Fin.succ_ne_zero i).symm | |
| change star (a 0 * _) = _ | |
| rw [star_mul, ht.star_eq, (ha 0).star_eq, hcomm.eq] | |
| omit [Nontrivial H] in | |
| lemma multiply_selfAdjoint | |
| (f : β i, V i ββ[β] (H βL[β] H)) | |
| (hsa : β i v, IsSelfAdjoint (f i v)) | |
| (hc : β i j, i β j β β v w, Commute (f i v) (f j w)) | |
| (x : β¨[β] i, V i) : IsSelfAdjoint (multiply f x) := by | |
| induction x using PiTensorProduct.induction_on with | |
| | smul_tprod r v => | |
| rw [map_smul, multiply_tprod] | |
| exact (IsSelfAdjoint.all r).smul (selfAdjoint_product _ (fun i => hsa i _) | |
| (fun i j hij => hc i j hij _ _)) | |
| | add x y hx hy => | |
| rw [map_add] | |
| exact hx.add hy | |
| end KirchbergRordam.GenericRW.RealProduct | |
| end | |
| end OAI | |