Download data/lean/OAI/Analysis/CharacterCriterion/RepresentedLabels.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 17.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/RepresentedLabels.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/CharacterCriterion/RepresentedLabels.lean
-
curl -L -o RepresentedLabels.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/RepresentedLabels.lean
17.2 kB
| import OAI.Analysis.CharacterCriterion.DetectingSpaces | |
| namespace OAI | |
| noncomputable section | |
| open scoped TensorProduct | |
| open scoped InnerProductSpace | |
| open scoped BigOperators | |
| open Set Module | |
| open Topology | |
| namespace KirchbergRordam.GenericRW.RepresentedLabels | |
| open Module | |
| open scoped TensorProduct | |
| universe u | |
| variable {D : Type u} [CStarAlgebra D] [Nontrivial D] | |
| omit [Nontrivial D] in | |
| lemma rank_two_of_detecting (V : Submodule β D) [FiniteDimensional β V] | |
| {B : Type*} [CStarAlgebra B] (Ο : D βββ[β] B) | |
| (hd : β x β V, β y β V, Β¬ Commute (Ο x) (Ο y)) : | |
| 2 β€ finrank β ((Ο.toLinearMap.restrictScalars β).comp V.subtype).range := by | |
| let f := (Ο.toLinearMap.restrictScalars β).comp V.subtype | |
| by_contra h | |
| change Β¬ 2 β€ finrank β f.range at h | |
| have h1 : finrank β f.range β€ 1 := by omega | |
| obtain β¨v, hvβ© := finrank_le_one_iff.mp h1 | |
| obtain β¨x, hx, y, hy, hxyβ© := hd | |
| obtain β¨a, haβ© := hv (f.rangeRestrict β¨x, hxβ©) | |
| obtain β¨b, hbβ© := hv (f.rangeRestrict β¨y, hyβ©) | |
| have ha' : a β’ (v : B) = Ο x := congrArg Subtype.val ha | |
| have hb' : b β’ (v : B) = Ο y := congrArg Subtype.val hb | |
| apply hxy | |
| rw [β ha', β hb'] | |
| show (a β’ (v : B)) * (b β’ (v : B)) = (b β’ (v : B)) * (a β’ (v : B)) | |
| simp only [smul_mul_assoc, mul_smul_comm, smul_smul, mul_comm a b] | |
| lemma multiply_map {n : β} {E F : Fin n β Type*} | |
| [β i, AddCommGroup (E i)] [β i, Module β (E i)] | |
| [β i, AddCommGroup (F i)] [β i, Module β (F i)] | |
| {A : Type*} [CStarAlgebra A] | |
| (f : β i, F i ββ[β] A) (g : β i, E i ββ[β] F i) (x : β¨[β] i, E i) : | |
| RealProduct.multiply f (PiTensorProduct.map g x) = | |
| RealProduct.multiply (fun i => (f i).comp (g i)) x := by | |
| have hh : (RealProduct.multiply f).comp (PiTensorProduct.map g) = | |
| RealProduct.multiply (fun i => (f i).comp (g i)) := by | |
| apply PiTensorProduct.ext | |
| ext v | |
| simp | |
| exact DFunLike.congr_fun hh x | |
| lemma labels_map_independent {n r : β} | |
| {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] | |
| {V : Fin n β Type*} [β i, AddCommGroup (V i)] [β i, Module β (V i)] | |
| (q : (β¨[β] i, V i) ββ[β] (H βL[β] H)) | |
| (hq : Function.Injective q) (y : Fin r β β¨[β] i, V i) | |
| (hy : LinearIndependent β y) : LinearIndependent β (fun i => q (y i)) := by | |
| exact hy.map' q (LinearMap.ker_eq_bot.mpr hq) | |
| lemma range_multiply_injective {n : β} | |
| {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] | |
| [CompleteSpace H] [Nontrivial H] | |
| {V : Type*} [AddCommGroup V] [Module β V] [FiniteDimensional β V] | |
| (f : Fin n β V ββ[β] (H βL[β] H)) | |
| (hsa : β i a, IsSelfAdjoint (f i a)) | |
| (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 a, f i a β M i) | |
| : | |
| Function.Injective (RealProduct.multiply (fun i => (f i).range.subtype)) := by | |
| exact RealProduct.multiply_injective (fun i => (f i).range.subtype) | |
| (fun i => Subtype.val_injective) | |
| (fun i v => by | |
| obtain β¨a, haβ© := v.property | |
| change IsSelfAdjoint (v : H βL[β] H) | |
| rw [β ha] | |
| exact hsa i a) | |
| M hM hc (fun i v => by | |
| obtain β¨a, haβ© := v.property | |
| change (v : H βL[β] H) β M i | |
| rw [β ha] | |
| exact hmem i a) | |
| lemma independent_multiply_range {n r : β} | |
| {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] | |
| [CompleteSpace H] [Nontrivial H] | |
| {V : Type*} [AddCommGroup V] [Module β V] [FiniteDimensional β V] | |
| (f : Fin n β V ββ[β] (H βL[β] H)) | |
| (hsa : β i a, IsSelfAdjoint (f i a)) | |
| (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 a, f i a β M i) | |
| (x : Fin r β (β¨[β] _ : Fin n, V)) | |
| (hli : LinearIndependent β (fun k => PiTensorProduct.map | |
| (fun i => (f i).rangeRestrict) (x k))) : | |
| LinearIndependent β (fun k => RealProduct.multiply f (x k)) := by | |
| have hsinj := range_multiply_injective f hsa M hM hc hmem | |
| let q : (β¨[β] i : Fin n, (f i).range) ββ[β] (H βL[β] H) := | |
| RealProduct.multiply (fun i => (f i).range.subtype) | |
| have hreal := labels_map_independent q hsinj _ hli | |
| have hreal' : LinearIndependent β (fun k => RealProduct.multiply f (x k)) := by | |
| have he (i : Fin n) : (f i).range.subtype.comp (f i).rangeRestrict = f i := rfl | |
| simpa only [q, multiply_map, he] using hreal | |
| apply ProductIndependence.selfAdjoint_complex_independent _ ?_ hreal' | |
| intro k | |
| apply RealProduct.multiply_selfAdjoint | |
| Β· exact hsa | |
| Β· intro i j hij a b | |
| exact (VonNeumannAlgebra.mem_commutant_iff.mp (hc i j hij _ (hmem _ _)) | |
| _ (hmem _ _)) | |
| theorem factor_labels (V : Submodule β D) [FiniteDimensional β V] | |
| (hsa : V β€ selfAdjoint.submodule β D) | |
| (hd : β (B : Type u) [CStarAlgebra B] [Nontrivial B] (Ο : D βββ[β] B), | |
| β x β V, β y β V, Β¬ Commute (Ο x) (Ο y)) | |
| (r : β) (hr : 1 β€ r) : | |
| β n : β, 1 β€ n β§ β x : Fin r β (β¨[β] _ : Fin n, V), | |
| β (H : Type u) [NormedAddCommGroup H] [InnerProductSpace β H] | |
| [CompleteSpace H] [Nontrivial H] | |
| (Ο : Fin n β D βββ[β] (H βL[β] H)) | |
| (M : Fin n β VonNeumannAlgebra H), | |
| (β i, FactorIndependence.IsFactor (M i)) β | |
| (β i j, i β j β β b β M j, b β (M i).commutant) β | |
| (β i a, Ο i a β M i) β | |
| LinearIndependent β (fun k => RealProduct.multiply | |
| (fun i => ((Ο i).toLinearMap.restrictScalars β).comp V.subtype) (x k)) := by | |
| have hV : 2 β€ finrank β V := by | |
| have h := rank_two_of_detecting V (StarAlgHom.id β D) (hd D (StarAlgHom.id β D)) | |
| exact h.trans (LinearMap.finrank_range_le _) | |
| obtain β¨n, hn, x, hxβ© := tensor_real_labels V hV r hr | |
| refine β¨n, hn, x, ?_β© | |
| intro H _ _ _ _ Ο M hM hc hmem | |
| let f (i : Fin n) := ((Ο i).toLinearMap.restrictScalars β).comp V.subtype | |
| let E (i : Fin n) := (f i).range | |
| let g (i : Fin n) : V ββ[β] E i := (f i).rangeRestrict | |
| have hrank (i : Fin n) : 2 β€ finrank β (g i).range := by | |
| rw [show (g i).range = β€ from (f i).range_rangeRestrict, finrank_top] | |
| exact rank_two_of_detecting V _ (hd _ (Ο i)) | |
| have hind := hx (fun i => E i) g hrank | |
| apply independent_multiply_range f (fun i a => (hsa a.property).map (Ο i)) M hM hc | |
| (fun i a => hmem i a) x | |
| exact hind | |
| lemma multiply_selfAdjoint_general {n : β} {E : Fin n β Type*} | |
| [β i, AddCommGroup (E i)] [β i, Module β (E i)] | |
| {A : Type*} [CStarAlgebra A] | |
| (f : β i, E i ββ[β] A) | |
| (hsa : β i v, IsSelfAdjoint (f i v)) | |
| (hc : β i j, i β j β β v w, Commute (f i v) (f j w)) | |
| (x : β¨[β] i, E i) : IsSelfAdjoint (RealProduct.multiply f x) := by | |
| induction x using PiTensorProduct.induction_on with | |
| | smul_tprod r v => | |
| rw [map_smul, RealProduct.multiply_tprod] | |
| exact (IsSelfAdjoint.all r).smul (RealProduct.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 | |
| lemma map_multiply {n : β} {E : Fin n β Type*} | |
| [β i, AddCommGroup (E i)] [β i, Module β (E i)] | |
| {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] | |
| (Ο : A βββ[β] B) (f : β i, E i ββ[β] A) (x : β¨[β] i, E i) : | |
| Ο (RealProduct.multiply f x) = RealProduct.multiply | |
| (fun i => (Ο.toLinearMap.restrictScalars β).comp (f i)) x := by | |
| have hh : (Ο.toLinearMap.restrictScalars β).comp (RealProduct.multiply f) = | |
| RealProduct.multiply (fun i => (Ο.toLinearMap.restrictScalars β).comp (f i)) := by | |
| apply PiTensorProduct.ext | |
| ext v | |
| simp [map_list_prod, Function.comp_def] | |
| exact DFunLike.congr_fun hh x | |
| theorem power_labels (V : Submodule β D) [FiniteDimensional β V] | |
| (hsa : V β€ selfAdjoint.submodule β D) | |
| (hd : β (B : Type u) [CStarAlgebra B] [Nontrivial B] (Ο : D βββ[β] B), | |
| β x β V, β y β V, Β¬ Commute (Ο x) (Ο y)) | |
| (r : β) (hr : 1 β€ r) : | |
| β n : β, β x : Fin r β (MaxTensor.powerPack D n), | |
| (β k, IsSelfAdjoint (x k)) β§ | |
| β (H : Type u) [NormedAddCommGroup H] [InnerProductSpace β H] | |
| [CompleteSpace H] [Nontrivial H] | |
| (B : Type u) [CStarAlgebra B] | |
| (Ο : (MaxTensor.powerPack D n) βββ[β] (H βL[β] H)) | |
| (Ο : B βββ[β] (H βL[β] H)), | |
| (β a b, Commute (Ο a) (Ο b)) β | |
| (β T : H βL[β] H, (β a, Commute T (Ο a)) β | |
| (β b, Commute T (Ο b)) β β z : β, T = z β’ 1) β | |
| LinearIndependent β (fun k => Ο (x k)) := by | |
| obtain β¨n, hn, v, hvβ© := factor_labels V hsa hd r hr | |
| cases n with | |
| | zero => omega | |
| | succ n => | |
| let f : Fin (n+1) β V ββ[β] (MaxTensor.powerPack D n) := | |
| fun i => ((MaxTensor.leg D n i).toLinearMap.restrictScalars β).comp V.subtype | |
| let x : Fin r β (MaxTensor.powerPack D n) := fun k => RealProduct.multiply f (v k) | |
| refine β¨n, x, ?_, ?_β© | |
| Β· intro k | |
| apply multiply_selfAdjoint_general | |
| Β· intro i a | |
| exact (hsa a.property).map (MaxTensor.leg D n i) | |
| Β· intro i j hij a b | |
| exact MaxTensor.commute_legs D n i j hij a b | |
| Β· intro H _ _ _ _ B _ Ο Ο hc hs | |
| let Ο (i : Fin (n+1)) := Ο.comp (MaxTensor.leg D n i) | |
| let M (i : Fin (n+1)) := GroupedFactors.bicommutant (Ο i).range | |
| have hi := hv H Ο M | |
| (fun i => MaxTensor.power_leg_factor n Ο Ο hc hs i) | |
| (fun i j hij => MaxTensor.power_leg_factors_commute n Ο i j hij) | |
| (fun i a => GroupedFactors.subset_bicommutant _ _ β¨a, rflβ©) | |
| convert hi using 1 | |
| funext k | |
| exact map_multiply Ο f (v k) | |
| end KirchbergRordam.GenericRW.RepresentedLabels | |
| namespace KirchbergRordam.GenericRW.GroupedFactors | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| lemma isFactor_of_three (S T R : StarSubalgebra β (H βL[β] H)) | |
| (hST : β a β S, β b β T, Commute a b) | |
| (hSR : β a β S, β c β R, Commute a c) | |
| (hs : β U : H βL[β] H, (β a β S, Commute U a) β | |
| (β b β T, Commute U b) β (β c β R, Commute U c) β β z : β, U = z β’ 1) : | |
| FactorIndependence.IsFactor (bicommutant S) := by | |
| intro U hU hUc | |
| apply hs 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 => hST a ha b hb))).symm | |
| Β· intro c hc | |
| exact (VonNeumannAlgebra.mem_commutant_iff.mp hU c | |
| ((mem_commutantOf_iff S c).mpr (fun a ha => hSR a ha c hc))).symm | |
| end KirchbergRordam.GenericRW.GroupedFactors | |
| namespace KirchbergRordam.GenericRW.TripleTensor | |
| variable {A B C : Type*} [CStarAlgebra A] [CStarAlgebra B] [CStarAlgebra C] | |
| open _root_.OAI.KirchbergRordam.GenericRW.MaxTensor | |
| abbrev Algebra (A B C : Type*) [CStarAlgebra A] [CStarAlgebra B] [CStarAlgebra C] := | |
| MaxTensor.Algebra A (MaxTensor.Algebra B C) | |
| def first : A βββ[β] Algebra A B C := includeLeft | |
| def second : B βββ[β] Algebra A B C := includeRight.comp includeLeft | |
| def third : C βββ[β] Algebra A B C := includeRight.comp includeRight | |
| lemma first_second (a : A) (b : B) : | |
| Commute (first (C := C) a) (second (A := A) b) := legs_commute _ _ | |
| lemma first_third (a : A) (c : C) : | |
| Commute (first (B := B) a) (third (A := A) c) := legs_commute _ _ | |
| lemma second_third (b : B) (c : C) : | |
| Commute (second (A := A) b) (third (A := A) c) := (legs_commute b c).map includeRight | |
| variable {E : Type*} [CStarAlgebra E] | |
| lemma commute_of_legs (Ο : Algebra A B C βββ[β] E) (T : E) | |
| (h1 : β a, Commute T (Ο (first a))) | |
| (h2 : β b, Commute T (Ο (second b))) | |
| (h3 : β c, Commute T (Ο (third c))) : β x, Commute T (Ο x) := by | |
| apply MaxTensor.commute_of_legs Ο T h1 | |
| exact MaxTensor.commute_of_legs (Ο.comp includeRight) T h2 h3 | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| lemma first_factor (Ο : Algebra A B C βββ[β] (H βL[β] H)) | |
| (hs : β T : H βL[β] H, (β x, Commute T (Ο x)) β β z : β, T = z β’ 1) : | |
| FactorIndependence.IsFactor (GroupedFactors.bicommutant (Ο.comp first).range) := | |
| MaxTensor.left_factor Ο hs | |
| lemma second_factor (Ο : Algebra A B C βββ[β] (H βL[β] H)) | |
| (hs : β T : H βL[β] H, (β x, Commute T (Ο x)) β β z : β, T = z β’ 1) : | |
| FactorIndependence.IsFactor (GroupedFactors.bicommutant (Ο.comp second).range) := by | |
| apply GroupedFactors.isFactor_of_three _ (Ο.comp first).range (Ο.comp third).range | |
| Β· rintro x β¨b, rflβ© y β¨a, rflβ© | |
| exact ((first_second a b).map Ο).symm | |
| Β· rintro x β¨b, rflβ© y β¨c, rflβ© | |
| exact (second_third b c).map Ο | |
| Β· intro T h2 h1 h3 | |
| exact hs T (commute_of_legs Ο T (fun a => h1 _ β¨a, rflβ©) | |
| (fun b => h2 _ β¨b, rflβ©) (fun c => h3 _ β¨c, rflβ©)) | |
| def complementSecond (Ο : Algebra A B C βββ[β] (H βL[β] H)) : | |
| MaxTensor.Algebra A C βββ[β] (H βL[β] H) := | |
| MaxTensor.lift (A := A) (B := C) (C := H βL[β] H) | |
| (Ο.comp first) (Ο.comp third) (fun a c => (first_third a c).map Ο) | |
| lemma complementSecond_commute (Ο : Algebra A B C βββ[β] (H βL[β] H)) | |
| (b : B) (d : MaxTensor.Algebra A C) : | |
| Commute (Ο (second b)) (complementSecond Ο d) := by | |
| apply MaxTensor.commute_of_legs (complementSecond Ο) _ ?_ ?_ d | |
| Β· intro a | |
| have he := DFunLike.congr_fun (MaxTensor.lift_includeLeft (Ο.comp first) (Ο.comp third) | |
| (fun a c => (first_third a c).map Ο)) a | |
| change complementSecond Ο (includeLeft a) = Ο (first a) at he | |
| rw [he] | |
| exact ((first_second a b).map Ο).symm | |
| Β· intro c | |
| have he := DFunLike.congr_fun (MaxTensor.lift_includeRight (Ο.comp first) (Ο.comp third) | |
| (fun a c => (first_third a c).map Ο)) c | |
| change complementSecond Ο (includeRight c) = Ο (third c) at he | |
| rw [he] | |
| exact (second_third b c).map Ο | |
| lemma complementSecond_total (Ο : Algebra A B C βββ[β] (H βL[β] H)) | |
| (hs : β T : H βL[β] H, (β x, Commute T (Ο x)) β β z : β, T = z β’ 1) | |
| (T : H βL[β] H) (h2 : β b, Commute T (Ο (second b))) | |
| (h13 : β d, Commute T (complementSecond Ο d)) : β z : β, T = z β’ 1 := by | |
| apply hs T | |
| apply commute_of_legs Ο T ?_ h2 ?_ | |
| Β· intro a | |
| have he := DFunLike.congr_fun (MaxTensor.lift_includeLeft (Ο.comp first) (Ο.comp third) | |
| (fun a c => (first_third a c).map Ο)) a | |
| change complementSecond Ο (includeLeft a) = Ο (first a) at he | |
| rw [β he] | |
| exact h13 _ | |
| Β· intro c | |
| have he := DFunLike.congr_fun (MaxTensor.lift_includeRight (Ο.comp first) (Ο.comp third) | |
| (fun a c => (first_third a c).map Ο)) c | |
| change complementSecond Ο (includeRight c) = Ο (third c) at he | |
| rw [β he] | |
| exact h13 _ | |
| def complementThird (Ο : Algebra A B C βββ[β] (H βL[β] H)) : | |
| MaxTensor.Algebra A B βββ[β] (H βL[β] H) := | |
| MaxTensor.lift (A := A) (B := B) (C := H βL[β] H) | |
| (Ο.comp first) (Ο.comp second) (fun a b => (first_second a b).map Ο) | |
| lemma complementThird_commute (Ο : Algebra A B C βββ[β] (H βL[β] H)) | |
| (c : C) (d : MaxTensor.Algebra A B) : | |
| Commute (Ο (third c)) (complementThird Ο d) := by | |
| apply MaxTensor.commute_of_legs (complementThird Ο) _ ?_ ?_ d | |
| Β· intro a | |
| have he := DFunLike.congr_fun (MaxTensor.lift_includeLeft (Ο.comp first) (Ο.comp second) | |
| (fun a b => (first_second a b).map Ο)) a | |
| change complementThird Ο (includeLeft a) = Ο (first a) at he | |
| rw [he] | |
| exact ((first_third a c).map Ο).symm | |
| Β· intro b | |
| have he := DFunLike.congr_fun (MaxTensor.lift_includeRight (Ο.comp first) (Ο.comp second) | |
| (fun a b => (first_second a b).map Ο)) b | |
| change complementThird Ο (includeRight b) = Ο (second b) at he | |
| rw [he] | |
| exact ((second_third b c).map Ο).symm | |
| lemma complementThird_total (Ο : Algebra A B C βββ[β] (H βL[β] H)) | |
| (hs : β T : H βL[β] H, (β x, Commute T (Ο x)) β β z : β, T = z β’ 1) | |
| (T : H βL[β] H) (h3 : β c, Commute T (Ο (third c))) | |
| (h12 : β d, Commute T (complementThird Ο d)) : β z : β, T = z β’ 1 := by | |
| apply hs T | |
| apply commute_of_legs Ο T ?_ ?_ h3 | |
| Β· intro a | |
| have he := DFunLike.congr_fun (MaxTensor.lift_includeLeft (Ο.comp first) (Ο.comp second) | |
| (fun a b => (first_second a b).map Ο)) a | |
| change complementThird Ο (includeLeft a) = Ο (first a) at he | |
| rw [β he] | |
| exact h12 _ | |
| Β· intro b | |
| have he := DFunLike.congr_fun (MaxTensor.lift_includeRight (Ο.comp first) (Ο.comp second) | |
| (fun a b => (first_second a b).map Ο)) b | |
| change complementThird Ο (includeRight b) = Ο (second b) at he | |
| rw [β he] | |
| exact h12 _ | |
| end KirchbergRordam.GenericRW.TripleTensor | |
| end | |
| end OAI | |