| import Mathlib |
| import OAI.Analysis.TracialSplitting.PreparedBlocks |
| import OAI.Analysis.JiangSu.DimensionDrop.TraceExistence |
| import OAI.Analysis.JiangSu.DimensionDrop.Matching |
| import OAI.Analysis.JiangSu.MatrixAlgebras.CStarProjectionRounding |
|
|
| namespace OAI |
|
|
|
|
| noncomputable section |
| namespace CStarProjectionRounding |
| open scoped CStarAlgebra |
|
|
| variable {A |
|
|
| lemma ‖ ℝ ‖≤‖‖ |
| rw |
| have |
| rw |
| norm_num |
| nlinarith |
|
|
| lemma φ →⋆ₐℂ |
| φ (selfAdjointPart ℝ ℝ φ |
| simp |
| change φ⅟ ℝ • |
| rw φ |
| simp |
|
|
| lemma |
| (h ‖‖/64) : ‖b-b*b‖≤1/ |
| have ‖‖≤ |
| have ‖‖≤ |
| have |
| rw |
| linarith |
| have |
| noncomm_ring |
| calc |
| ‖b-b*b‖=‖(b-e)-(b*(b-e)+(b-e)*e)‖ := congrArg |
| _≤‖b-e‖+‖b*(b-e)+(b-e)*e‖ := norm_sub_le |
| _≤‖b-e‖+(‖b*(b-e)‖+‖(b-e)*e‖) := add_le_add_right |
| _≤‖b-e‖+(‖b‖*‖b-e‖+‖b-e‖*‖e‖) := |
| add_le_add_right |
| _≤4*‖b-e‖ := by |
| mul_le_mul_of_nonneg_left |
| _≤1/16 := by linarith |
|
|
| lemma trivial_projection_of_approximation (φ : A →⋆ₐ[ℂ] B) (hφ : Isometry φ) |
| (hA : ∀ q : A, IsStarProjection q → q=0 ∨ q=1) |
| {e : B} (he : IsStarProjection e) {a : A} (ha : ‖e-φ a‖<1/64) : e=0 ∨ e=1 := by |
| let ℝ |
| have ℝ |
| have ‖φ ‖/64 := by |
| have hid : φ b-e=(selfAdjointPart ℝ (φ a-e) : B) := by |
| rw [show φ b=(selfAdjointPart ℝ (φ a) : B) from map_selfAdjointPart φ a] |
| rw [map_sub] |
| change (selfAdjointPart ℝ (φ a) : B)-e= |
| (selfAdjointPart ℝ (φ a) : B)-(selfAdjointPart ℝ e : B) |
| rw [he.isSelfAdjoint.coe_selfAdjointPart_apply ℝ] |
| rw [hid] |
| exact (norm_selfAdjointPart_le _).trans_lt (by simpa only [norm_sub_rev] using ha) |
| have hnorm (x : A) : ‖φ x‖=‖x‖ := by |
| simpa only [map_zero,dist_zero_right] using hφ.dist_eq x 0 |
| have hbdef : ‖b-b*b‖≤1/ |
| rw ← |
| exact |
| obtain ⟨⟩ |
| have ‖φ ‖ |
| calc |
| ‖φ q-e‖≤‖φ q-φ b‖+‖φ b-e‖ := norm_sub_le_norm_sub_add_norm_sub |
| _=‖q-b‖+‖φ b-e‖ := by ← |
| _<1 := by |
| rcases | |
| · left |
| rw |
| exact |
| · right |
| rw |
| exact |
| end |
|
|
| namespace |
| open |
|
|
| variable ℕ → ∀ ∀ |
| variable |
|
|
| theorem ∀ → ∨ |
| (p ∨ |
| obtain ⟨⟩ ℝ/64 by norm_num) |
| exact trivial_projection_of_approximation (S.inclusion n) (S.inclusion_isometry n) (h n) hp ha |
|
|
| end SequentialCStar.System |
|
|
|
|
| namespace OriginalJiangSu |
| open JiangSuConstruction |
|
|
| theorem projection_trivial (e : Algebra) (he : IsStarProjection e) : e=0 ∨ e=1 := by |
| apply system.limit_projection_trivial _ e he |
| intro n q hq |
| exact primeDrop_idempotent_trivial (by have := (pair n).p_gt; omega) |
| (by have := (pair n).q_gt; omega) (pair n).coprime q hq.isIdempotentElem |
|
|
| open scoped CStarAlgebra ComplexOrder |
|
|
| local instance tracePNeZero (n : ℕ) : NeZero (pair n).p := |
| ⟨by have := (pair n).p_gt; omega⟩ |
| local instance traceQNeZero (n : ℕ) : NeZero (pair n).q := |
| ⟨by have := (pair n).q_gt; omega⟩ |
|
|
| lemma stage_trace_oscillation (n : ℕ) (f : Stage n) {ε : ℝ} (hε : 0<ε) : |
| ∃ k : ℕ,∀ s t : Interval, |
| ‖normalizedTracePath (system.map (Nat.le_add_right n k) f).val s- |
| normalizedTracePath (system.map (Nat.le_add_right n k) f).val t‖<ε := by |
| classical |
| obtain ⟨k,W,-,hW⟩ := stage_matching n {f} hε |
| refine ⟨k,?_⟩ |
| intro s t |
| let g := system.map (Nat.le_add_right n k) f |
| have hb := normalizedMatrixTrace_norm |
| (unitaryConjugation (W (s,t)) (g.val s)-g.val t) |
| rw [map_sub matrixTrace,matrixTrace_unitary,mul_sub] at hb |
| exact hb.trans_lt (hW f (Finset.mem_singleton_self f) s t) |
|
|
| lemma trace_stage_unique |
| (τ σ : Algebra →L[ℂ] ℂ) |
| (hτ : ∀ a b,τ (a*b)=τ (b*a)) (hσ : ∀ a b,σ (a*b)=σ (b*a)) |
| (hτ1 : τ 1=1) (hσ1 : σ 1=1) (hτn : ‖τ‖≤1) (hσn : ‖σ‖≤1) |
| (n : ℕ) (f : Stage n) : |
| τ (system.inclusion n f)=σ (system.inclusion n f) := by |
| apply sub_eq_zero.mp |
| apply norm_eq_zero.mp |
| apply le_antisymm _ (norm_nonneg _) |
| apply le_of_forall_pos_le_add |
| intro ε hε |
| obtain ⟨k,hk⟩ := stage_trace_oscillation n f (half_pos hε) |
| let g : Stage (n+k) := system.map (Nat.le_add_right n k) f |
| have hg (s : Interval) : |
| ‖normalizedTracePath g.val s-normalizedTracePath g.val leftEndpoint‖≤ε/ |
| exact |
| let →ₗℂ ℂ τ |
| let →ₗℂ ℂ σ |
| have ∀ |
| intro |
| change τ τ |
| rw τ |
| have ∀ |
| intro |
| change σ σ |
| rw σ |
| have τ ; rw [map_one,hτ1] |
| have hS1 : S 1=1 := by change σ (system.inclusion (n+k) 1)=1; rw [map_one,hσ1] |
| have hTb (a) : ‖T a‖≤‖a‖ := by |
| calc _ ≤ ‖τ‖*‖system.inclusion (n+k) a‖ := τ.le_opNorm _ |
| _ ≤ 1*‖system.inclusion (n+k) a‖ := mul_le_mul_of_nonneg_right hτn (norm_nonneg _) |
| _ = ‖a‖ := by rw [one_mul,system.inclusion_norm] |
| have hSb (a) : ‖S a‖≤‖a‖ := by |
| calc _ ≤ ‖σ‖*‖system.inclusion (n+k) a‖ := σ.le_opNorm _ |
| _ ≤ 1*‖system.inclusion (n+k) a‖ := mul_le_mul_of_nonneg_right hσn (norm_nonneg _) |
| _ = ‖a‖ := by rw [one_mul,system.inclusion_norm] |
| have ht := dimensionDrop_trace_oscillation T hT hT1 hTb g leftEndpoint (half_pos hε).le hg |
| have hs := dimensionDrop_trace_oscillation S hS hS1 hSb g leftEndpoint (half_pos hε).le hg |
| have hinc : system.inclusion (n+k) g=system.inclusion n f := |
| system.inclusion_compatible _ _ |
| have ht' : T g=τ (system.inclusion n f) := congrArg τ hinc |
| have hs' : S g=σ (system.inclusion n f) := congrArg σ hinc |
| rw [ht'] at ht |
| rw [hs'] at hs |
| have hh := norm_sub_le (τ (system.inclusion n f)-normalizedTracePath g.val leftEndpoint) |
| (σ (system.inclusion n f)-normalizedTracePath g.val leftEndpoint) |
| simp only [sub_sub_sub_cancel_right] at hh |
| linarith |
|
|
| theorem trace_unique |
| (τ σ : Algebra →L[ℂ] ℂ) |
| (hτ : ∀ a b,τ (a*b)=τ (b*a)) (hσ : ∀ a b,σ (a*b)=σ (b*a)) |
| (hτ1 : τ 1=1) (hσ1 : σ 1=1) (hτn : ‖τ‖≤1) (hσn : ‖σ‖≤1) : τ=σ := by |
| ext x |
| apply sub_eq_zero.mp |
| apply norm_eq_zero.mp |
| apply le_antisymm _ (norm_nonneg _) |
| apply le_of_forall_pos_le_add |
| intro ε hε |
| obtain ⟨n,f,hf⟩ := system.finite_stage_approximation x (half_pos hε) |
| have he := trace_stage_unique τ σ hτ hσ hτ1 hσ1 hτn hσn n f |
| have ht : ‖τ x-τ (system.inclusion n f)‖<ε/2 := by |
| rw [←map_sub] |
| exact (τ.le_opNorm _).trans_lt ((mul_le_mul_of_nonneg_right hτn (norm_nonneg _)).trans_lt (by simpa using hf)) |
| have hs : ‖σ x-σ (system.inclusion n f)‖<ε/2 := by |
| rw [←map_sub] |
| exact (σ.le_opNorm _).trans_lt ((mul_le_mul_of_nonneg_right hσn (norm_nonneg _)).trans_lt (by simpa using hf)) |
| have hh := norm_sub_le (τ x-τ (system.inclusion n f)) (σ x-σ (system.inclusion n f)) |
| rw [he,sub_sub_sub_cancel_right] at hh |
| rw [he] at ht |
| linarith |
|
|
| def stageTrace (n : ℕ) : Stage n →ₗ[ℂ] ℂ := |
| ((Fintype.card (Fin (pair n).p×Fin (pair n).q):ℂ)⁻¹ • matrixTrace).comp |
| (((evalHom _ _ leftEndpoint).comp (dimensionDrop _ _).subtype).toLinearMap) |
|
|
| lemma stageTrace_norm (n : ℕ) (a : Stage n) : ‖stageTrace n a‖≤‖a‖ := |
| (normalizedMatrixTrace_norm (a.val leftEndpoint)).trans (a.val.norm_coe_le_norm leftEndpoint) |
| lemma stageTrace_one (n : ℕ) : stageTrace n 1=1 := normalizedMatrixTrace_one |
| lemma stageTrace_tracial (n : ℕ) (a b : Stage n) : |
| stageTrace n (a*b)=stageTrace n (b*a) := by |
| change _*matrixTrace (a.val leftEndpoint*b.val leftEndpoint)=_*matrixTrace (b.val leftEndpoint*a.val leftEndpoint) |
| rw [matrixTrace_mul_comm] |
|
|
| def trace : Algebra →L[ℂ] ℂ := |
| SequentialCStar.limitTrace stageTrace stageTrace_norm system |
| lemma trace_one : trace 1=1 := |
| SequentialCStar.limitTrace_normalized _ _ _ stageTrace_one |
| lemma trace_tracial (a b : Algebra) : trace (a*b)=trace (b*a) := |
| SequentialCStar.limitTrace_tracial _ _ _ stageTrace_tracial a b |
| lemma trace_norm : ‖trace‖≤1 := SequentialCStar.limitTrace_norm _ _ _ |
|
|
| theorem existsUnique_trace : |
| ∃! τ : Algebra →L[ℂ] ℂ, |
| (∀ a b,τ (a*b)=τ (b*a)) ∧ τ 1=1 ∧ ‖τ‖≤1 := by |
| refine ⟨trace,⟨trace_tracial,trace_one,trace_norm⟩,?_⟩ |
| intro σ hσ |
| exact trace_unique σ trace hσ.1 trace_tracial hσ.2.1 trace_one hσ.2.2 trace_norm |
|
|
| end OriginalJiangSu |
|
|
| end |
|
|
| end OAI |
|
|
