| import OAI.Analysis.CharacterCriterion.NormUltrapower |
|
|
| 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 |
| namespace KirchbergRordam.Reindex |
|
|
|
|
| theorem diagonal_select {ι : Type*} [Countable ι] (ω : Filter ℕ) [NeBot ω] |
| (f : ι → ℕ → ℕ → ℝ) |
| (hf : ∀ i s, Tendsto (f i s) ω (𝓝 0)) : |
| ∃ k : ℕ → ℕ, ∀ i, Tendsto (fun s => f i s (k s)) atTop (𝓝 0) := by |
| classical |
| let := Encodable.ofCountable ι |
| have good (s : ℕ) : ∃ l, ∀ i, Encodable.encode i ≤ s → |f i s l| < 1 / ((s:ℝ)+1) := by |
| have hfin : {i : ι | Encodable.encode i ≤ s}.Finite := |
| (Set.finite_Iic s).preimage Encodable.encode_injective.injOn |
| have he : ∀ᶠ l in ω, ∀ i ∈ {i : ι | Encodable.encode i ≤ s}, |
| |f i s l| < 1 / ((s:ℝ)+1) := hfin.eventually_all.mpr fun i _ => by |
| have hp : (0:ℝ) < 1 / ((s:ℝ)+1) := by positivity |
| simpa only [Real.dist_eq, sub_zero] using |
| (tendsto_order.1 ((hf i s).abs)).2 _ (by simpa using hp) |
| exact he.exists |
| choose k hk using good |
| refine ⟨k, fun i => ?_⟩ |
| apply squeeze_zero_norm' (a := fun s : ℕ => 1 / ((s:ℝ)+1)) |
| · filter_upwards [eventually_ge_atTop (Encodable.encode i)] with s hs |
| simpa only [Real.norm_eq_abs] using (hk s i hs).le |
| · exact tendsto_one_div_add_atTop_nhds_zero_nat |
| end KirchbergRordam.Reindex |
|
|
| namespace KirchbergRordam.NormUltrapower |
| open Filter Topology TopologicalSpace |
| open scoped CStarAlgebra |
| variable {A : Type*} [CStarAlgebra A] |
| lemma quotient_eq_iff (ω : Ultrafilter ℕ) (x y : BoundedSeq A) : |
| quotientMap ω x = quotientMap ω y ↔ |
| Tendsto (fun n => ‖x n - y n‖) (ω : Filter ℕ) (𝓝 0) := by |
| change Ideal.Quotient.mk (nullIdeal ω) x = Ideal.Quotient.mk (nullIdeal ω) y ↔ _ |
| rw [Ideal.Quotient.eq, mem_nullIdeal] |
| rfl |
|
|
| def reindexed (k : ℕ → ℕ) (x : BoundedSeq A) : BoundedSeq A := |
| BoundedContinuousFunction.ofNormedAddCommGroupDiscrete (fun n => x (k n)) ‖x‖ |
| (fun n => x.norm_coe_le_norm (k n)) |
| @[simp] lemma reindexed_apply (k : ℕ → ℕ) (x : BoundedSeq A) (n : ℕ) : |
| reindexed k x n = x (k n) := rfl |
|
|
| inductive ReindexTest (S : Type*) |
| | add (x y : S) | mul (x y : S) | adjoint (x : S) |
| | zero | one | norm (x : S) | central (x : S) (j : ℕ) |
| | commute (x : S) (j : ℕ) | imag |
| deriving Countable |
|
|
|
|
| theorem countable_reindex {S : Type*} [Ring S] [StarRing S] [Countable S] |
| [SeparableSpace A] (ω : Ultrafilter ℕ) (hω : (ω : Filter ℕ) ≤ cofinite) |
| (φ : S →+* Algebra A ω) (hφ : ∀ x, φ (star x) = star (φ x)) |
| (hc : ∀ x, φ x ∈ centralSubalgebra ω) |
| (j : S) (hj : φ j = diagonal ω (algebraMap ℂ A Complex.I)) |
| (b : ℕ → BoundedSeq A) : |
| ∃ θ : S →+* CentralAlgebra A ω, |
| (∀ x, θ (star x) = star (θ x)) ∧ |
| (∀ x, ‖θ x‖ = ‖φ x‖) ∧ |
| (θ j : Algebra A ω) = diagonal ω (algebraMap ℂ A Complex.I) ∧ |
| ∀ x n, Commute (θ x : Algebra A ω) (quotientMap ω (b n)) := by |
| classical |
| have hex (x : S) : ∃ u : BoundedSeq A, quotientMap ω u = φ x := |
| Ideal.Quotient.mk_surjective _ |
| choose u hu using hex |
| let a : ℕ → A := TopologicalSpace.denseSeq A |
| have ha : DenseRange a := TopologicalSpace.denseRange_denseSeq A |
| let test : ReindexTest S → ℕ → ℕ → ℝ |
| | .add x y, _, l => ‖u (x+y) l - (u x l + u y l)‖ |
| | .mul x y, _, l => ‖u (x*y) l - u x l * u y l‖ |
| | .adjoint x, _, l => ‖u (star x) l - star (u x l)‖ |
| | .zero, _, l => ‖u 0 l - 0‖ |
| | .one, _, l => ‖u 1 l - 1‖ |
| | .norm x, _, l => ‖u x l‖ - ‖φ x‖ |
| | .central x n, _, l => ‖u x l * a n - a n * u x l‖ |
| | .commute x n, s, l => ‖u x l * b n s - b n s * u x l‖ |
| | .imag, _, l => ‖u j l - algebraMap ℂ A Complex.I‖ |
| have ht (i : ReindexTest S) (s : ℕ) : Tendsto (test i s) (ω : Filter ℕ) (𝓝 0) := by |
| have hn (x y : BoundedSeq A) (h : quotientMap ω x = quotientMap ω y) := |
| (quotient_eq_iff ω x y).mp h |
| have hcent x : ∀ c : A, Tendsto (fun l => ‖u x l * c - c * u x l‖) |
| (ω : Filter ℕ) (𝓝 0) := (mk_mem_central_iff ω (u x)).mp (by rw [hu]; exact hc x) |
| cases i with |
| | add x y => exact hn (u (x+y)) (u x + u y) (by simp only [hu, map_add]) |
| | mul x y => exact hn (u (x*y)) (u x * u y) (by simp only [hu, map_mul]) |
| | adjoint x => exact hn (u (star x)) (star (u x)) (by simp only [hu, map_star, hφ]) |
| | zero => exact hn (u 0) 0 (by simp only [hu, map_zero]) |
| | one => exact hn (u 1) 1 (by simp only [hu, map_one]) |
| | norm x => |
| have he : normLimit ω (u x) = ‖φ x‖ := by rw [← hu]; exact (norm_mk_eq ω (u x)).symm |
| simpa only [he, sub_self] using (tendsto_norm ω (u x)).sub_const ‖φ x‖ |
| | central x n => exact hcent x (a n) |
| | commute x n => exact hcent x (b n s) |
| | imag => exact hn (u j) (constantSeq (algebraMap ℂ A Complex.I)) (by rw [hu,hj]; rfl) |
| obtain ⟨k,hk⟩ := Reindex.diagonal_select (ω : Filter ℕ) test ht |
| have hfree : (ω : Filter ℕ) ≤ atTop := by simpa only [Nat.cofinite_eq_atTop] using hω |
| have hk' (i : ReindexTest S) : Tendsto (fun s => test i s (k s)) (ω : Filter ℕ) (𝓝 0) := |
| (hk i).mono_left hfree |
| let v : S → BoundedSeq A := fun x => reindexed k (u x) |
| let g : S → Algebra A ω := fun x => quotientMap ω (v x) |
| have heq (x y : BoundedSeq A) |
| (h : Tendsto (fun s => ‖x s - y s‖) (ω : Filter ℕ) (𝓝 0)) : |
| quotientMap ω x = quotientMap ω y := (quotient_eq_iff ω x y).mpr h |
| have hadd (x y : S) : g (x+y) = g x + g y := by |
| change quotientMap ω (v (x+y)) = _ |
| rw [← map_add] |
| exact heq _ _ (hk' (.add x y)) |
| have hmul (x y : S) : g (x*y) = g x * g y := by |
| change quotientMap ω (v (x*y)) = _ |
| rw [← map_mul] |
| exact heq _ _ (hk' (.mul x y)) |
| have hstar (x : S) : g (star x) = star (g x) := by |
| change quotientMap ω (v (star x)) = _ |
| rw [← map_star] |
| exact heq _ _ (hk' (.adjoint x)) |
| have hzero : g 0 = 0 := by |
| rw [← map_zero (quotientMap ω)] |
| exact heq _ _ (hk' .zero) |
| have hone : g 1 = 1 := by |
| rw [← map_one (quotientMap ω)] |
| exact heq _ _ (hk' .one) |
| have hgNorm (x : S) : ‖g x‖ = ‖φ x‖ := by |
| change ‖quotientMap ω (v x)‖ = _ |
| change ‖Ideal.Quotient.mk (nullIdeal ω) (v x)‖ = _ |
| rw [norm_mk_eq] |
| apply tendsto_nhds_unique (tendsto_norm ω (v x)) |
| simpa only [test, v, reindexed_apply, sub_add_cancel, zero_add] using (hk' (.norm x)).add_const ‖φ x‖ |
| have hgCentral (x : S) : g x ∈ centralSubalgebra ω := by |
| rw [mem_central_iff] |
| intro c |
| refine ha.induction_on c (p := fun c => diagonal ω c * g x = g x * diagonal ω c) |
| (isClosed_eq (by fun_prop) (by fun_prop)) ?_ |
| intro n |
| have he := heq (v x * constantSeq (a n)) (constantSeq (a n) * v x) (hk' (.central x n)) |
| change quotientMap ω (constantSeq (a n)) * quotientMap ω (v x) = |
| quotientMap ω (v x) * quotientMap ω (constantSeq (a n)) |
| simpa only [map_mul] using he.symm |
| let θ : S →+* CentralAlgebra A ω := |
| { toFun := fun x => ⟨g x, hgCentral x⟩ |
| map_zero' := Subtype.ext hzero |
| map_one' := Subtype.ext hone |
| map_add' := fun x y => Subtype.ext (hadd x y) |
| map_mul' := fun x y => Subtype.ext (hmul x y) } |
| refine ⟨θ, (fun x => Subtype.ext (hstar x)), hgNorm, ?_, ?_⟩ |
| · exact heq (v j) (constantSeq (algebraMap ℂ A Complex.I)) (hk' .imag) |
| · intro x n |
| have he := heq (v x * b n) (b n * v x) (hk' (.commute x n)) |
| exact (show g x * quotientMap ω (b n) = quotientMap ω (b n) * g x from |
| by simpa only [map_mul] using he) |
| end KirchbergRordam.NormUltrapower |
| namespace KirchbergRordam.RationalDense |
| open Set Topology TopologicalSpace |
| variable {A : Type*} [CStarAlgebra A] |
| local instance : Algebra ℚ A := Algebra.compHom A (algebraMap ℚ ℂ) |
|
|
|
|
| def stage (s : Set A) : ℕ → Set A |
| | 0 => s ∪ Set.range (algebraMap ℚ A) |
| | n+1 => stage s n ∪ (fun p : A×A=>p.1+p.2) '' (stage s n ×ˢ stage s n) ∪ |
| (fun p : A×A=>p.1*p.2) '' (stage s n ×ˢ stage s n) ∪ star '' stage s n |
| lemma stage_step (s : Set A) (n : ℕ) : stage s n ⊆ stage s (n+1) := |
| fun _ hx => Or.inl (Or.inl (Or.inl hx)) |
| lemma stage_mono (s : Set A) : Monotone (stage s) := monotone_nat_of_le_succ (stage_step s) |
| lemma stage_countable {s : Set A} (hs : s.Countable) (n : ℕ) : (stage s n).Countable := by |
| induction n with |
| | zero => exact hs.union (Set.countable_range _) |
| | succ n ih => exact ((ih.union ((ih.prod ih).image _)).union |
| ((ih.prod ih).image _)).union (ih.image _) |
| def termAlgebra (s : Set A) : StarSubalgebra ℚ A where |
| carrier := ⋃ n, stage s n |
| zero_mem' := mem_iUnion.mpr ⟨0,Or.inr ⟨0,map_zero _⟩⟩ |
| one_mem' := mem_iUnion.mpr ⟨0,Or.inr ⟨1,map_one _⟩⟩ |
| add_mem' := by |
| intro a b ha hb |
| obtain ⟨n,hn⟩ := mem_iUnion.mp ha |
| obtain ⟨m,hm⟩ := mem_iUnion.mp hb |
| exact mem_iUnion.mpr ⟨max n m + 1,Or.inl (Or.inl (Or.inr |
| ⟨(a,b),⟨stage_mono s (le_max_left _ _) hn,stage_mono s (le_max_right _ _) hm⟩,rfl⟩))⟩ |
| mul_mem' := by |
| intro a b ha hb |
| obtain ⟨n,hn⟩ := mem_iUnion.mp ha |
| obtain ⟨m,hm⟩ := mem_iUnion.mp hb |
| exact mem_iUnion.mpr ⟨max n m + 1,Or.inl (Or.inr |
| ⟨(a,b),⟨stage_mono s (le_max_left _ _) hn,stage_mono s (le_max_right _ _) hm⟩,rfl⟩)⟩ |
| algebraMap_mem' z := mem_iUnion.mpr ⟨0,Or.inr ⟨z,rfl⟩⟩ |
| star_mem' := by |
| intro a ha |
| obtain ⟨n,hn⟩ := mem_iUnion.mp ha |
| exact mem_iUnion.mpr ⟨n+1,Or.inr ⟨a,hn,rfl⟩⟩ |
|
|
| lemma term_countable {s : Set A} (hs : s.Countable) : (termAlgebra s : Set A).Countable := |
| Set.countable_iUnion (stage_countable hs) |
| lemma subset_term (s : Set A) : s ⊆ termAlgebra s := |
| fun _ ha => mem_iUnion.mpr ⟨0,Or.inl ha⟩ |
|
|
| theorem exists_countable_dense_star [SeparableSpace A] : |
| ∃ S : StarSubalgebra ℚ A, (S : Set A).Countable ∧ Dense (S : Set A) ∧ |
| algebraMap ℂ A Complex.I ∈ S := by |
| obtain ⟨s,hc,hd⟩ := exists_countable_dense A |
| refine ⟨termAlgebra (insert (algebraMap ℂ A Complex.I) s), |
| term_countable (hc.insert _), hd.mono ?_, subset_term _ (mem_insert _ _)⟩ |
| exact fun a ha => subset_term _ (mem_insert_of_mem _ ha) |
| end KirchbergRordam.RationalDense |
| open Topology |
| namespace KirchbergRordam.RationalDense |
| variable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B] |
| local instance (C : Type*) [CStarAlgebra C] : Algebra ℚ C := |
| Algebra.compHom C (algebraMap ℚ ℂ) |
|
|
|
|
| theorem extend_complex (S : StarSubalgebra ℚ A) (hS : Dense (S : Set A)) |
| (f : S →+* B) (hf : UniformContinuous f) |
| (hstar : ∀ x, f (star x) = star (f x)) |
| (hI : algebraMap ℂ A Complex.I ∈ S) |
| (hfI : f ⟨algebraMap ℂ A Complex.I,hI⟩ = algebraMap ℂ B Complex.I) : |
| ∃ g : A →⋆ₐ[ℂ] B, ∀ x : S, g x = f x := by |
| let i : S →+* A := S.subtype.toRingHom |
| have ui : IsUniformInducing i := isometry_subtype_coe.isUniformInducing |
| have di : DenseRange i := hS.denseRange_val |
| let g : A →+* B := IsDenseInducing.extendRingHom ui di hf |
| have hg : Continuous g := (uniformContinuous_uniformly_extend ui di hf).continuous |
| have he (x : S) : g x = f x := |
| IsDenseInducing.extend_eq (ui.isDenseInducing di) hf.continuous x |
| have hs (x : A) : g (star x) = star (g x) := by |
| refine di.induction_on x (p := fun x => g (star x) = star (g x)) |
| (isClosed_eq (hg.comp continuous_star) (continuous_star.comp hg)) ?_ |
| intro x |
| change g (↑(star x) : A) = star (g (x : A)) |
| rw [he,he,hstar] |
| have hgi : g (algebraMap ℂ A Complex.I) = algebraMap ℂ B Complex.I := |
| (he ⟨_,hI⟩).trans hfI |
| have hr (r : ℝ) : g (algebraMap ℂ A (r:ℂ)) = algebraMap ℂ B (r:ℂ) := by |
| refine (Rat.denseRange_cast (𝕜 := ℝ)).induction_on r |
| (p := fun r => g (algebraMap ℂ A (r:ℂ)) = algebraMap ℂ B (r:ℂ)) |
| (isClosed_eq (hg.comp ((continuous_algebraMap ℂ A).comp Complex.continuous_ofReal)) |
| ((continuous_algebraMap ℂ B).comp Complex.continuous_ofReal)) ?_ |
| intro q |
| change g (algebraMap ℂ A ((q : ℝ) : ℂ)) = algebraMap ℂ B ((q : ℝ) : ℂ) |
| rw [Complex.ofReal_ratCast] |
| exact g.map_rat_algebraMap q |
| have hcomplex (z : ℂ) : g (algebraMap ℂ A z) = algebraMap ℂ B z := by |
| conv_lhs => rw [← Complex.re_add_im z] |
| simp only [map_add,map_mul,hr,hgi] |
| rw [← map_mul, ← map_add, Complex.re_add_im] |
| exact ⟨{ g with map_star' := hs, commutes' := hcomplex }, he⟩ |
| end KirchbergRordam.RationalDense |
|
|
| namespace KirchbergRordam.NormUltrapower |
| open Topology TopologicalSpace |
| open scoped CStarAlgebra |
|
|
| theorem relative_commuting_copy {A D E : Type*} |
| [CStarAlgebra A] [CStarAlgebra D] [CStarAlgebra E] |
| [SeparableSpace A] [SeparableSpace D] [SeparableSpace E] |
| (ω : Ultrafilter ℕ) (hω : (ω : Filter ℕ) ≤ Filter.cofinite) |
| (φ : D →⋆ₐ[ℂ] CentralAlgebra A ω) |
| (ψ : E →⋆ₐ[ℂ] CentralAlgebra A ω) : |
| ∃ θ : D →⋆ₐ[ℂ] CentralAlgebra A ω, |
| ∀ d e, Commute (θ d) (ψ e) := by |
| classical |
| let : _root_.Algebra ℚ D := Algebra.compHom D (algebraMap ℚ ℂ) |
| obtain ⟨S,hcount,hden,hI⟩ := RationalDense.exists_countable_dense_star (A := D) |
| let : Countable S := hcount.to_subtype |
| let Φ : D →⋆ₐ[ℂ] Algebra A ω := (centralSubalgebra ω).subtype.comp φ |
| let f : S →+* Algebra A ω := Φ.toRingHom.comp S.subtype.toRingHom |
| have hfstar (x : S) : f (star x) = star (f x) := map_star Φ (x:D) |
| have hfcent (x : S) : f x ∈ centralSubalgebra ω := (φ (x:D)).property |
| have hfI : f ⟨_,hI⟩ = diagonal ω (algebraMap ℂ A Complex.I) := by |
| change Φ (algebraMap ℂ D Complex.I) = _ |
| exact (Φ.commutes Complex.I).trans ((diagonal ω).commutes Complex.I).symm |
| let e : ℕ → E := denseSeq E |
| have he : DenseRange e := denseRange_denseSeq E |
| have hbex (n : ℕ) : ∃ b : BoundedSeq A, quotientMap ω b = (ψ (e n) : Algebra A ω) := |
| Ideal.Quotient.mk_surjective _ |
| choose b hb using hbex |
| obtain ⟨g,hgs,hgn,hgi,hgc⟩ := countable_reindex ω hω f hfstar hfcent ⟨_,hI⟩ hfI b |
| have hbound (x : S) : ‖g x‖ ≤ ‖x‖ := by |
| rw [hgn] |
| exact NonUnitalStarAlgHom.norm_apply_le Φ (x:D) |
| have hLip : LipschitzWith 1 g := by |
| apply LipschitzWith.of_dist_le_mul |
| intro x y |
| simp only [dist_eq_norm, ← map_sub, NNReal.coe_one, one_mul] |
| exact hbound (x-y) |
| have hgi' : g ⟨_,hI⟩ = algebraMap ℂ (CentralAlgebra A ω) Complex.I := by |
| apply Subtype.ext |
| exact hgi.trans ((diagonal ω).commutes Complex.I) |
| obtain ⟨θ,hθ⟩ := RationalDense.extend_complex S hden g hLip.uniformContinuous hgs hI hgi' |
| refine ⟨θ, fun d e' => ?_⟩ |
| change θ d * ψ e' = ψ e' * θ d |
| have hθc : Continuous θ := map_continuous θ |
| have hψc : Continuous ψ := map_continuous ψ |
| refine hden.denseRange_val.induction_on d |
| (p := fun d => θ d * ψ e' = ψ e' * θ d) |
| (isClosed_eq (hθc.mul continuous_const) (continuous_const.mul hθc)) ?_ |
| intro x |
| rw [hθ] |
| refine he.induction_on e' (p := fun e' => g x * ψ e' = ψ e' * g x) |
| (isClosed_eq (continuous_const.mul hψc) (hψc.mul continuous_const)) ?_ |
| intro n |
| apply Subtype.ext |
| change (g x : Algebra A ω) * (ψ (e n) : Algebra A ω) = |
| (ψ (e n) : Algebra A ω) * (g x : Algebra A ω) |
| simpa only [hb] using (hgc x n).eq |
| end KirchbergRordam.NormUltrapower |
| end |
|
|
| end OAI |
|
|
