Download data/lean/OAI/Analysis/CharacterCriterion/MinTensor.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 16.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/MinTensor.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/CharacterCriterion/MinTensor.lean
-
curl -L -o MinTensor.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/MinTensor.lean
16.6 kB
| import OAI.Analysis.CharacterCriterion.Definitions | |
| import OAI.Analysis.CharacterCriterion.Absorption | |
| namespace OAI | |
| noncomputable section | |
| open scoped TensorProduct | |
| open scoped InnerProductSpace | |
| open scoped BigOperators | |
| open Set Module | |
| open Topology | |
| open NormedSpace | |
| open scoped ComplexOrder | |
| open scoped ComplexOrder | |
| open scoped InnerProductSpace | |
| open scoped InnerProductSpace | |
| open NormedSpace | |
| open scoped TensorProduct InnerProductSpace | |
| open UniformSpace | |
| variable [KirchbergRordam.GenericRW.Size] | |
| local notation "rankNum" => KirchbergRordam.GenericRW.Size.n | |
| variable [KirchbergRordam.GenericRW.PauliData] | |
| omit [KirchbergRordam.GenericRW.Size] [KirchbergRordam.GenericRW.PauliData] | |
| open Filter Topology BoundedContinuousFunction | |
| open Filter Topology | |
| open Topology | |
| open scoped TensorProduct CStarAlgebra | |
| open scoped CStarAlgebra ComplexOrder | |
| open NormedSpace | |
| open scoped ComplexOrder | |
| open scoped ComplexOrder | |
| open scoped InnerProductSpace | |
| section | |
| open scoped CStarAlgebra ComplexOrder | |
| open scoped TensorProduct InnerProductSpace | |
| open UniformSpace | |
| namespace KirchbergRordam.Spatial | |
| variable {H K : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] | |
| [NormedAddCommGroup K] [InnerProductSpace β K] | |
| @[simp] lemma map_coe (T : H βL[β] H) (S : K βL[β] K) (x : H β[β] K) : | |
| map T S (x : Hilbert H K) = (TensorProduct.mapL T S x : H β[β] K) := by | |
| simp [map] | |
| @[ext] lemma ext {T S : Hilbert H K βL[β] Hilbert H K} | |
| (h : β x : H β[β] K, T x = S x) : T = S := by | |
| apply ContinuousLinearMap.ext | |
| intro x | |
| induction x using Completion.induction_on with | |
| | hp => exact isClosed_eq T.continuous S.continuous | |
| | ih x => exact h x | |
| lemma map_add_left (T U : H βL[β] H) (S : K βL[β] K) : | |
| map (T + U) S = map T S + map U S := by | |
| apply ext | |
| intro x | |
| simp [TensorProduct.mapL_add_left, β Completion.coe_add] | |
| lemma map_add_right (T : H βL[β] H) (S U : K βL[β] K) : | |
| map T (S + U) = map T S + map T U := by | |
| apply ext | |
| intro x | |
| simp [TensorProduct.mapL_add_right, β Completion.coe_add] | |
| lemma map_smul_left (z : β) (T : H βL[β] H) (S : K βL[β] K) : | |
| map (z β’ T) S = z β’ map T S := by | |
| apply ext | |
| intro x | |
| simp [TensorProduct.mapL_smul_left, β Completion.coe_smul] | |
| lemma map_smul_right (z : β) (T : H βL[β] H) (S : K βL[β] K) : | |
| map T (z β’ S) = z β’ map T S := by | |
| apply ext | |
| intro x | |
| simp [TensorProduct.mapL_smul_right, β Completion.coe_smul] | |
| lemma map_mul (T U : H βL[β] H) (S V : K βL[β] K) : | |
| map (T * U) (S * V) = map T S * map U V := by | |
| apply ext | |
| intro x | |
| simp only [mul_apply_eq_comp, map_coe, TensorProduct.mapL_mul] | |
| @[simp] lemma map_one : map (1 : H βL[β] H) (1 : K βL[β] K) = 1 := by | |
| apply ext | |
| intro x | |
| simp [show (1 : H βL[β] H) = ContinuousLinearMap.id β H from rfl, | |
| show (1 : K βL[β] K) = ContinuousLinearMap.id β K from rfl] | |
| variable [CompleteSpace H] [CompleteSpace K] | |
| lemma map_inner_algebraic (T : H βL[β] H) (S : K βL[β] K) | |
| (x y : H β[β] K) : | |
| βͺTensorProduct.mapL (star T) (star S) x, yβ«_β = | |
| βͺx, TensorProduct.mapL T S yβ«_β := by | |
| induction x using TensorProduct.inductionOn with | |
| | add x z hx hz => simp only [map_add, inner_add_left, hx, hz] | |
| | tmul a b => | |
| induction y using TensorProduct.inductionOn with | |
| | add y z hy hz => simp only [map_add, inner_add_right, hy, hz] | |
| | tmul c d => | |
| simp only [TensorProduct.mapL_tmul, TensorProduct.inner_tmul, | |
| ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_left] | |
| lemma map_inner (T : H βL[β] H) (S : K βL[β] K) (x y : Hilbert H K) : | |
| βͺmap (star T) (star S) x, yβ«_β = βͺx, map T S yβ«_β := by | |
| induction x, y using Completion.induction_onβ with | |
| | hp => exact isClosed_eq (by fun_prop) (by fun_prop) | |
| | ih x y => simpa using map_inner_algebraic T S x y | |
| lemma map_star (T : H βL[β] H) (S : K βL[β] K) : | |
| map (star T) (star S) = star (map T S) := by | |
| apply ContinuousLinearMap.ext | |
| intro x | |
| apply ext_inner_right β | |
| intro y | |
| rw [map_inner, ContinuousLinearMap.star_eq_adjoint, | |
| ContinuousLinearMap.adjoint_inner_left] | |
| lemma left_right_commute (T : H βL[β] H) (S : K βL[β] K) : | |
| Commute (left (K := K) T) (right (H := H) S) := by | |
| change map T 1 * map 1 S = map 1 S * map T 1 | |
| rw [β map_mul, β map_mul] | |
| simp | |
| end KirchbergRordam.Spatial | |
| end | |
| namespace KirchbergRordam.MinTensor | |
| open scoped TensorProduct | |
| universe u | |
| variable (A B : Type u) [CStarAlgebra A] [CStarAlgebra B] | |
| attribute [instance] RepresentationPair.normH RepresentationPair.innerH | |
| RepresentationPair.completeH RepresentationPair.normK RepresentationPair.innerK | |
| RepresentationPair.completeK | |
| variable {A B} | |
| lemma RepresentationPair.commute (Ο : RepresentationPair A B) (a : A) (b : B) : | |
| Commute (Ο.left a) (Ο.right b) := | |
| Spatial.left_right_commute _ _ | |
| end KirchbergRordam.MinTensor | |
| namespace KirchbergRordam.MinTensor | |
| open scoped TensorProduct | |
| universe u | |
| variable {A B : Type u} [CStarAlgebra A] [CStarAlgebra B] | |
| local instance : Ring (A β[β] B) := | |
| _root_.Algebra.TensorProduct.instRing (R := β) (A := A) (B := B) | |
| lemma bounded : BddAbove (Set.range (fun Ο : Option (RepresentationPair A B) => | |
| (spatialIndex Ο).toSeminorm)) := by | |
| rw [Seminorm.bddAbove_range_iff] | |
| intro x | |
| obtain β¨C,hCβ© := MaxTensor.bounded_at x | |
| exact β¨C,by rintro _ β¨Ο,rflβ©; exact hC _β© | |
| lemma seminorm_apply (x : A β[β] B) : | |
| seminorm x=β¨ Ο : Option (RepresentationPair A B), (spatialIndex Ο).toSeminorm x := | |
| Seminorm.iSup_apply bounded | |
| lemma le_seminorm (Ο : Option (RepresentationPair A B)) (x : A β[β] B) : | |
| (spatialIndex Ο).toSeminorm x β€ seminorm x := by | |
| rw [seminorm_apply] | |
| apply le_ciSup _ Ο | |
| obtain β¨C,hCβ© := MaxTensor.bounded_at x | |
| exact β¨C,by rintro _ β¨Ο,rflβ©; exact hC _β© | |
| lemma seminorm_le {x : A β[β] B} {C : β} | |
| (h : β Ο : Option (RepresentationPair A B), (spatialIndex Ο).toSeminorm x β€ C) : | |
| seminorm x β€ C := by | |
| rw [seminorm_apply] | |
| exact ciSup_le h | |
| lemma seminorm_mul_le (x y : A β[β] B) : | |
| @LE.le β Real.instLE | |
| (seminorm (@Mul.mul (A β[β] B) | |
| (_root_.Algebra.TensorProduct.instRing (R := β) (A := A) (B := B)).toMul x y)) | |
| (@Mul.mul β Real.instMul (seminorm x) (seminorm y)) := by | |
| apply seminorm_le | |
| intro Ο | |
| exact ((spatialIndex Ο).mul_le x y).trans (mul_le_mul (le_seminorm Ο x) | |
| (le_seminorm Ο y) (apply_nonneg _ _) (apply_nonneg _ _)) | |
| lemma seminorm_star (x : A β[β] B) : seminorm (star x)=seminorm x := by | |
| rw [seminorm_apply,seminorm_apply] | |
| congr 1 | |
| funext Ο | |
| exact (spatialIndex Ο).star_eq x | |
| lemma seminorm_cstar (x : A β[β] B) : | |
| seminorm (star x*x)=seminorm x * seminorm x := by | |
| apply le_antisymm | |
| Β· calc | |
| seminorm (star x * x) β€ seminorm (star x) * seminorm x := seminorm_mul_le (star x) x | |
| _ = seminorm x * seminorm x := by rw [seminorm_star] | |
| Β· have h : seminorm x β€ Real.sqrt (seminorm (star x*x)) := by | |
| apply seminorm_le | |
| intro Ο | |
| apply (Real.le_sqrt (apply_nonneg _ _) (apply_nonneg _ _)).mpr | |
| simpa only [β (spatialIndex Ο).cstar_eq x,pow_two] using le_seminorm Ο (star x*x) | |
| have := mul_self_le_mul_self (apply_nonneg seminorm x) h | |
| rwa [Real.mul_self_sqrt (apply_nonneg seminorm _)] at this | |
| lemma seminorm_tmul_le (a : A) (b : B) : seminorm (a ββ[β] b) β€ βaβ * βbβ := | |
| seminorm_le fun Ο => (spatialIndex Ο).tmul_le a b | |
| lemma seminorm_le_maximal : (seminorm : Seminorm β (A β[β] B)) β€ MaxTensor.seminorm := | |
| fun x => seminorm_le fun Ο => MaxTensor.le_seminorm (spatialIndex Ο) x | |
| theorem exists_spatial_crossSeminorm (A B : Type u) [CStarAlgebra A] [CStarAlgebra B] : | |
| β p : MaxTensor.CrossSeminorm A B, p.toSeminorm=seminorm β§ | |
| p.toSeminorm β€ MaxTensor.seminorm := by | |
| exact β¨{toSeminorm := seminorm | |
| mul_le := seminorm_mul_le | |
| star_eq := seminorm_star | |
| cstar_eq := seminorm_cstar | |
| tmul_le := seminorm_tmul_le},rfl,seminorm_le_maximalβ© | |
| end KirchbergRordam.MinTensor | |
| namespace KirchbergRordam.MinTensor | |
| open scoped TensorProduct CStarAlgebra | |
| universe u | |
| variable (A B : Type u) [CStarAlgebra A] [CStarAlgebra B] | |
| variable {A B} | |
| instance : StarModule β (Raw A B) := TensorProduct.instStarModule | |
| def rawEquiv : (A β[β] B) βββ[β] Raw A B := | |
| StarAlgEquiv.refl β (A β[β] B) | |
| instance : NormedAlgebra β (Raw A B) where | |
| norm_smul_le z x := (map_smul_eq_mul seminorm z x).le | |
| instance : NormedStarGroup (Raw A B) where | |
| norm_star_le x := (seminorm_star x).le | |
| @[simp] lemma norm_raw (x : Raw A B) : βxβ = seminorm x := rfl | |
| instance : CStarRing (Algebra A B) where | |
| norm_mul_self_le x := by | |
| induction x using UniformSpace.Completion.induction_on with | |
| | hp => exact isClosed_le (by fun_prop) (by fun_prop) | |
| | ih x => | |
| simp only [StarCompletion.star_coe, β UniformSpace.Completion.coe_mul, | |
| UniformSpace.Completion.norm_coe, norm_raw] | |
| exact (seminorm_cstar x).ge | |
| instance : CStarAlgebra (Algebra A B) where | |
| def of : Raw A B βββ[β] Algebra A B where | |
| __ := UniformSpace.Completion.coeRingHom | |
| commutes' _ := rfl | |
| map_star' x := (StarCompletion.star_coe _ x).symm | |
| @[simp] lemma norm_of (x : Raw A B) : βof xβ = seminorm x := | |
| UniformSpace.Completion.norm_coe x | |
| lemma denseRange_of : DenseRange (of (A := A) (B := B)) := | |
| UniformSpace.Completion.denseRange_coe | |
| def includeLeft : A βββ[β] Algebra A B := of.comp (rawEquiv.toStarAlgHom.comp { | |
| toAlgHom := _root_.Algebra.TensorProduct.includeLeft | |
| map_star' a := by simp }) | |
| def includeRight : B βββ[β] Algebra A B := of.comp (rawEquiv.toStarAlgHom.comp { | |
| toAlgHom := _root_.Algebra.TensorProduct.includeRight | |
| map_star' b := by simp }) | |
| lemma legs_commute (a : A) (b : B) : | |
| Commute (includeLeft (B := B) a) (includeRight (A := A) b) := by | |
| change of (rawEquiv (a ββ[β] (1 : B))) * of (rawEquiv ((1 : A) ββ[β] b)) = | |
| of (rawEquiv ((1 : A) ββ[β] b)) * of (rawEquiv (a ββ[β] (1 : B))) | |
| rw [β map_mul, β map_mul, β map_mul, β map_mul] | |
| congr 2 | |
| simp only [_root_.Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul] | |
| def spatialRaw (Ο : RepresentationPair A B) : | |
| Raw A B βββ[β] (Spatial.Hilbert Ο.H Ο.K βL[β] Spatial.Hilbert Ο.H Ο.K) := | |
| (MaxTensor.liftRaw (A := A) (B := B) | |
| (C := (Spatial.Hilbert Ο.H Ο.K βL[β] Spatial.Hilbert Ο.H Ο.K)) | |
| Ο.left Ο.right Ο.commute).comp rawEquiv.symm.toStarAlgHom | |
| lemma norm_spatialRaw_le (Ο : RepresentationPair A B) (x : Raw A B) : | |
| βspatialRaw Ο xβ β€ βxβ := | |
| le_seminorm (some Ο) x | |
| lemma lipschitz_spatialRaw (Ο : RepresentationPair A B) : LipschitzWith 1 (spatialRaw Ο) := by | |
| apply LipschitzWith.of_dist_le_mul | |
| intro x y | |
| simp only [NNReal.coe_one, one_mul, dist_eq_norm, β map_sub] | |
| exact norm_spatialRaw_le Ο (x-y) | |
| lemma continuous_spatialRaw (Ο : RepresentationPair A B) : Continuous (spatialRaw Ο) := | |
| (lipschitz_spatialRaw Ο).continuous | |
| private def extendHom {C : Type*} [NormedRing C] [NormedAlgebra β C] | |
| [StarRing C] [NormedStarGroup C] [CompleteSpace C] | |
| (f : Raw A B βββ[β] C) (hf : Continuous f) : Algebra A B βββ[β] C where | |
| __ := UniformSpace.Completion.extensionHom f.toRingHom hf | |
| commutes' z := by | |
| change UniformSpace.Completion.extensionHom f.toRingHom hf | |
| (algebraMap β (Raw A B) z) = _ | |
| rw [UniformSpace.Completion.extensionHom_coe] | |
| exact f.commutes z | |
| map_star' x := by | |
| induction x using UniformSpace.Completion.induction_on with | |
| | hp => | |
| exact isClosed_eq | |
| (UniformSpace.Completion.continuous_extension.comp continuous_star) | |
| (continuous_star.comp UniformSpace.Completion.continuous_extension) | |
| | ih x => | |
| change UniformSpace.Completion.extensionHom f.toRingHom hf | |
| (star (x : Algebra A B)) = | |
| star (UniformSpace.Completion.extensionHom f.toRingHom hf (x : Algebra A B)) | |
| simp only [StarCompletion.star_coe, UniformSpace.Completion.extensionHom_coe] | |
| exact map_star f x | |
| private lemma extendHom_of {C : Type*} [NormedRing C] [NormedAlgebra β C] | |
| [StarRing C] [NormedStarGroup C] [CompleteSpace C] | |
| (f : Raw A B βββ[β] C) (hf : Continuous f) (x : Raw A B) : | |
| extendHom f hf (of x) = f x := | |
| UniformSpace.Completion.extensionHom_coe _ hf x | |
| def spatialLift (Ο : RepresentationPair A B) : | |
| Algebra A B βββ[β] (Spatial.Hilbert Ο.H Ο.K βL[β] Spatial.Hilbert Ο.H Ο.K) := | |
| extendHom (A := A) (B := B) | |
| (C := Spatial.Hilbert Ο.H Ο.K βL[β] Spatial.Hilbert Ο.H Ο.K) | |
| (spatialRaw Ο) (continuous_spatialRaw Ο) | |
| def fromMaximal : MaxTensor.Algebra A B βββ[β] Algebra A B := | |
| MaxTensor.lift includeLeft includeRight legs_commute | |
| @[simp] lemma fromMaximal_of (x : A β[β] B) : | |
| fromMaximal (MaxTensor.of (MaxTensor.rawEquiv x)) = | |
| of (rawEquiv (A := A) (B := B) x) := by | |
| induction x using TensorProduct.inductionOn with | |
| | add x y hx hy => simpa only [map_add] using congrArgβ (Β· + Β·) hx hy | |
| | tmul a b => | |
| change MaxTensor.lift includeLeft includeRight legs_commute | |
| (MaxTensor.of (a ββ[β] b)) = _ | |
| rw [MaxTensor.lift_of_tmul] | |
| change of (rawEquiv (a ββ[β] (1 : B))) * of (rawEquiv ((1 : A) ββ[β] b)) = of (rawEquiv (a ββ[β] b)) | |
| rw [β map_mul, β map_mul] | |
| congr 2 | |
| simp only [_root_.Algebra.TensorProduct.tmul_mul_tmul,mul_one,one_mul] | |
| lemma fromMaximal_denseRange : DenseRange (fromMaximal (A := A) (B := B)) := | |
| denseRange_of.mono (by | |
| rintro _ β¨x, rflβ© | |
| exact β¨MaxTensor.of (MaxTensor.rawEquiv (rawEquiv.symm x)), by simpβ©) | |
| end KirchbergRordam.MinTensor | |
| namespace KirchbergRordam | |
| namespace Spatial | |
| open scoped TensorProduct | |
| variable {H K : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] | |
| [NormedAddCommGroup K] [InnerProductSpace β K] [Nontrivial H] [Nontrivial K] | |
| instance : Nontrivial (Hilbert H K) := | |
| (UniformSpace.Completion.coe_injective (H β[β] K)).nontrivial | |
| end Spatial | |
| namespace MinTensor | |
| universe u | |
| variable (A B : Type u) [CStarAlgebra A] [CStarAlgebra B] | |
| [Nontrivial A] [Nontrivial B] | |
| instance : Nontrivial (Algebra A B) := by | |
| obtain β¨Οβ© := exists_irreducible_representation A | |
| obtain β¨Οβ© := exists_irreducible_representation B | |
| let Ο : RepresentationPair A B := { | |
| H := Ο.space | |
| K := Ο.space | |
| normH := inferInstance | |
| innerH := inferInstance | |
| completeH := inferInstance | |
| normK := inferInstance | |
| innerK := inferInstance | |
| completeK := inferInstance | |
| leftRep := Ο.representation | |
| rightRep := Ο.representation } | |
| exact (spatialLift Ο).toRingHom.domain_nontrivial | |
| end MinTensor | |
| end KirchbergRordam | |
| namespace KirchbergRordam.States | |
| open scoped ComplexOrder | |
| theorem exists_norming_state (A : Type*) [CStarAlgebra A] [Nontrivial A] | |
| [PartialOrder A] [StarOrderedRing A] (a : A) : | |
| β Ο : A ββ[β] β, Ο 1 = 1 β§ βΟ (star a * a)β = βaβ ^ 2 := by | |
| let b := star a * a | |
| have hb : 0 β€ b := star_mul_self_nonneg a | |
| let : IsStarNormal b := (IsSelfAdjoint.of_nonneg hb).isStarNormal | |
| let S := StarAlgebra.elemental β b | |
| have hs : (βbβ : β) β spectrum β b := by | |
| exact spectrum.algebraMap_mem β (CStarAlgebra.norm_mem_spectrum_of_nonneg b hb) | |
| obtain β¨Ο,hΟβ© := (StarAlgebra.elemental.bijective_characterSpaceToSpectrum b).surjective | |
| β¨(βbβ : β),hsβ© | |
| let g : S ββ[β] β := WeakDual.CharacterSpace.equivAlgHom Ο | |
| let : StarHomClass (S ββ[β] β) S β := AlgHomClass.instStarHomClass | |
| have hg : βg.toContinuousLinearMapβ β€ 1 := by | |
| apply ContinuousLinearMap.opNorm_le_bound _ zero_le_one | |
| intro x | |
| simpa only [one_mul, AlgHom.coe_toContinuousLinearMap] using NonUnitalStarAlgHom.norm_apply_le g x | |
| obtain β¨Ο,hΟ,hΟnormβ© := exists_extension_norm_eq S.toSubalgebra.toSubmodule | |
| g.toContinuousLinearMap | |
| have hΟ1 : Ο 1 = 1 := by | |
| exact (hΟ (1 : S)).trans (map_one g) | |
| have hΟb : Ο b = (βbβ : β) := by | |
| have hh := congrArg Subtype.val hΟ | |
| exact (hΟ β¨b,StarAlgebra.elemental.self_mem β bβ©).trans hh | |
| let Ο : A ββ[β] β := PositiveLinearMap.mkβ Ο.toLinearMap | |
| (eval_nonneg Ο (hΟnorm.trans_le hg) hΟ1) | |
| refine β¨Ο,hΟ1,?_β© | |
| change βΟ bβ = βaβ ^ 2 | |
| rw [hΟb,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (norm_nonneg b)] | |
| simp only [b,CStarRing.norm_star_mul_self,pow_two] | |
| end KirchbergRordam.States | |
| end | |
| end OAI | |