Download data/lean/OAI/Analysis/CharacterCriterion/BalancedLimit.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 18.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/BalancedLimit.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/CharacterCriterion/BalancedLimit.lean
-
curl -L -o BalancedLimit.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/CharacterCriterion/BalancedLimit.lean
18.5 kB
| import OAI.Analysis.CharacterCriterion.BalancedSystem | |
| 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 | |
| local notation "rankNum" => KirchbergRordam.GenericRW.Size.n | |
| variable | |
| omit | |
| open Filter Topology BoundedContinuousFunction | |
| open Filter Topology | |
| open Topology | |
| open scoped TensorProduct CStarAlgebra | |
| open scoped CStarAlgebra ComplexOrder | |
| namespace KirchbergRordam | |
| open scoped Matrix Kronecker ComplexOrder | |
| abbrev M2 := CStarMatrix (Fin 2) (Fin 2) β | |
| abbrev M3 := CStarMatrix (Fin 3) (Fin 3) β | |
| abbrev M6 := CStarMatrix (Fin 2 Γ Fin 3) (Fin 2 Γ Fin 3) β | |
| def leftMatrixAlgebra : Matrix (Fin 2) (Fin 2) β βββ[β] | |
| Matrix (Fin 2 Γ Fin 3) (Fin 2 Γ Fin 3) β where | |
| toFun a := a ββ (1 : Matrix (Fin 3) (Fin 3) β) | |
| map_zero' := Matrix.zero_kronecker _ | |
| map_one' := Matrix.one_kronecker_one | |
| map_add' a b := Matrix.add_kronecker _ _ _ | |
| map_mul' a b := by | |
| simpa only | |
| map_star' a := by | |
| change aα΄΄ ββ (1 : Matrix (Fin 3) (Fin 3) β) = (a ββ 1)α΄΄ | |
| rw | |
| def rightMatrixAlgebra : Matrix (Fin 3) (Fin 3) β βββ[β] | |
| Matrix (Fin 2 Γ Fin 3) (Fin 2 Γ Fin 3) β where | |
| toFun a := (1 : Matrix (Fin 2) (Fin 2) β) ββ a | |
| map_zero' := Matrix.kronecker_zero _ | |
| map_one' := Matrix.one_kronecker_one | |
| map_add' a b := Matrix.kronecker_add _ _ _ | |
| map_mul' a b := by | |
| simpa only | |
| map_star' a := by | |
| change (1 : Matrix (Fin 2) (Fin 2) β) ββ aα΄΄ = (1 ββ a)α΄΄ | |
| rw | |
| def leftMatrix : M2 βββ[β] M6 := | |
| CStarMatrix.ofMatrixStarAlgEquiv.toStarAlgHom.comp | |
| (leftMatrixAlgebra.comp CStarMatrix.ofMatrixStarAlgEquiv.symm.toStarAlgHom) | |
| def rightMatrix : M3 βββ[β] M6 := | |
| CStarMatrix.ofMatrixStarAlgEquiv.toStarAlgHom.comp | |
| (rightMatrixAlgebra.comp CStarMatrix.ofMatrixStarAlgEquiv.symm.toStarAlgHom) | |
| def matrixEval (t : unitInterval) : C(unitInterval, M6) βββ[β] M6 where | |
| toFun f := f t | |
| map_zero' := rfl | |
| map_one' := rfl | |
| map_add' _ _ := rfl | |
| map_mul' _ _ := rfl | |
| commutes' _ := rfl | |
| map_star' _ := rfl | |
| def dimensionDropSubalgebra : StarSubalgebra β C(unitInterval, M6) := | |
| leftMatrix.range.comap (matrixEval 0) β rightMatrix.range.comap (matrixEval 1) | |
| instance : FiniteDimensional β M6 := | |
| inferInstanceAs (FiniteDimensional β (Matrix (Fin 2 Γ Fin 3) (Fin 2 Γ Fin 3) β)) | |
| instance dimensionDropClosed : IsClosed | |
| (dimensionDropSubalgebra : Set C(unitInterval, M6)) := by | |
| change IsClosed ((fun f : C(unitInterval, M6) => f 0) β»ΒΉ' (leftMatrix.range : Set M6) β© | |
| (fun f : C(unitInterval, M6) => f 1) β»ΒΉ' (rightMatrix.range : Set M6)) | |
| exact ((leftMatrix.range.toSubalgebra.toSubmodule.closed_of_finiteDimensional).preimage | |
| (continuous_eval_const (0 : unitInterval))).inter | |
| ((rightMatrix.range.toSubalgebra.toSubmodule.closed_of_finiteDimensional).preimage | |
| (continuous_eval_const (1 : unitInterval))) | |
| abbrev DimensionDrop23 := dimensionDropSubalgebra | |
| instance dropSubringClass : SubringClass | |
| (StarSubalgebra β C(unitInterval, M6)) C(unitInterval, M6) := | |
| StarSubalgebra.subringClass (R := β) (A := C(unitInterval, M6)) | |
| instance : CStarAlgebra DimensionDrop23 := | |
| StarSubalgebra.cstarAlgebra dimensionDropSubalgebra | |
| example : Nontrivial DimensionDrop23 := inferInstance | |
| def dropCoordinate : DimensionDrop23 := | |
| β¨β¨fun t => ((t : β) : β) β’ (1 : M6), by fun_propβ©, | |
| by | |
| constructor | |
| Β· change β a : M2, leftMatrix a = ((0 : unitInterval) : β) β’ (1 : M6) | |
| exact β¨0, by simpβ© | |
| Β· change β a : M3, rightMatrix a = ((1 : unitInterval) : β) β’ (1 : M6) | |
| exact β¨1, by simpβ©β© | |
| def leftCone (a : M2) : DimensionDrop23 := | |
| β¨β¨fun t => (1 - ((t : β) : β)) β’ leftMatrix a, by fun_propβ©, | |
| by | |
| constructor | |
| Β· refine β¨a, ?_β© | |
| change leftMatrix a = (1 - (((0 : unitInterval) : β) : β)) β’ leftMatrix a | |
| simp | |
| Β· refine β¨0, ?_β© | |
| change rightMatrix 0 = (1 - (((1 : unitInterval) : β) : β)) β’ leftMatrix a | |
| simpβ© | |
| def rightCone (a : M3) : DimensionDrop23 := | |
| β¨β¨fun t => ((t : β) : β) β’ rightMatrix a, by fun_propβ©, | |
| by | |
| constructor | |
| Β· refine β¨0, ?_β© | |
| change leftMatrix 0 = (((0 : unitInterval) : β) : β) β’ rightMatrix a | |
| simp | |
| Β· refine β¨a, ?_β© | |
| change rightMatrix a = (((1 : unitInterval) : β) : β) β’ rightMatrix a | |
| simpβ© | |
| def matrixUnit {n : β} (i j : Fin n) : CStarMatrix (Fin n) (Fin n) β := | |
| CStarMatrix.ofMatrixStarAlgEquiv (Matrix.single i j 1) | |
| @[ext] | |
| theorem drop_ext {f g : DimensionDrop23} | |
| (h : β t, (f : C(unitInterval, M6)) t = (g : C(unitInterval, M6)) t) : f = g := by | |
| apply Subtype.ext | |
| exact ContinuousMap.ext h | |
| @[simp] | |
| theorem matrixUnit_mul {n : β} (i j k : Fin n) : | |
| matrixUnit i j * matrixUnit j k = matrixUnit i k := by | |
| unfold matrixUnit | |
| rw | |
| simp only | |
| theorem matrixUnit_mul_self {n : β} (i j : Fin n) (h : i β j) : | |
| matrixUnit i j * matrixUnit i j = 0 := by | |
| unfold matrixUnit | |
| rw | |
| theorem leftCone_mul_self (a : M2) (ha : a * a = 0) : | |
| leftCone a * leftCone a = 0 := by | |
| apply drop_ext | |
| intro t | |
| change ((1 - ((t : β) : β)) β’ leftMatrix a) * | |
| ((1 - ((t : β) : β)) β’ leftMatrix a) = 0 | |
| rw | |
| theorem rightCone_mul_self (a : M3) (ha : a * a = 0) : | |
| rightCone a * rightCone a = 0 := by | |
| apply drop_ext | |
| intro t | |
| change (((t : β) : β) β’ rightMatrix a) * | |
| (((t : β) : β) β’ rightMatrix a) = 0 | |
| rw | |
| theorem matrixUnit_two_diagonal : | |
| matrixUnit (0 : Fin 2) 0 + matrixUnit 1 1 = 1 := by | |
| apply CStarMatrix.ext | |
| intro i j | |
| change Matrix.single (0 : Fin 2) 0 (1 : β) i j + Matrix.single 1 1 1 i j = | |
| (1 : Matrix (Fin 2) (Fin 2) β) i j | |
| fin_cases i <;> fin_cases j <;> norm_num | |
| theorem matrixUnit_three_diagonal : | |
| matrixUnit (0 : Fin 3) 0 + matrixUnit 1 1 + matrixUnit 2 2 = 1 := by | |
| apply CStarMatrix.ext | |
| intro i j | |
| change Matrix.single (0 : Fin 3) 0 (1 : β) i j + Matrix.single 1 1 1 i j + | |
| Matrix.single 2 2 1 i j = (1 : Matrix (Fin 3) (Fin 3) β) i j | |
| fin_cases i <;> fin_cases j <;> norm_num | |
| theorem drop_left_identity : | |
| leftCone (matrixUnit 0 1) * leftCone (matrixUnit 1 0) + | |
| leftCone (matrixUnit 1 0) * leftCone (matrixUnit 0 1) = (1 - dropCoordinate) ^ 2 := by | |
| apply drop_ext | |
| intro t | |
| let z : β := (t : β) | |
| change ((1-z) β’ leftMatrix (matrixUnit 0 1)) * ((1-z) β’ leftMatrix (matrixUnit 1 0)) + | |
| ((1-z) β’ leftMatrix (matrixUnit 1 0)) * ((1-z) β’ leftMatrix (matrixUnit 0 1)) = | |
| ((1 : M6) - z β’ 1) ^ 2 | |
| rw | |
| have h : (1 : M6) - z β’ 1 = (1-z) β’ (1 : M6) := by rw | |
| rw | |
| theorem drop_right_identity : | |
| rightCone (matrixUnit 0 1) * rightCone (matrixUnit 1 0) + | |
| rightCone (matrixUnit 1 0) * rightCone (matrixUnit 0 1) + | |
| rightCone (matrixUnit 2 0) * rightCone (matrixUnit 0 2) = dropCoordinate ^ 2 := by | |
| apply drop_ext | |
| intro t | |
| let z : β := (t : β) | |
| change (z β’ rightMatrix (matrixUnit 0 1)) * (z β’ rightMatrix (matrixUnit 1 0)) + | |
| (z β’ rightMatrix (matrixUnit 1 0)) * (z β’ rightMatrix (matrixUnit 0 1)) + | |
| (z β’ rightMatrix (matrixUnit 2 0)) * (z β’ rightMatrix (matrixUnit 0 2)) = | |
| (z β’ (1 : M6)) ^ 2 | |
| rw | |
| theorem dimensionDrop23_no_ringhom : IsEmpty (DimensionDrop23 β+* β) := by | |
| refine β¨fun f => ?_β© | |
| have kill {x : DimensionDrop23} (hx : x * x = 0) : f x = 0 := by | |
| apply eq_zero_of_mul_self_eq_zero | |
| rw | |
| have hL (i j : Fin 2) (h : i β j) : f (leftCone (matrixUnit i j)) = 0 := | |
| kill (leftCone_mul_self _ (matrixUnit_mul_self i j h)) | |
| have hR (i j : Fin 3) (h : i β j) : f (rightCone (matrixUnit i j)) = 0 := | |
| kill (rightCone_mul_self _ (matrixUnit_mul_self i j h)) | |
| have hl : f (1 - dropCoordinate) = 0 := by | |
| apply eq_zero_of_pow_eq_zero (n := 2) | |
| rw | |
| simp only | |
| have hr : f dropCoordinate = 0 := by | |
| apply eq_zero_of_pow_eq_zero (n := 2) | |
| rw | |
| simp only | |
| apply one_ne_zero (Ξ± := β) | |
| simpa only | |
| rfl | |
| rw | |
| lemma quotient_eq_of_eventuallyEq (Ο : Ultrafilter β) | |
| {x y : NormUltrapower.BoundedSeq B} | |
| (h : βαΆ m in (Ο : Filter β), x m=y m) : | |
| NormUltrapower.quotientMap Ο x=NormUltrapower.quotientMap Ο y := by | |
| apply (NormUltrapower.quotient_eq_iff Ο x y).mpr | |
| apply tendsto_const_nhds.congr' | |
| filter_upwards | |
| def stageSeq (S : System) (Ο : β n, S.obj n βββ[β] B) | |
| (n : β) (x : S.obj n) : NormUltrapower.BoundedSeq B := | |
| BoundedContinuousFunction.ofNormedAddCommGroupDiscrete | |
| (fun m => if h : n β€ m then Ο m (S.map n m h x) else 0) | |
| βxβ (fun m => by | |
| split_ifs with h | |
| Β· exact (NonUnitalStarAlgHom.norm_apply_le (Ο m) _).trans_eq (S.norm_map n m h x) | |
| Β· exact (norm_zero (E:=B)).le.trans (norm_nonneg x)) | |
| lemma stageSeq_apply (S : System) (Ο : β n, S.obj n βββ[β] B) | |
| (n m : β) (h : n β€ m) (x : S.obj n) : | |
| stageSeq S Ο n x m=Ο m (S.map n m h x) := dite_eq_left h | |
| def stageHom (S : System) (Ο : β n, S.obj n βββ[β] B) | |
| (Ο : Ultrafilter β) (hΟ : (Ο : Filter β)β€Filter.atTop) (n : β) : | |
| S.obj n βββ[β] NormUltrapower.Algebra B Ο where | |
| toFun x := NormUltrapower.quotientMap Ο (stageSeq S Ο n x) | |
| map_add' x y := by | |
| rw | |
| apply quotient_eq_of_eventuallyEq | |
| filter_upwards | |
| map_mul' x y := by | |
| rw | |
| apply quotient_eq_of_eventuallyEq | |
| filter_upwards | |
| map_zero' := by | |
| rw | |
| apply quotient_eq_of_eventuallyEq | |
| filter_upwards | |
| rfl | |
| map_one' := by | |
| rw | |
| apply quotient_eq_of_eventuallyEq | |
| filter_upwards | |
| rfl | |
| commutes' z := by | |
| rw | |
| apply quotient_eq_of_eventuallyEq | |
| filter_upwards | |
| exact (congrArg (Ο m) ((S.map n m hm).commutes z)).trans ((Ο m).commutes z) | |
| map_star' x := by | |
| rw | |
| apply quotient_eq_of_eventuallyEq | |
| filter_upwards | |
| lemma stageHom_map (S : System) (Ο : β n, S.obj n βββ[β] B) | |
| (Ο : Ultrafilter β) (hΟ : (Ο : Filter β)β€Filter.atTop) | |
| (i j : β) (hij : i β€ j) (x : S.obj i) : | |
| stageHom S Ο Ο hΟ j (S.map i j hij x)=stageHom S Ο Ο hΟ i x := by | |
| apply quotient_eq_of_eventuallyEq | |
| filter_upwards | |
| def toUltrapower (S : System) (Ο : β n, S.obj n βββ[β] B) | |
| (Ο : Ultrafilter β) (hΟ : (Ο : Filter β)β€Filter.atTop) : | |
| Algebra S βββ[β] NormUltrapower.Algebra B Ο := | |
| lift S (stageHom S Ο Ο hΟ) (stageHom_map S Ο Ο hΟ) | |
| lemma toUltrapower_of (S : System) (Ο : β n, S.obj n βββ[β] B) | |
| (Ο : Ultrafilter β) (hΟ : (Ο : Filter β)β€Filter.atTop) (n : β) (x : S.obj n) : | |
| toUltrapower S Ο Ο hΟ (of S n x)=stageHom S Ο Ο hΟ n x := lift_of _ _ _ _ _ | |
| theorem exists_toCentral (S : System) | |
| {A : Type*} | |
| (Ο : Ultrafilter β) (hΟ : (Ο : Filter β)β€cofinite) | |
| (Ο : β n, S.obj n βββ[β] NormUltrapower.CentralAlgebra A Ο) : | |
| Nonempty (Algebra S βββ[β] NormUltrapower.CentralAlgebra A Ο) := by | |
| have hfree : (Ο : Filter β) β€ atTop := by simpa only | |
| | succ n ih => | |
| rw | |
| ring | |
| lemma stage_power_successor (n : β) : stage n = 2^((3^n-1)+1) := by | |
| have hp : 1 β€ 3^n := Nat.one_le_pow n 3 (by decide) | |
| rw | |
| exact stage_power n | |
| end KirchbergRordam.BalancedDropMultiplicity | |
| namespace KirchbergRordam.BalancedDropLimit | |
| open TopologicalSpace | |
| theorem stage_to_central (A : Type*) | |
| [SeparableSpace A] (Ο : Ultrafilter β) (hΟ : (Ο : Filter β) β€ Filter.cofinite) | |
| (hF : IsEmpty (NormUltrapower.CentralAlgebra A Ο βββ[β] β)) (n : β) : | |
| Nonempty (Stage n βββ[β] NormUltrapower.CentralAlgebra A Ο) := by | |
| change Nonempty (PrimeDimensionDrop.Algebra | |
| (BalancedDropMultiplicity.stage n) (BalancedDropMultiplicity.stage n+1) βββ[β] _) | |
| rw | |
| exact central_prime_power_drop A Ο hΟ hF (3^n-1) | |
| theorem to_central (A : Type*) | |
| [SeparableSpace A] (Ο : Ultrafilter β) (hΟ : (Ο : Filter β) β€ Filter.cofinite) | |
| (hF : IsEmpty (NormUltrapower.CentralAlgebra A Ο βββ[β] β)) : | |
| Nonempty (Algebra βββ[β] NormUltrapower.CentralAlgebra A Ο) := by | |
| let Ο := fun n => (stage_to_central A Ο hΟ hF n).some | |
| exact CStarInductiveLimit.exists_toCentral system Ο hΟ Ο | |
| end KirchbergRordam.BalancedDropLimit | |
| end | |
| end OAI | |