Download data/lean/OAI/Analysis/FactorGeneration/OperatorLimits.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 8.95 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/FactorGeneration/OperatorLimits.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/FactorGeneration/OperatorLimits.lean
-
curl -L -o OperatorLimits.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/FactorGeneration/OperatorLimits.lean
8.95 kB
| import Mathlib.Analysis.InnerProductSpace.StarOrder | |
| import Mathlib.Analysis.InnerProductSpace.WeakOperatorTopology | |
| import Mathlib.Analysis.Normed.Module.Basic | |
| import Mathlib.Analysis.Normed.Module.WeakDual | |
| import Mathlib.Analysis.Normed.Ring.Lemmas | |
| import Mathlib.Analysis.VonNeumannAlgebra.Basic | |
| import Mathlib.Topology.Algebra.Algebra | |
| namespace OAI | |
| noncomputable section | |
| namespace Generator | |
| /-! Operator-norm completeness of the manuscript's concrete algebra, derived | |
| from its actual double-commutant property. No quotient completeness is assumed. -/ | |
| namespace Tracial | |
| section | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| theorem base_norm_closed (M : VonNeumannAlgebra H) : | |
| IsClosed (M.toStarSubalgebra : Set (H βL[β] H)) := by | |
| change IsClosed (M : Set (H βL[β] H)) | |
| rw [β M.centralizer_centralizer] | |
| exact Set.isClosed_centralizer _ | |
| instance baseCompleteSpace (M : VonNeumannAlgebra H) : CompleteSpace M.toStarSubalgebra := | |
| (base_norm_closed M).completeSpace_coe | |
| instance baseNormedAlgebraRat (M : VonNeumannAlgebra H) : NormedAlgebra β M.toStarSubalgebra := | |
| .restrictScalars β β M.toStarSubalgebra | |
| end | |
| /-! Bounded operator families have weak operator ultralimits. This is proved | |
| from Banach--Alaoglu and Riesz representation, not assumed as compactness. -/ | |
| open Filter | |
| open scoped Topology | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| theorem exists_weak_vector_ultralimit {ΞΉ : Type*} (Ο : Ultrafilter ΞΉ) | |
| (v : ΞΉ β H) (C : β) (hv : β i, βv iβ β€ C) : | |
| β z : H, βzβ β€ C β§ β y : H, | |
| Tendsto (fun i => inner β y (v i)) (Ο : Filter ΞΉ) (π (inner β y z)) := by | |
| let f : ΞΉ β WeakDual β H := fun i => | |
| StrongDual.toWeakDual (InnerProductSpace.toDual β H (v i)) | |
| obtain β¨d, hd, htβ© := (WeakDual.isCompact_closedBall (0 : StrongDual β H) C).ultrafilter_le_nhds | |
| (Ο.map f) (by | |
| apply le_principal_iff.mpr | |
| change βαΆ i in (Ο : Filter ΞΉ), f i β _ | |
| exact Eventually.of_forall fun i => by | |
| simpa [f, Metric.mem_closedBall, dist_zero_right] using hv i) | |
| let z := (InnerProductSpace.toDual β H).symm (WeakDual.toStrongDual d) | |
| refine β¨z, ?_, ?_β© | |
| Β· have hd' : βWeakDual.toStrongDual dβ β€ C := by | |
| simpa only [Set.mem_preimage, Metric.mem_closedBall, dist_zero_right] using hd | |
| simpa only [z, LinearIsometryEquiv.norm_map] using hd' | |
| Β· intro y | |
| have he : Tendsto (fun i => inner β (v i) y) (Ο : Filter ΞΉ) | |
| (π (inner β z y)) := by | |
| have h := (WeakBilin.eval_continuous _ y).continuousAt.tendsto.comp ht | |
| change Tendsto (fun i => inner β (v i) y) (Ο : Filter ΞΉ) (π (d y)) at h | |
| rw [show inner β z y = d y from InnerProductSpace.toDual_symm_apply] | |
| exact h | |
| have hs := he.star | |
| change Tendsto (fun i => (starRingEnd β) (inner β (v i) y)) (Ο : Filter ΞΉ) | |
| (π ((starRingEnd β) (inner β z y))) at hs | |
| simpa only [inner_conj_symm] using hs | |
| theorem exists_weak_operator_ultralimit {ΞΉ : Type*} (Ο : Ultrafilter ΞΉ) | |
| (a : ΞΉ β H βL[β] H) (C : β) (hC : 0 β€ C) (ha : β i, βa iβ β€ C) : | |
| β T : H βL[β] H, βTβ β€ C β§ β x y : H, | |
| Tendsto (fun i => inner β y (a i x)) (Ο : Filter ΞΉ) (π (inner β y (T x))) := by | |
| have h (x : H) := exists_weak_vector_ultralimit Ο (fun i => a i x) (C * βxβ) | |
| (fun i => (a i).le_of_opNorm_le (ha i) x) | |
| choose v hv ht using h | |
| have hadd (x z : H) : v (x+z) = v x + v z := by | |
| apply ext_inner_left β | |
| intro y | |
| apply tendsto_nhds_unique (ht (x+z) y) | |
| simpa only [map_add, inner_add_right] using (ht x y).add (ht z y) | |
| have hsmul (c : β) (x : H) : v (c β’ x) = c β’ v x := by | |
| apply ext_inner_left β | |
| intro y | |
| apply tendsto_nhds_unique (ht (c β’ x) y) | |
| simpa only [map_smul, inner_smul_right] using (ht x y).const_mul c | |
| let T : H βL[β] H := LinearMap.mkContinuous | |
| { toFun := v, map_add' := hadd, map_smul' := hsmul } C hv | |
| exact β¨T, T.opNorm_le_bound hC hv, htβ© | |
| /-- The double-commutant property retains the weak limit in the actual algebra. -/ | |
| theorem weak_operator_limit_mem (M : VonNeumannAlgebra H) | |
| {ΞΉ : Type*} {l : Filter ΞΉ} [l.NeBot] (a : ΞΉ β M.toStarSubalgebra) | |
| (T : H βL[β] H) | |
| (ht : β x y : H, Tendsto (fun i => inner β y ((a i : H βL[β] H) x)) l | |
| (π (inner β y (T x)))) : T β M := by | |
| change T β (M : Set (H βL[β] H)) | |
| rw [β M.centralizer_centralizer] | |
| intro S hS | |
| apply ContinuousLinearMap.ext | |
| intro x | |
| apply ext_inner_left β | |
| intro y | |
| have he (i : ΞΉ) : inner β y ((a i : H βL[β] H) (S x)) = | |
| inner β (star S y) ((a i : H βL[β] H) x) := by | |
| rw [ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_left] | |
| exact congrArg (fun R : H βL[β] H => inner β y (R x)) (hS (a i) (a i).property) | |
| have hh := (ht (S x) y).congr he | |
| have heq := tendsto_nhds_unique hh (ht x (star S y)) | |
| simpa only [ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_left, mul_apply_eq_comp] using heq.symm | |
| /-! Operator-norm balls of an actual von Neumann algebra are compact for the | |
| weak operator topology, using the previously constructed operator ultralimits. -/ | |
| def weakOperatorBall (M : VonNeumannAlgebra H) (C : β) : Set (H βWOT[β] H) := | |
| {T | T.toCLM β M β§ βT.toCLMβ β€ C} | |
| theorem weakOperatorBall_isCompact (M : VonNeumannAlgebra H) (C : β) : | |
| IsCompact (weakOperatorBall M C) := by | |
| classical | |
| by_cases hC : 0 β€ C | |
| Β· apply isCompact_iff_ultrafilter_le_nhds'.mpr | |
| intro Ο hΟ | |
| let a : (H βWOT[β] H) β M.toStarSubalgebra := fun T => | |
| if h : T β weakOperatorBall M C then β¨T.toCLM,h.1β© else 0 | |
| have ha (T : H βWOT[β] H) : βa Tβ β€ C := by | |
| dsimp [a] | |
| split_ifs with h | |
| Β· exact h.2 | |
| Β· change β(0 : H βL[β] H)β β€ C | |
| simpa only [norm_zero] using hC | |
| obtain β¨T,hT,htβ© := exists_weak_operator_ultralimit Ο (fun U => (a U).val) C hC ha | |
| have hm := weak_operator_limit_mem M a T ht | |
| refine β¨ContinuousLinearMapWOT.ofCLM T,β¨hm,hTβ©,?_β© | |
| have hl : Tendsto (fun U => ContinuousLinearMapWOT.ofCLM (a U).val) | |
| (Ο : Filter (H βWOT[β] H)) (π (ContinuousLinearMapWOT.ofCLM T)) := | |
| ContinuousLinearMapWOT.tendsto_iff_forall_inner_apply_tendsto.mpr ht | |
| have he : (fun U => ContinuousLinearMapWOT.ofCLM (a U).val) =αΆ [Ο] id := by | |
| filter_upwards [show βαΆ U in (Ο : Filter (H βWOT[β] H)),U β weakOperatorBall M C from hΟ] | |
| with U hU | |
| simp only [a,dite_eq_left hU,ContinuousLinearMapWOT.ofCLM_toCLM,id_eq] | |
| exact hl.congr' he | |
| Β· have he : weakOperatorBall M C=β := by | |
| apply Set.eq_empty_iff_forall_notMem.mpr | |
| intro T hT | |
| exact hC ((norm_nonneg _).trans hT.2) | |
| rw [he] | |
| exact isCompact_empty | |
| theorem weakOperatorBall_isClosed (M : VonNeumannAlgebra H) (C : β) : | |
| IsClosed (weakOperatorBall M C) := (weakOperatorBall_isCompact M C).isClosed | |
| end Tracial | |
| /-! Operator order bounds are closed in the weak operator topology. -/ | |
| variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace β H] [CompleteSpace H] | |
| theorem weakOperator_nonneg_isClosed : | |
| IsClosed {T : H βWOT[β] H | 0 β€ T.toCLM} := by | |
| have hi (x : H) : Continuous (fun T : H βWOT[β] H => inner β (T x) x) := by | |
| simpa only [Function.comp_def, id_eq, inner_conj_symm] using | |
| (Complex.continuous_conj.comp | |
| (ContinuousLinearMapWOT.continuous_inner_apply continuous_id x x)) | |
| have he : {T : H βWOT[β] H | 0 β€ T.toCLM} = | |
| β x : H, {T : H βWOT[β] H | | |
| ((inner β (T x) x).re : β) = inner β (T x) x β§ 0 β€ (inner β (T x) x).re} := by | |
| ext T | |
| simp only [Set.mem_ofPred_eq, Set.mem_iInter, ContinuousLinearMap.nonneg_iff_isPositive, | |
| ContinuousLinearMap.isPositive_iff_complex] | |
| rfl | |
| rw [he] | |
| apply isClosed_iInter | |
| intro x | |
| exact (isClosed_eq (Complex.continuous_ofReal.comp (Complex.continuous_re.comp (hi x))) | |
| (hi x)).inter (isClosed_le continuous_const (Complex.continuous_re.comp (hi x))) | |
| theorem weakOperator_lowerBound_isClosed (a : H βL[β] H) : | |
| IsClosed {T : H βWOT[β] H | a β€ T.toCLM} := by | |
| have h := (weakOperator_nonneg_isClosed (H := H)).preimage | |
| (continuous_id.sub (continuous_const (y := ContinuousLinearMapWOT.ofCLM a))) | |
| convert h using 1 | |
| ext T | |
| change (a β€ T.toCLM) β 0 β€ T.toCLM - a | |
| exact sub_nonneg.symm | |
| theorem weakOperator_upperBound_isClosed (b : H βL[β] H) : | |
| IsClosed {T : H βWOT[β] H | T.toCLM β€ b} := by | |
| have h := (weakOperator_nonneg_isClosed (H := H)).preimage | |
| ((continuous_const (y := ContinuousLinearMapWOT.ofCLM b)).sub continuous_id) | |
| convert h using 1 | |
| ext T | |
| change (T.toCLM β€ b) β 0 β€ b - T.toCLM | |
| exact sub_nonneg.symm | |
| end Generator | |
| end | |
| end OAI | |