import OAI.Analysis.TracialSplitting.PreparedBlocks namespace OAI noncomputable section namespace Pureness open scoped ComplexOrder ENNReal variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] variable {ι : Type*} [Fintype ι] [DecidableEq ι] lemma positive_square_factor (a : A) (ha : 0 ≤ a) : ∃ x : A, star x * x = a := by refine ⟨CFC.sqrt a, ?_⟩ rw [(CFC.sqrt_nonneg a).star_eq, CFC.sqrt_mul_sqrt_self a ha] noncomputable def matrixTraceLinear (τ : TracialState A) : CStarMatrix ι ι A →ₗ[ℂ] ℂ where toFun M := ∑ i, τ.functional (M i i) map_add' M N := by simp [CStarMatrix.add_apply, map_add, Finset.sum_add_distrib] map_smul' z M := by simp [CStarMatrix.smul_apply, Finset.mul_sum] lemma matrix_entry_nonneg (M : CStarMatrix ι ι A) (hM : 0 ≤ M) (i : ι) : 0 ≤ M i i := by obtain ⟨x, hs⟩ := positive_square_factor M hM rw [← hs, CStarMatrix.mul_apply] exact Finset.sum_nonneg fun j _ => by rw [CStarMatrix.star_apply] exact star_mul_self_nonneg _ noncomputable def matrixTrace (τ : TracialState A) : CStarMatrix ι ι A →ₚ[ℂ] ℂ := { matrixTraceLinear τ with monotone' := by intro M N hMN apply sub_nonneg.mp change 0 ≤ matrixTraceLinear τ N - matrixTraceLinear τ M rw [← map_sub] exact Finset.sum_nonneg fun i _ => τ.functional.map_nonneg (matrix_entry_nonneg (N - M) (sub_nonneg.mpr hMN) i) } @[simp] lemma matrixTrace_apply (τ : TracialState A) (M : CStarMatrix ι ι A) : matrixTrace τ M = ∑ i, τ.functional (M i i) := rfl lemma matrixTrace_tracial (τ : TracialState A) (M N : CStarMatrix ι ι A) : matrixTrace τ (M * N) = matrixTrace τ (N * M) := by simp only [matrixTrace_apply, CStarMatrix.mul_apply, map_sum] rw [Finset.sum_comm] congr 1 funext i apply Finset.sum_congr rfl intro j _ exact τ.tracial _ _ end Pureness namespace Pureness open Filter Topology open scoped NNReal ENNReal ComplexOrder variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] variable {B : Type*} [CStarAlgebra B] [PartialOrder B] [StarOrderedRing B] lemma starAlgHom_positive (φ : A →⋆ₐ[ℂ] B) (a : A) (ha : 0 ≤ a) : 0 ≤ φ a := by have hs : star (CFC.sqrt a) * CFC.sqrt a = a := by rw [(CFC.sqrt_nonneg a).star_eq, CFC.sqrt_mul_sqrt_self a ha] rw [← hs, map_mul, map_star] exact star_mul_self_nonneg _ end Pureness namespace Pureness open scoped ComplexOrder ENNReal NNReal open Filter Topology variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] variable {ι : Type*} [Fintype ι] [DecidableEq ι] noncomputable def diagonalMatrixHom : (ι → A) →⋆ₐ[ℂ] CStarMatrix ι ι A := CStarMatrix.ofMatrixStarAlgEquiv.toStarAlgHom.comp { Matrix.diagonalAlgHom ℂ with map_star' := by intro a exact (Matrix.diagonal_conjTranspose a).symm } omit [PartialOrder A] [StarOrderedRing A] in @[simp] lemma diagonalMatrixHom_apply (a : ι → A) (i j : ι) : diagonalMatrixHom a i j = if i = j then a i else 0 := rfl end Pureness section open scoped ENNReal NNReal namespace TraceCone variable (A : Type*) [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] abbrev Positive := {a : A // 0 ≤ a} end TraceCone end section open scoped ENNReal NNReal namespace TraceCone variable (A : Type*) [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] namespace Positive variable {A} def zero : Positive A := ⟨0, le_rfl⟩ def add (a b : Positive A) : Positive A := ⟨a.1 + b.1, add_nonneg a.2 b.2⟩ def smul (r : ℝ≥0) (a : Positive A) : Positive A := ⟨(r : ℝ) • a.1, smul_nonneg r.2 a.2⟩ def starMul (x : A) : Positive A := ⟨star x * x, star_mul_self_nonneg x⟩ def mulStar (x : A) : Positive A := ⟨x * star x, mul_star_self_nonneg x⟩ def power (r : ℝ≥0) (a : Positive A) : Positive A := ⟨CFC.nnrpow a.1 r, CFC.nnrpow_nonneg⟩ def rootExponent (n : ℕ) : ℝ≥0 := 1 / ((n : ℝ≥0) + 1) end Positive end TraceCone end section open scoped ENNReal NNReal namespace TraceCone variable (A : Type*) [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] structure ExtendedTrace where toFun : Positive A → ℝ≥0∞ map_zero : toFun (Positive.zero) = 0 map_add (a b : Positive A) : toFun (Positive.add a b) = toFun a + toFun b map_smul (r : ℝ≥0) (a : Positive A) : toFun (Positive.smul r a) = (r : ℝ≥0∞) * toFun a tracial (x : A) : toFun (Positive.starMul x) = toFun (Positive.mulStar x) lowerSemicontinuous : LowerSemicontinuous toFun end TraceCone end section open scoped ENNReal NNReal namespace TraceCone variable (A : Type*) [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] namespace ExtendedTrace variable {A} instance : CoeFun (ExtendedTrace A) (fun _ => Positive A → ℝ≥0∞) := ⟨toFun⟩ def rank (τ : ExtendedTrace A) (a : Positive A) : ℝ≥0∞ := Filter.liminf (fun n : ℕ => τ (Positive.power (Positive.rootExponent n) a)) Filter.atTop @[ext] theorem ext {τ σ : ExtendedTrace A} (h : ∀ a, τ a = σ a) : τ = σ := by cases τ cases σ congr exact funext h instance : Zero (ExtendedTrace A) := ⟨{ toFun := fun _ => 0 map_zero := rfl map_add := fun _ _ => (zero_add 0).symm map_smul := fun _ _ => (mul_zero _).symm tracial := fun _ => rfl lowerSemicontinuous := lowerSemicontinuous_const }⟩ instance : Add (ExtendedTrace A) := ⟨fun τ σ => { toFun := fun a => τ a + σ a map_zero := by rw [τ.map_zero, σ.map_zero, add_zero] map_add := by intro a b rw [τ.map_add, σ.map_add] ac_rfl map_smul := by intro r a rw [τ.map_smul, σ.map_smul, mul_add] tracial := by intro x rw [τ.tracial, σ.tracial] lowerSemicontinuous := τ.lowerSemicontinuous.add σ.lowerSemicontinuous }⟩ @[simp] theorem add_apply (τ σ : ExtendedTrace A) (a : Positive A) : (τ + σ) a = τ a + σ a := rfl instance : AddCommMonoid (ExtendedTrace A) where add_assoc a b c := ext fun x => add_assoc (a x) (b x) (c x) zero_add a := ext fun x => zero_add (a x) add_zero a := ext fun x => add_zero (a x) add_comm a b := ext fun x => add_comm (a x) (b x) nsmul := nsmulRec theorem monotone (τ : ExtendedTrace A) : Monotone (fun a : Positive A => τ a) := by intro a b hab change τ a ≤ τ b let c : Positive A := ⟨b.1 - a.1, sub_nonneg.mpr hab⟩ have heq : Positive.add a c = b := Subtype.ext (add_sub_cancel _ _) have h := τ.map_add a c rw [heq] at h rw [h] exact le_self_add end ExtendedTrace end TraceCone end section open scoped Topology NNReal open Filter namespace TraceCone variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def CuntzBelow (a b : Positive A) : Prop := ∀ ε : ℝ, 0 < ε → ∃ v : A, ‖star v * b.1 * v - a.1‖ < ε end TraceCone end namespace Pureness open scoped ComplexOrder variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] variable {k l m : ℕ} noncomputable def corner (_ : k ≤ l) (a : CStarMatrix (Fin k) (Fin k) A) : CStarMatrix (Fin l) (Fin l) A := fun i j => if hi : i.val < k then if hj : j.val < k then a ⟨i.val, hi⟩ ⟨j.val, hj⟩ else 0 else 0 omit [PartialOrder A] [StarOrderedRing A] in @[simp] lemma corner_apply_cast (h : k ≤ l) (a : CStarMatrix (Fin k) (Fin k) A) (i j : Fin k) : corner h a (Fin.castLE h i) (Fin.castLE h j) = a i j := by simp [corner, i.isLt, j.isLt] omit [PartialOrder A] [StarOrderedRing A] in lemma corner_row_zero (h : k ≤ l) (a : CStarMatrix (Fin k) (Fin k) A) (i j : Fin l) (hi : ¬ i.val < k) : corner h a i j = 0 := by simp [corner, hi] omit [PartialOrder A] [StarOrderedRing A] in lemma corner_col_zero (h : k ≤ l) (a : CStarMatrix (Fin k) (Fin k) A) (i j : Fin l) (hj : ¬ j.val < k) : corner h a i j = 0 := by simp [corner, hj] lemma sum_corner_support {G : Type*} [AddCommMonoid G] (h : k ≤ l) (f : Fin l → G) (hf : ∀ i, ¬ i.val < k → f i = 0) : ∑ i, f i = ∑ i : Fin k, f (Fin.castLE h i) := by symm apply Fintype.sum_of_injective (Fin.castLE h) (fun i j hij => Fin.ext (congrArg (fun t : Fin l => t.val) hij)) · intro i hi apply hf i intro hik exact hi ⟨⟨i.val, hik⟩, Fin.ext rfl⟩ · intro i; rfl omit [PartialOrder A] [StarOrderedRing A] in lemma corner_mul (h : k ≤ l) (a b : CStarMatrix (Fin k) (Fin k) A) : corner h (a * b) = corner h a * corner h b := by ext i j by_cases hi : i.val < k · by_cases hj : j.val < k · rw [CStarMatrix.mul_apply, sum_corner_support h _ (fun t ht => by rw [corner_col_zero h a i t ht, zero_mul])] simp [corner, hi, hj, CStarMatrix.mul_apply] · simp [corner_col_zero h _ _ _ hj, CStarMatrix.mul_apply] · simp [corner_row_zero h _ _ _ hi, CStarMatrix.mul_apply] noncomputable def cornerHom (h : k ≤ l) : CStarMatrix (Fin k) (Fin k) A →⋆ₙₐ[ℂ] CStarMatrix (Fin l) (Fin l) A where toFun := corner h map_zero' := by ext i j; simp [corner] map_add' a b := by ext i j by_cases hi : i.val < k <;> by_cases hj : j.val < k <;> simp [corner, hi, hj] map_mul' := corner_mul h map_smul' z a := by ext i j by_cases hi : i.val < k <;> by_cases hj : j.val < k <;> simp [corner, hi, hj] map_star' a := by ext i j simp only [CStarMatrix.star_apply, corner] by_cases hi : i.val < k <;> by_cases hj : j.val < k <;> simp [hi, hj] omit [PartialOrder A] [StarOrderedRing A] in lemma corner_injective (h : k ≤ l) : Function.Injective (cornerHom (A := A) h) := by intro a b hab ext i j exact (corner_apply_cast h a i j).symm.trans ((congrArg (fun M : CStarMatrix (Fin l) (Fin l) A => M (Fin.castLE h i) (Fin.castLE h j)) hab).trans (corner_apply_cast h b i j)) @[simp] lemma corner_norm (h : k ≤ l) (a : CStarMatrix (Fin k) (Fin k) A) : ‖corner h a‖ = ‖a‖ := NonUnitalStarAlgHom.norm_map (cornerHom h) (corner_injective h) a omit [PartialOrder A] [StarOrderedRing A] in @[simp] lemma corner_refl (a : CStarMatrix (Fin k) (Fin k) A) : corner le_rfl a = a := by ext i j simp [corner, i.isLt, j.isLt] omit [PartialOrder A] [StarOrderedRing A] in lemma corner_comp (h : k ≤ l) (g : l ≤ m) (a : CStarMatrix (Fin k) (Fin k) A) : corner g (corner h a) = corner (h.trans g) a := by ext i j by_cases hi : i.val < k <;> by_cases hj : j.val < k · simp [corner, hi, hj, hi.trans_le h, hj.trans_le h] · simp [corner, hi, hj, hi.trans_le h] · simp [corner, hi] · simp [corner, hi] lemma matrixTrace_corner (τ : TracialState A) (h : k ≤ l) (a : CStarMatrix (Fin k) (Fin k) A) : matrixTrace τ (corner h a) = matrixTrace τ a := by rw [matrixTrace_apply, sum_corner_support h _ (fun i hi => by rw [corner_row_zero h a i i hi, map_zero])] simp only [corner_apply_cast, matrixTrace_apply] end Pureness namespace Pureness open Filter Topology open scoped ComplexOrder variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] variable {k l : ℕ} def compress (h : k ≤ l) (a : CStarMatrix (Fin l) (Fin l) A) : CStarMatrix (Fin k) (Fin k) A := fun i j => a (Fin.castLE h i) (Fin.castLE h j) end Pureness namespace Pureness open scoped ComplexOrder ENNReal variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] variable {k l : ℕ} noncomputable def cornerProjection (_ : k ≤ l) : CStarMatrix (Fin l) (Fin l) A := diagonalMatrixHom fun i => if i.val < k then 1 else 0 omit [PartialOrder A] [StarOrderedRing A] in lemma cornerProjection_eq (h : k ≤ l) : cornerProjection (A := A) h = corner h (1 : CStarMatrix (Fin k) (Fin k) A) := by ext i j by_cases hij : i = j · subst j by_cases hi : i.val < k <;> simp [cornerProjection, diagonalMatrixHom_apply, corner, hi] · have hv : i.val ≠ j.val := fun h => hij (Fin.ext h) simp [cornerProjection, diagonalMatrixHom_apply, corner, hij, Fin.ext_iff, hv] omit [PartialOrder A] [StarOrderedRing A] in lemma cornerProjection_mul (h : k ≤ l) (a : CStarMatrix (Fin l) (Fin l) A) (i j : Fin l) : (cornerProjection (A := A) h * a) i j = if i.val < k then a i j else 0 := by simp [CStarMatrix.mul_apply, cornerProjection, diagonalMatrixHom_apply, ite_mul] omit [PartialOrder A] [StarOrderedRing A] in lemma mul_cornerProjection (h : k ≤ l) (a : CStarMatrix (Fin l) (Fin l) A) (i j : Fin l) : (a * cornerProjection (A := A) h) i j = if j.val < k then a i j else 0 := by simp [CStarMatrix.mul_apply, cornerProjection, diagonalMatrixHom_apply, mul_ite] omit [PartialOrder A] [StarOrderedRing A] in lemma corner_compress (h : k ≤ l) (a : CStarMatrix (Fin l) (Fin l) A) : corner h (compress h a) = cornerProjection h * a * cornerProjection h := by ext i j rw [mul_cornerProjection, cornerProjection_mul] by_cases hi : i.val < k <;> by_cases hj : j.val < k <;> simp [corner, compress, hi, hj] end Pureness namespace Pureness open scoped ComplexOrder variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] variable {B : Type*} [CStarAlgebra B] [PartialOrder B] [StarOrderedRing B] variable {ι : Type*} [Fintype ι] [DecidableEq ι] noncomputable def TracialState.comap (ρ : TracialState B) (φ : A →⋆ₐ[ℂ] B) : TracialState A where functional := { ρ.functional.toLinearMap.comp φ.toLinearMap with monotone' := by intro a b hab change ρ.functional (φ a) ≤ ρ.functional (φ b) apply ρ.functional.monotone apply sub_nonneg.mp rw [← map_sub] exact starAlgHom_positive φ (b - a) (sub_nonneg.mpr hab) } normalized := by change ρ.functional (φ 1) = 1; rw [map_one, ρ.normalized] tracial a b := by change ρ.functional (φ (a * b)) = ρ.functional (φ (b * a)) rw [map_mul φ, map_mul φ, ρ.tracial] end Pureness namespace Pureness variable (A : Type*) [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] abbrev MatrixStage (k : ℕ) := CStarMatrix (Fin k) (Fin k) A noncomputable def matrixConnecting (k l : ℕ) (h : k ≤ l) : MatrixStage A k →⋆ₙₐ[ℂ] MatrixStage A l := cornerHom h instance matrixDirectedSystem : DirectedSystem (MatrixStage A) (fun _ _ h => matrixConnecting A _ _ h) where map_self := by intro i x; exact corner_refl x map_map := by intro k j i h g a; exact corner_comp h g a abbrev FiniteMatrixLimit := DirectLimit (MatrixStage A) (matrixConnecting A) noncomputable def finiteMatrixInclude (k : ℕ) : MatrixStage A k →⋆ₙₐ[ℂ] FiniteMatrixLimit A where toFun a := Quotient.mk _ ⟨k, a⟩ map_zero' := (DirectLimit.zero_def k).symm map_add' a b := (DirectLimit.add_def k a b).symm map_mul' a b := (DirectLimit.mul_def k a b).symm map_smul' z a := (DirectLimit.smul_def k a z).symm map_star' a := (DirectLimit.star_def k a).symm omit [PartialOrder A] [StarOrderedRing A] in lemma finiteMatrixInclude_corner {k l : ℕ} (h : k ≤ l) (a : MatrixStage A k) : finiteMatrixInclude A l (corner h a) = finiteMatrixInclude A k a := (DirectLimit.eq_of_le ⟨k, a⟩ l h).symm noncomputable def finiteMatrixNorm : FiniteMatrixLimit A → ℝ := DirectLimit.lift (matrixConnecting A) (fun _ a => ‖a‖) (fun _ _ h a => (corner_norm h a).symm) @[simp] lemma finiteMatrixNorm_include (k : ℕ) (a : MatrixStage A k) : finiteMatrixNorm A (finiteMatrixInclude A k a) = ‖a‖ := rfl noncomputable def finiteMatrixGroupNorm : AddGroupNorm (FiniteMatrixLimit A) where toFun := finiteMatrixNorm A map_zero' := by rw [← map_zero (finiteMatrixInclude A 0), finiteMatrixNorm_include, norm_zero] add_le' := by apply DirectLimit.induction₂ intro k a b change finiteMatrixNorm A (finiteMatrixInclude A k a + finiteMatrixInclude A k b) ≤ _ rw [← map_add, finiteMatrixNorm_include] exact norm_add_le a b neg' := by apply DirectLimit.induction intro k a change finiteMatrixNorm A (-finiteMatrixInclude A k a) = _ rw [← map_neg, finiteMatrixNorm_include] exact norm_neg a eq_zero_of_map_eq_zero' := by apply DirectLimit.induction intro k a ha have hz : a = 0 := norm_eq_zero.mp ha change finiteMatrixInclude A k a = 0 rw [hz, map_zero] noncomputable instance finiteMatrixNormedAddCommGroup : NormedAddCommGroup (FiniteMatrixLimit A) := (finiteMatrixGroupNorm A).toNormedAddCommGroup noncomputable instance finiteMatrixTopology : TopologicalSpace (FiniteMatrixLimit A) := (finiteMatrixNormedAddCommGroup A).toMetricSpace.toUniformSpace.toTopologicalSpace @[simp] lemma finiteMatrixInclude_norm (k : ℕ) (a : MatrixStage A k) : ‖finiteMatrixInclude A k a‖ = ‖a‖ := rfl noncomputable instance finiteMatrixNonUnitalNormedRing : NonUnitalNormedRing (FiniteMatrixLimit A) where dist_eq x y := by rw [dist_eq_norm, ← norm_neg]; simp [sub_eq_add_neg, add_comm] norm_mul_le := by apply DirectLimit.induction₂ intro k a b change ‖finiteMatrixInclude A k a * finiteMatrixInclude A k b‖ ≤ _ rw [← map_mul, finiteMatrixInclude_norm] exact norm_mul_le a b noncomputable instance finiteMatrixModule : Module ℂ (FiniteMatrixLimit A) where one_smul := by apply DirectLimit.induction intro k a simp only [one_smul] mul_smul r s := by apply DirectLimit.induction intro k a simp only [DirectLimit.smul_def, mul_smul] smul_zero r := by rw [DirectLimit.zero_def 0, DirectLimit.smul_def, smul_zero] smul_add r := by apply DirectLimit.induction₂ intro k a b simp only [DirectLimit.smul_def, DirectLimit.add_def, smul_add] add_smul r s := by apply DirectLimit.induction intro k a simp only [DirectLimit.smul_def, DirectLimit.add_def, add_smul] zero_smul := by apply DirectLimit.induction intro k a simp only [DirectLimit.smul_def, zero_smul, DirectLimit.zero_def k] noncomputable instance finiteMatrixNormedSpace : NormedSpace ℂ (FiniteMatrixLimit A) where __ : Module ℂ (FiniteMatrixLimit A) := inferInstance norm_smul_le z := by apply DirectLimit.induction intro k a change ‖z • finiteMatrixInclude A k a‖ ≤ ‖z‖ * ‖finiteMatrixInclude A k a‖ rw [← map_smul, finiteMatrixInclude_norm, finiteMatrixInclude_norm] exact norm_smul_le z a noncomputable instance finiteMatrixStarRing : StarRing (FiniteMatrixLimit A) where __ : StarAddMonoid (FiniteMatrixLimit A) := inferInstance __ : StarMul (FiniteMatrixLimit A) := inferInstance instance finiteMatrixCStarRing : CStarRing (FiniteMatrixLimit A) where norm_mul_self_le := by apply DirectLimit.induction intro k a change ‖finiteMatrixInclude A k a‖ * ‖finiteMatrixInclude A k a‖ ≤ ‖star (finiteMatrixInclude A k a) * finiteMatrixInclude A k a‖ rw [← map_star, ← map_mul, finiteMatrixInclude_norm, finiteMatrixInclude_norm] exact CStarRing.norm_mul_self_le a end Pureness namespace Pureness open UniformSpace Function Topology open UniformSpace.Completion variable (E : Type*) [NonUnitalNormedRing E] [StarRing E] [CStarRing E] [NormedSpace ℂ E] [IsScalarTower ℂ E E] [SMulCommClass ℂ E E] [StarModule ℂ E] instance nonUnitalCompletionMul : Mul (Completion E) := ⟨curry <| (isDenseInducing_coe.prodMap isDenseInducing_coe).extend ((↑) ∘ uncurry (· * · : E → E → E))⟩ instance nonUnitalCompletionContinuousMul : ContinuousMul (Completion E) where continuous_mul := by let multiplication := (AddMonoidHom.mul : E →+ E →+ E).compr₂ toCompl have continuous_multiplication : Continuous fun pair : E × E => multiplication pair.1 pair.2 := (continuous_coe _).comp continuous_mul have dense_embedding : IsDenseInducing (toCompl : E → Completion E) := isDenseInducing_coe exact (dense_embedding.extend_Z_bilin dense_embedding continuous_multiplication :) omit [StarRing E] [CStarRing E] [NormedSpace ℂ E] [IsScalarTower ℂ E E] [SMulCommClass ℂ E E] [StarModule ℂ E] in lemma completion_coe_mul (a b : E) : ((a * b : E) : Completion E) = (a : Completion E) * b := ((isDenseInducing_coe.prodMap isDenseInducing_coe).extend_eq ((continuous_coe _).comp continuous_mul) (a, b)).symm instance nonUnitalCompletionNonUnitalRing : NonUnitalRing (Completion E) where __ : AddCommGroup (Completion E) := inferInstance zero_mul element := Completion.induction_on element (isClosed_eq (by fun_prop) continuous_const) fun element => by rw [← coe_zero, ← completion_coe_mul, zero_mul] mul_zero element := Completion.induction_on element (isClosed_eq (by fun_prop) continuous_const) fun element => by rw [← coe_zero, ← completion_coe_mul, mul_zero] mul_assoc first second third := Completion.induction_on₃ first second third (isClosed_eq (by fun_prop) (by fun_prop)) fun first second third => by simp only [← completion_coe_mul, mul_assoc] left_distrib first second third := Completion.induction_on₃ first second third (isClosed_eq (by fun_prop) (by fun_prop)) fun first second third => by simp only [← coe_add, ← completion_coe_mul, mul_add] right_distrib first second third := Completion.induction_on₃ first second third (isClosed_eq (by fun_prop) (by fun_prop)) fun first second third => by simp only [← coe_add, ← completion_coe_mul, add_mul] instance nonUnitalCompletionNonUnitalNormedRing : NonUnitalNormedRing (Completion E) where __ : NormedAddCommGroup (Completion E) := inferInstance __ : NonUnitalRing (Completion E) := inferInstance norm_mul_le first second := Completion.induction_on₂ first second (isClosed_le (by fun_prop) (by fun_prop)) fun first second => by simpa only [← completion_coe_mul, norm_coe] using norm_mul_le first second instance nonUnitalCompletionStar : Star (Completion E) := ⟨Completion.map (star : E → E)⟩ instance nonUnitalCompletionContinuousStar : ContinuousStar (Completion E) := ⟨Completion.continuous_map⟩ omit [NormedSpace ℂ E] [IsScalarTower ℂ E E] [SMulCommClass ℂ E E] [StarModule ℂ E] in lemma completion_coe_star (a : E) : ((star a : E) : Completion E) = star (a : Completion E) := (Completion.map_coe star_isometry.uniformContinuous a).symm instance nonUnitalCompletionStarRing : StarRing (Completion E) where star_involutive element := Completion.induction_on element (isClosed_eq (by fun_prop) continuous_id) fun element => by simp only [← completion_coe_star, star_star] star_mul first second := Completion.induction_on₂ first second (isClosed_eq (by fun_prop) (by fun_prop)) fun first second => by simp only [← completion_coe_star, ← completion_coe_mul, star_mul] star_add first second := Completion.induction_on₂ first second (isClosed_eq (by fun_prop) (by fun_prop)) fun first second => by simp only [← completion_coe_star, ← coe_add, star_add] instance nonUnitalCompletionCStarRing : CStarRing (Completion E) where norm_mul_self_le element := Completion.induction_on element (isClosed_le (by fun_prop) (by fun_prop)) fun element => by simpa only [← completion_coe_star, ← completion_coe_mul, norm_coe] using CStarRing.norm_mul_self_le element instance nonUnitalCompletionStarModule : StarModule ℂ (Completion E) where star_smul scalar element := Completion.induction_on element (isClosed_eq (continuous_star.comp (continuous_const_smul scalar)) ((continuous_const_smul (star scalar)).comp continuous_star)) fun element => by simp only [← coe_smul, ← completion_coe_star, star_smul] instance nonUnitalCompletionScalarTower : IsScalarTower ℂ (Completion E) (Completion E) where smul_assoc scalar first second := Completion.induction_on₂ first second (isClosed_eq ((continuous_fst.const_smul scalar).mul continuous_snd) ((continuous_fst.mul continuous_snd).const_smul scalar)) fun first second => by change (scalar • (first : Completion E)) * (second : Completion E) = scalar • ((first : Completion E) * second) simp only [← coe_smul, ← completion_coe_mul, smul_mul_assoc] instance nonUnitalCompletionSMulComm : SMulCommClass ℂ (Completion E) (Completion E) where smul_comm scalar first second := Completion.induction_on₂ first second (isClosed_eq ((continuous_fst.mul continuous_snd).const_smul scalar) (continuous_fst.mul (continuous_snd.const_smul scalar))) fun first second => by change scalar • ((first : Completion E) * second) = (first : Completion E) * (scalar • (second : Completion E)) simp only [← coe_smul, ← completion_coe_mul, mul_smul_comm] instance nonUnitalCompletionCStarAlgebra : NonUnitalCStarAlgebra (Completion E) where end Pureness namespace Pureness open UniformSpace Function Topology open UniformSpace.Completion variable (A : Type*) [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] abbrev CornerCompletion := Completion (FiniteMatrixLimit A) instance cornerCompletionCStarAlgebra : NonUnitalCStarAlgebra (CornerCompletion A) := inferInstance def completedMatrixInclude (k : ℕ) : MatrixStage A k →⋆ₙₐ[ℂ] CornerCompletion A where toFun a := (finiteMatrixInclude A k a : CornerCompletion A) map_zero' := by simp only [map_zero, coe_zero] map_add' a b := by simp only [map_add, coe_add] map_mul' a b := by simp only [map_mul, completion_coe_mul] map_smul' z a := by simp only [map_smul, coe_smul]; rfl map_star' a := by simp only [map_star, completion_coe_star] lemma completedMatrixInclude_norm (k : ℕ) (a : MatrixStage A k) : ‖completedMatrixInclude A k a‖ = ‖a‖ := by change ‖(finiteMatrixInclude A k a : CornerCompletion A)‖ = _ rw [norm_coe, finiteMatrixInclude_norm] lemma completedMatrixInclude_isometry (k : ℕ) : Isometry (completedMatrixInclude A k) := AddMonoidHomClass.isometry_of_norm _ (completedMatrixInclude_norm A k) lemma completedMatrixInclude_corner {k l : ℕ} (h : k ≤ l) (a : MatrixStage A k) : completedMatrixInclude A l (corner h a) = completedMatrixInclude A k a := by change (finiteMatrixInclude A l (corner h a) : CornerCompletion A) = _ rw [finiteMatrixInclude_corner] rfl theorem completedMatrixInclude_dense : Dense (⋃ k : ℕ, Set.range (completedMatrixInclude A k)) := by have heq : (⋃ k : ℕ, Set.range (completedMatrixInclude A k)) = Set.range ((↑) : FiniteMatrixLimit A → CornerCompletion A) := by ext x simp only [Set.mem_iUnion, Set.mem_range] constructor · rintro ⟨k, a, rfl⟩; exact ⟨finiteMatrixInclude A k a, rfl⟩ · rintro ⟨y, rfl⟩ obtain ⟨k, a, rfl⟩ := DirectLimit.exists_eq_mk (matrixConnecting A) y exact ⟨k, a, rfl⟩ rw [heq] exact denseRange_coe end Pureness namespace Pureness open Filter Topology open scoped ComplexOrder variable (A : Type*) [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] instance cornerCompletionOrder : PartialOrder (CornerCompletion A) := CStarAlgebra.spectralOrder _ instance cornerCompletionStarOrdered : StarOrderedRing (CornerCompletion A) := CStarAlgebra.spectralOrderedRing _ lemma completedMatrixInclude_nonneg (k : ℕ) (a : MatrixStage A k) (ha : 0 ≤ a) : 0 ≤ completedMatrixInclude A k a := by obtain ⟨x, rfl⟩ := positive_square_factor a ha rw [map_mul, map_star] exact star_mul_self_nonneg _ def completedProjection (k : ℕ) : CornerCompletion A := completedMatrixInclude A k 1 lemma completedProjection_star (k : ℕ) : star (completedProjection A k) = completedProjection A k := by change star (completedMatrixInclude A k 1) = completedMatrixInclude A k 1 rw [← map_star, star_one] lemma completedProjection_norm_le (k : ℕ) : ‖completedProjection A k‖ ≤ 1 := by change ‖completedMatrixInclude A k 1‖ ≤ 1 rw [completedMatrixInclude_norm] cases subsingleton_or_nontrivial (MatrixStage A k) · rw [Subsingleton.elim (1 : MatrixStage A k) 0, norm_zero]; exact zero_le_one · exact le_of_eq norm_one def completedCornerCut (k : ℕ) (a : CornerCompletion A) : CornerCompletion A := completedProjection A k * a * completedProjection A k lemma completedCornerCut_continuous (k : ℕ) : Continuous (completedCornerCut A k) := by unfold completedCornerCut fun_prop lemma completedCornerCut_sub (k : ℕ) (a b : CornerCompletion A) : completedCornerCut A k (a - b) = completedCornerCut A k a - completedCornerCut A k b := by simp only [completedCornerCut, mul_sub, sub_mul] lemma completedCornerCut_norm_le (k : ℕ) (a : CornerCompletion A) : ‖completedCornerCut A k a‖ ≤ ‖a‖ := by calc _ ≤ ‖completedProjection A k‖ * ‖a‖ * ‖completedProjection A k‖ := (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right (norm_mul_le _ _) (norm_nonneg _)) _ ≤ 1 * ‖a‖ * 1 := mul_le_mul (mul_le_mul_of_nonneg_right (completedProjection_norm_le A k) (norm_nonneg _)) (completedProjection_norm_le A k) (norm_nonneg _) (by positivity) _ = ‖a‖ := by ring lemma completedCornerCut_fixes {l k : ℕ} (h : l ≤ k) (a : MatrixStage A l) : completedCornerCut A k (completedMatrixInclude A l a) = completedMatrixInclude A l a := by rw [← completedMatrixInclude_corner A h a] change completedMatrixInclude A k 1 * completedMatrixInclude A k (corner h a) * completedMatrixInclude A k 1 = _ rw [← map_mul, ← map_mul, one_mul, mul_one] theorem completedCornerCut_tendsto (a : CornerCompletion A) : Tendsto (fun k : ℕ => completedCornerCut A k a) atTop (𝓝 a) := by apply Metric.tendsto_atTop.mpr intro ε hε have ha := completedMatrixInclude_dense A a obtain ⟨b, hb, hab⟩ := Metric.mem_closure_iff.mp ha (ε / 2) (by positivity) obtain ⟨l, c, rfl⟩ := Set.mem_iUnion.mp hb refine ⟨l, fun k hk => ?_⟩ have hfix := completedCornerCut_fixes A hk c have heq : completedCornerCut A k a - a = completedCornerCut A k (a - completedMatrixInclude A l c) + (completedMatrixInclude A l c - a) := by rw [completedCornerCut_sub, hfix] abel rw [dist_eq_norm, heq] calc _ ≤ ‖completedCornerCut A k (a - completedMatrixInclude A l c)‖ + ‖completedMatrixInclude A l c - a‖ := norm_add_le _ _ _ ≤ ‖a - completedMatrixInclude A l c‖ + ‖completedMatrixInclude A l c - a‖ := add_le_add (completedCornerCut_norm_le A k _) le_rfl _ < ε := by rw [norm_sub_rev (completedMatrixInclude A l c)] rw [dist_eq_norm] at hab linarith lemma completedCornerCut_nonneg (k : ℕ) (a : CornerCompletion A) (ha : 0 ≤ a) : 0 ≤ completedCornerCut A k a := by simpa only [completedCornerCut, completedProjection_star] using star_left_conjugate_nonneg ha (completedProjection A k) end Pureness namespace TraceCone open scoped CStarAlgebra variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] abbrev FinMatrix (A : Type*) (n : ℕ) := CStarMatrix (Fin n) (Fin n) A def matrixSuccessor (n : ℕ) : FinMatrix A n →⋆ₙₐ[ℂ] FinMatrix A (n+1) where toFun M := CStarMatrix.ofMatrix (fun i j => Fin.lastCases 0 (fun i => Fin.lastCases 0 (M i) j) i) map_zero' := by ext row column change Fin.lastCases (motive := fun _ => A) 0 (fun _ : Fin n => Fin.lastCases 0 (fun _ => (0 : A)) column) row = 0 refine Fin.lastCases ?_ (fun row => ?_) row · simp · refine Fin.lastCases ?_ (fun column => ?_) column <;> simp map_add' M N := by ext row column change Fin.lastCases (motive := fun _ => A) 0 (fun row => Fin.lastCases 0 (fun column => M row column + N row column) column) row = Fin.lastCases (motive := fun _ => A) 0 (fun row => Fin.lastCases 0 (M row) column) row + Fin.lastCases (motive := fun _ => A) 0 (fun row => Fin.lastCases 0 (N row) column) row refine Fin.lastCases ?_ (fun row => ?_) row · simp · refine Fin.lastCases ?_ (fun column => ?_) column <;> simp map_mul' M N := by ext row column change Fin.lastCases (motive := fun _ => A) 0 (fun row => Fin.lastCases 0 (fun column => ∑ index, M row index * N index column) column) row = ∑ index : Fin (n + 1), Fin.lastCases (motive := fun _ => A) 0 (fun row => Fin.lastCases 0 (M row) index) row * Fin.lastCases (motive := fun _ => A) 0 (fun index => Fin.lastCases 0 (N index) column) index refine Fin.lastCases ?_ (fun row => ?_) row · simp · refine Fin.lastCases ?_ (fun column => ?_) column · simp [Fin.sum_univ_castSucc] · simp [Fin.sum_univ_castSucc] map_smul' c M := by ext row column change Fin.lastCases (motive := fun _ => A) 0 (fun row => Fin.lastCases 0 (fun column => c • M row column) column) row = c • Fin.lastCases (motive := fun _ => A) 0 (fun row => Fin.lastCases 0 (M row) column) row refine Fin.lastCases ?_ (fun row => ?_) row · simp · refine Fin.lastCases ?_ (fun column => ?_) column <;> simp map_star' M := by ext row column change Fin.lastCases (motive := fun _ => A) 0 (fun row => Fin.lastCases 0 (fun column => star (M column row)) column) row = star (Fin.lastCases (motive := fun _ => A) 0 (fun column => Fin.lastCases 0 (M column) row) column) refine Fin.lastCases ?_ (fun row => ?_) row · refine Fin.lastCases ?_ (fun column => ?_) column <;> simp · refine Fin.lastCases ?_ (fun column => ?_) column <;> simp def matrixPad {n m : ℕ} (h : n ≤ m) : FinMatrix A n → FinMatrix A m := Nat.leRecOn h (fun {k} => matrixSuccessor k) omit [PartialOrder A] [StarOrderedRing A] in lemma matrixPad_succ {n m : ℕ} (h : n ≤ m) (M : FinMatrix A n) : matrixPad (Nat.le.step h) M = matrixSuccessor m (matrixPad h M) := Nat.leRecOn_succ h M def matrixInclusion {n m : ℕ} (h : n ≤ m) : FinMatrix A n →⋆ₙₐ[ℂ] FinMatrix A m where toFun := matrixPad h map_zero' := by induction m, h using Nat.le_induction with | base => simp only [matrixPad, Nat.leRecOn_self] | succ m h ih => rw [matrixPad_succ h, ih, map_zero] map_add' M N := by induction m, h using Nat.le_induction with | base => simp only [matrixPad, Nat.leRecOn_self] | succ m h ih => simp only [matrixPad_succ h, ih, map_add] map_mul' M N := by induction m, h using Nat.le_induction with | base => simp only [matrixPad, Nat.leRecOn_self] | succ m h ih => simp only [matrixPad_succ h, ih, map_mul] map_smul' c M := by induction m, h using Nat.le_induction with | base => simp only [matrixPad, Nat.leRecOn_self, MonoidHom.id_apply] | succ m h ih => simp only [matrixPad_succ h, ih, map_smul] map_star' M := by induction m, h using Nat.le_induction with | base => simp only [matrixPad, Nat.leRecOn_self] | succ m h ih => simp only [matrixPad_succ h, ih, map_star] omit [PartialOrder A] [StarOrderedRing A] in @[simp] lemma matrixSuccessor_apply_castSucc (n : ℕ) (M : FinMatrix A n) (row column : Fin n) : matrixSuccessor n M row.castSucc column.castSucc = M row column := by change Fin.lastCases 0 (fun row => Fin.lastCases 0 (M row) column.castSucc) row.castSucc = M row column simp omit [PartialOrder A] [StarOrderedRing A] in lemma matrixSuccessor_injective (n : ℕ) : Function.Injective (matrixSuccessor (A := A) n) := by intro first second equality ext row column simpa only [matrixSuccessor_apply_castSucc] using congrArg (fun matrix : FinMatrix A (n + 1) => matrix row.castSucc column.castSucc) equality lemma matrixSuccessor_isometry (n : ℕ) : Isometry (matrixSuccessor (A := A) n) := NonUnitalStarAlgHom.isometry _ (matrixSuccessor_injective n) @[simp] lemma matrixSuccessor_norm (n : ℕ) (M : FinMatrix A n) : ‖matrixSuccessor n M‖ = ‖M‖ := NonUnitalStarAlgHom.norm_map _ (matrixSuccessor_injective n) M omit [PartialOrder A] [StarOrderedRing A] in @[simp] lemma matrixPad_self (n : ℕ) (M : FinMatrix A n) : matrixPad le_rfl M = M := Nat.leRecOn_self M omit [PartialOrder A] [StarOrderedRing A] in lemma matrixPad_trans {n m k : ℕ} (h : n ≤ m) (g : m ≤ k) (M : FinMatrix A n) : matrixPad g (matrixPad h M) = matrixPad (h.trans g) M := (Nat.leRecOn_trans h g M).symm @[simp] lemma matrixInclusion_norm {n m : ℕ} (h : n ≤ m) (M : FinMatrix A n) : ‖matrixInclusion h M‖ = ‖M‖ := by change ‖matrixPad h M‖ = ‖M‖ induction m, h using Nat.le_induction with | base => simp | succ m h ih => rw [matrixPad_succ h, matrixSuccessor_norm, ih] lemma matrixInclusion_isometry {n m : ℕ} (h : n ≤ m) : Isometry (matrixInclusion (A := A) h) := AddMonoidHomClass.isometry_of_norm _ (matrixInclusion_norm h) @[simp] lemma matrixInclusion_trans {n m k : ℕ} (h : n ≤ m) (g : m ≤ k) (M : FinMatrix A n) : matrixInclusion g (matrixInclusion h M) = matrixInclusion (h.trans g) M := matrixPad_trans h g M end TraceCone section open scoped ENNReal Topology open Filter namespace TraceCone variable (A : ℕ → Type*) [∀ n, NonUnitalCStarAlgebra (A n)] abbrev BoundedFamilies := lp A ∞ end TraceCone end section open scoped ENNReal Topology open Filter namespace TraceCone variable (A : ℕ → Type*) [∀ n, NonUnitalCStarAlgebra (A n)] namespace BoundedFamilies variable {A} lemma norm_coordinate_le (x : BoundedFamilies A) (n : ℕ) : ‖x n‖ ≤ ‖x‖ := lp.norm_apply_le_norm (by simp) x n def vanishing : Submodule ℂ (BoundedFamilies A) where carrier := {x | Tendsto (fun n => ‖x n‖) atTop (𝓝 0)} zero_mem' := by simp add_mem' hx hy := by apply squeeze_zero (fun _ => norm_nonneg _) (fun n => norm_add_le _ _) simpa using hx.add hy smul_mem' c x hx := by change Tendsto (fun n => ‖c • x n‖) atTop (𝓝 0) simpa only [norm_smul, mul_zero] using (tendsto_const_nhds (x := ‖c‖)).mul hx @[simp] lemma mem_vanishing (x : BoundedFamilies A) : x ∈ vanishing (A := A) ↔ Tendsto (fun n => ‖x n‖) atTop (𝓝 0) := Iff.rfl lemma mul_mem_vanishing_left (x : BoundedFamilies A) {y : BoundedFamilies A} (hy : y ∈ vanishing (A := A)) : x*y ∈ vanishing (A := A) := by rw [mem_vanishing] have h : Tendsto (fun n => ‖x‖*‖y n‖) atTop (𝓝 0) := by simpa using (tendsto_const_nhds (x := ‖x‖)).mul hy apply squeeze_zero (fun _ => norm_nonneg _) (fun n => ?_) h exact (norm_mul_le (x n) (y n)).trans (mul_le_mul_of_nonneg_right (norm_coordinate_le x n) (norm_nonneg _)) lemma mul_mem_vanishing_right {x : BoundedFamilies A} (hx : x ∈ vanishing (A := A)) (y : BoundedFamilies A) : x*y ∈ vanishing (A := A) := by rw [mem_vanishing] have h : Tendsto (fun n => ‖x n‖*‖y‖) atTop (𝓝 0) := by simpa using hx.mul (tendsto_const_nhds (x := ‖y‖)) apply squeeze_zero (fun _ => norm_nonneg _) (fun n => ?_) h exact (norm_mul_le (x n) (y n)).trans (mul_le_mul_of_nonneg_left (norm_coordinate_le y n) (norm_nonneg _)) lemma star_mem_vanishing {x : BoundedFamilies A} (hx : x ∈ vanishing (A := A)) : star x ∈ vanishing (A := A) := by change Tendsto (fun n => ‖star (x n)‖) atTop (𝓝 0) simpa only [norm_star] using (mem_vanishing x).mp hx instance vanishing_closed : IsClosed (vanishing (A := A) : Set (BoundedFamilies A)) := by apply isClosed_of_closure_subset intro x hx change Tendsto (fun n => ‖x n‖) atTop (𝓝 0) rw [Metric.tendsto_atTop] intro ε hε obtain ⟨y, hy, hxy⟩ := Metric.mem_closure_iff.mp hx (ε/2) (by linarith) obtain ⟨N, hN⟩ := Metric.tendsto_atTop.mp hy (ε/2) (by linarith) refine ⟨N, fun n hn => ?_⟩ have hdiff : ‖x n-y n‖ < ε/2 := by have h := norm_coordinate_le (x-y) n exact h.trans_lt (by simpa only [dist_eq_norm] using hxy) have htail : ‖y n‖ < ε/2 := by simpa using hN n hn rw [dist_zero_right, norm_norm] have h : ‖x n‖ ≤ ‖x n-y n‖+‖y n‖ := norm_le_norm_sub_add _ _ linarith def vanishingCon : RingCon (BoundedFamilies A) where toSetoid := (vanishing (A := A)).quotientRel add' := by intro x y u v hxy huv rw [Submodule.quotientRel_def] at hxy huv ⊢ convert (vanishing (A := A)).add_mem hxy huv using 1; abel mul' := by intro x y u v hxy huv rw [Submodule.quotientRel_def] at hxy huv ⊢ have h := (vanishing (A := A)).add_mem (mul_mem_vanishing_right hxy u) (mul_mem_vanishing_left y huv) convert h using 1; noncomm_ring end BoundedFamilies end TraceCone end section open scoped ENNReal Topology open Filter Metric namespace TraceCone variable (A : ℕ → Type*) [∀ n, NonUnitalCStarAlgebra (A n)] def FamilyQuotient := (BoundedFamilies.vanishingCon (A := A)).Quotient end TraceCone end section open scoped ENNReal Topology open Filter Metric namespace TraceCone variable (A : ℕ → Type*) [∀ n, NonUnitalCStarAlgebra (A n)] namespace FamilyQuotient open BoundedFamilies variable {A} instance : NonUnitalRing (FamilyQuotient A) := inferInstanceAs (NonUnitalRing (vanishingCon (A := A)).Quotient) instance : NormedAddCommGroup (FamilyQuotient A) := inferInstanceAs (NormedAddCommGroup (BoundedFamilies A ⧸ vanishing (A := A))) instance : Module ℂ (FamilyQuotient A) := inferInstanceAs (Module ℂ (BoundedFamilies A ⧸ vanishing (A := A))) instance : NormedSpace ℂ (FamilyQuotient A) := inferInstanceAs (NormedSpace ℂ (BoundedFamilies A ⧸ vanishing (A := A))) instance : CompleteSpace (FamilyQuotient A) := inferInstanceAs (CompleteSpace (BoundedFamilies A ⧸ vanishing (A := A))) def mk (x : BoundedFamilies A) : FamilyQuotient A := Submodule.Quotient.mk x @[simp] lemma mk_mul (x y : BoundedFamilies A) : mk (x*y) = mk x*mk y := rfl lemma mk_surjective : Function.Surjective (mk (A := A)) := Quotient.mk_surjective lemma mk_eq_mk_iff (x y : BoundedFamilies A) : mk x = mk y ↔ x-y ∈ vanishing (A := A) := Submodule.Quotient.eq _ lemma norm_mk_le (x : BoundedFamilies A) : ‖mk x‖ ≤ ‖x‖ := Submodule.Quotient.norm_mk_le _ _ lemma exists_norm_mk_lt (x : FamilyQuotient A) {ε : ℝ} (hε : 0 < ε) : ∃ a : BoundedFamilies A, mk a = x ∧ ‖a‖ < ‖x‖+ε := Submodule.Quotient.norm_mk_lt x hε instance : NonUnitalNormedRing (FamilyQuotient A) where dist_eq := dist_eq_norm_neg_add norm_mul_le x y := le_of_forall_pos_le_add fun ε hε => by have h := ((nhds_basis_ball.prod_nhds nhds_basis_ball).tendsto_iff nhds_basis_ball).mp (continuous_mul.tendsto (‖x‖, ‖y‖)) ε hε simp only [Set.mem_prod, Metric.mem_ball, and_imp, Prod.forall, Prod.exists] at h obtain ⟨ε₁, ε₂, ⟨h₁,h₂⟩, h⟩ := h obtain ⟨a, rfl, ha⟩ := exists_norm_mk_lt x h₁ obtain ⟨b, rfl, hb⟩ := exists_norm_mk_lt y h₂ simp only [Real.dist_eq, abs_sub_lt_iff] at h specialize h ‖a‖ ‖b‖ ⟨by linarith, by linarith [norm_mk_le a]⟩ ⟨by linarith, by linarith [norm_mk_le b]⟩ exact ((norm_mk_le (a*b)).trans (norm_mul_le a b)).trans (sub_lt_iff_lt_add'.mp h.1).le instance : Star (FamilyQuotient A) := ⟨Quotient.map' star (by intro x y h change (vanishing (A := A)).quotientRel x y at h change (vanishing (A := A)).quotientRel (star x) (star y) rw [Submodule.quotientRel_def] at h ⊢ simpa only [star_sub] using star_mem_vanishing h)⟩ @[simp] lemma mk_star (x : BoundedFamilies A) : mk (star x) = star (mk x) := rfl instance : StarRing (FamilyQuotient A) where star_involutive := by intro x obtain ⟨x,rfl⟩ := mk_surjective x exact congrArg mk (star_star x) star_mul := by intro x y obtain ⟨x,rfl⟩ := mk_surjective x obtain ⟨y,rfl⟩ := mk_surjective y exact congrArg mk (star_mul x y) star_add := by intro x y obtain ⟨x,rfl⟩ := mk_surjective x obtain ⟨y,rfl⟩ := mk_surjective y exact congrArg mk (star_add x y) instance : StarModule ℂ (FamilyQuotient A) where star_smul := by intro c x obtain ⟨x,rfl⟩ := mk_surjective x exact congrArg mk (star_smul c x) instance : IsScalarTower ℂ (FamilyQuotient A) (FamilyQuotient A) where smul_assoc := by intro c x y obtain ⟨x,rfl⟩ := mk_surjective x obtain ⟨y,rfl⟩ := mk_surjective y exact congrArg mk (smul_mul_assoc c x y) instance : SMulCommClass ℂ (FamilyQuotient A) (FamilyQuotient A) where smul_comm := by intro c x y obtain ⟨x,rfl⟩ := mk_surjective x obtain ⟨y,rfl⟩ := mk_surjective y exact congrArg mk (smul_comm c x y) end FamilyQuotient end TraceCone end section open scoped ENNReal Topology open Filter namespace TraceCone variable {A : ℕ → Type*} [∀ n, NonUnitalCStarAlgebra (A n)] namespace BoundedFamilies lemma norm_bounded (x : BoundedFamilies A) : IsBoundedUnder (· ≤ ·) atTop (fun n => ‖x n‖) := isBoundedUnder_of ⟨‖x‖, norm_coordinate_le x⟩ lemma norm_cobounded (x : BoundedFamilies A) : IsCoboundedUnder (· ≤ ·) atTop (fun n => ‖x n‖) := (isBoundedUnder_of ⟨0, fun n => norm_nonneg (x n)⟩ : IsBoundedUnder (· ≥ ·) atTop (fun n => ‖x n‖)).isCoboundedUnder_le lemma limsup_norm_nonneg (x : BoundedFamilies A) : 0 ≤ limsup (fun n => ‖x n‖) atTop := le_limsup_of_frequently_le (Eventually.of_forall (fun n => norm_nonneg (x n))).frequently (norm_bounded x) lemma limsup_norm_le_of_vanishing_sub (x y : BoundedFamilies A) (h : x-y ∈ vanishing (A := A)) : limsup (fun n => ‖x n‖) atTop ≤ ‖y‖ := by apply le_of_forall_pos_le_add intro ε hε apply limsup_le_of_le (norm_cobounded x) have he : ∀ᶠ n in atTop, ‖x n-y n‖ < ε := by have h0 := h have h0' : Tendsto (fun n => ‖x n-y n‖) atTop (𝓝 0) := h0 exact (tendsto_order.mp h0').2 ε hε filter_upwards [he] with n hn have ht := norm_le_norm_sub_add (x n) (y n) have hy := norm_coordinate_le y n linarith def tail (x : BoundedFamilies A) (N : ℕ) : BoundedFamilies A := ⟨fun n => if N ≤ n then x n else 0, memℓp_infty ⟨‖x‖, by rintro _ ⟨n,rfl⟩ change ‖if N ≤ n then x n else 0‖ ≤ ‖x‖ split_ifs · exact norm_coordinate_le x n · simpa only [norm_zero] using norm_nonneg x⟩⟩ lemma tail_sub_mem (x : BoundedFamilies A) (N : ℕ) : tail x N-x ∈ vanishing (A := A) := by change Tendsto (fun n => ‖(tail x N) n-x n‖) atTop (𝓝 0) apply (tendsto_congr' (show (fun n => ‖(tail x N) n-x n‖) =ᶠ[atTop] fun _ => (0 : ℝ) from ?_)).mpr tendsto_const_nhds filter_upwards [eventually_ge_atTop N] with n hn simp [tail, hn] lemma norm_tail_le (x : BoundedFamilies A) (N : ℕ) (C : ℝ) (hC : 0 ≤ C) (h : ∀ n, N ≤ n → ‖x n‖ ≤ C) : ‖tail x N‖ ≤ C := by apply lp.norm_le_of_forall_le hC intro n change ‖if N ≤ n then x n else 0‖ ≤ C split_ifs with hn · exact h n hn · simpa using hC end BoundedFamilies end TraceCone end section open scoped ENNReal Topology open Filter namespace TraceCone variable {A : ℕ → Type*} [∀ n, NonUnitalCStarAlgebra (A n)] namespace FamilyQuotient open BoundedFamilies theorem norm_mk_eq_limsup (x : BoundedFamilies A) : ‖mk x‖ = limsup (fun n => ‖x n‖) atTop := by apply le_antisymm · apply le_of_forall_pos_le_add intro ε hε obtain ⟨N,hN⟩ := eventually_atTop.mp (eventually_lt_of_limsup_lt (lt_add_of_pos_right (limsup (fun n => ‖x n‖) atTop) hε) (norm_bounded x)) have heq : mk (tail x N) = mk x := (mk_eq_mk_iff _ _).mpr (tail_sub_mem x N) rw [← heq] exact (norm_mk_le _).trans (norm_tail_le x N _ (by linarith [limsup_norm_nonneg x]) (fun n hn => (hN n hn).le)) · apply le_of_forall_pos_le_add intro ε hε obtain ⟨y,hy,hn⟩ := exists_norm_mk_lt (mk x) hε have hxy : x-y ∈ vanishing (A := A) := (mk_eq_mk_iff _ _).mp hy.symm exact (limsup_norm_le_of_vanishing_sub x y hxy).trans hn.le lemma norm_star_mul_self_eq (x : FamilyQuotient A) : ‖star x*x‖ = ‖x‖*‖x‖ := by obtain ⟨x,rfl⟩ := mk_surjective x rw [← mk_star, ← mk_mul, norm_mk_eq_limsup, norm_mk_eq_limsup] let f : ℝ → ℝ := fun t => max t 0 * max t 0 have hf : Monotone f := by intro a b hab exact mul_self_le_mul_self (le_max_right _ _) (max_le_max hab le_rfl) have hc : Continuous f := (continuous_id.max continuous_const).mul (continuous_id.max continuous_const) have h := hf.map_limsup_of_continuousAt (fun n => ‖x n‖) hc.continuousAt (norm_bounded x) (norm_cobounded x) have he : f ∘ (fun n => ‖x n‖) = fun n => ‖star (x n)*x n‖ := by funext n simp only [Function.comp_apply, f, max_eq_left (norm_nonneg (x n)), CStarRing.norm_star_mul_self] rw [he] at h dsimp [f] at h rw [max_eq_left (limsup_norm_nonneg x)] at h exact h.symm instance : CStarRing (FamilyQuotient A) where norm_mul_self_le x := (norm_star_mul_self_eq x).symm.le instance : NonUnitalCStarAlgebra (FamilyQuotient A) where end FamilyQuotient end TraceCone end section open scoped ENNReal Topology CStarAlgebra open Filter namespace TraceCone variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def matrixFamily (n : ℕ) : FinMatrix A n →⋆ₙₐ[ℂ] BoundedFamilies (FinMatrix A) where toFun M := ⟨fun m => if h : n ≤ m then matrixInclusion h M else 0, memℓp_infty ⟨‖M‖, by rintro _ ⟨m,rfl⟩ change ‖if h : n ≤ m then matrixInclusion h M else 0‖ ≤ ‖M‖ split_ifs <;> simp_all [norm_nonneg]⟩⟩ map_zero' := by apply lp.ext; funext m; change (if h : n ≤ m then matrixInclusion h 0 else 0) = 0; split_ifs <;> simp_all map_add' M N := by apply lp.ext; funext m change (if h : n ≤ m then matrixInclusion h (M+N) else 0) = (if h : n ≤ m then matrixInclusion h M else 0) + (if h : n ≤ m then matrixInclusion h N else 0) split_ifs <;> simp_all map_mul' M N := by apply lp.ext; funext m change (if h : n ≤ m then matrixInclusion h (M*N) else 0) = (if h : n ≤ m then matrixInclusion h M else 0) * (if h : n ≤ m then matrixInclusion h N else 0) split_ifs <;> simp_all map_smul' c M := by apply lp.ext; funext m change (if h : n ≤ m then matrixInclusion h (c • M) else 0) = c • (if h : n ≤ m then matrixInclusion h M else 0) split_ifs <;> simp_all map_star' M := by apply lp.ext; funext m change (if h : n ≤ m then matrixInclusion h (star M) else 0) = star (if h : n ≤ m then matrixInclusion h M else 0) by_cases h : n ≤ m · rw [dite_eq_left h, dite_eq_left h] exact map_star (matrixInclusion h) M · rw [dite_eq_right h, dite_eq_right h] exact (star_zero _).symm end TraceCone end section open scoped ENNReal Topology CStarAlgebra open Filter namespace TraceCone variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] namespace FamilyQuotient variable {F : ℕ → Type*} [∀ n, NonUnitalCStarAlgebra (F n)] def quotientHom : BoundedFamilies F →⋆ₙₐ[ℂ] FamilyQuotient F where toFun := mk map_zero' := rfl map_add' _ _ := rfl map_mul' _ _ := rfl map_smul' _ _ := rfl map_star' _ := rfl lemma mk_eq_of_eventually_eq (x y : BoundedFamilies F) (h : ∀ᶠ n in atTop, x n = y n) : mk x = mk y := by apply (mk_eq_mk_iff _ _).mpr change Tendsto (fun n => ‖x n-y n‖) atTop (𝓝 0) apply tendsto_const_nhds.congr' filter_upwards [h] with n hn simp [hn] end FamilyQuotient end TraceCone end section open scoped ENNReal Topology CStarAlgebra open Filter namespace TraceCone variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def matrixStage (n : ℕ) : FinMatrix A n →⋆ₙₐ[ℂ] FamilyQuotient (FinMatrix A) := FamilyQuotient.quotientHom.comp (matrixFamily n) @[simp] lemma matrixStage_norm (n : ℕ) (M : FinMatrix A n) : ‖matrixStage n M‖ = ‖M‖ := by change ‖FamilyQuotient.mk (matrixFamily n M)‖ = _ rw [FamilyQuotient.norm_mk_eq_limsup] calc _ = limsup (fun _ : ℕ => ‖M‖) atTop := limsup_congr (by filter_upwards [eventually_ge_atTop n] with m hm change ‖if h : n ≤ m then matrixInclusion h M else 0‖ = ‖M‖ simp [hm]) _ = ‖M‖ := limsup_const (b := ‖M‖) @[simp] lemma matrixStage_compatible {n m : ℕ} (h : n ≤ m) (M : FinMatrix A n) : matrixStage m (matrixInclusion h M) = matrixStage n M := by apply FamilyQuotient.mk_eq_of_eventually_eq filter_upwards [eventually_ge_atTop m] with k hk change (if g : m ≤ k then matrixInclusion g (matrixInclusion h M) else 0) = (if g : n ≤ k then matrixInclusion g M else 0) simp [hk, h.trans hk] end TraceCone end section open scoped ENNReal Topology CStarAlgebra namespace TraceCone variable (A : Type*) [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def matrixUnion : NonUnitalStarSubalgebra ℂ (FamilyQuotient (FinMatrix A)) where carrier := {x | ∃ (n : ℕ) (M : FinMatrix A n), matrixStage n M = x} zero_mem' := ⟨0,0,map_zero _⟩ add_mem' := by rintro x y ⟨n,M,rfl⟩ ⟨m,N,rfl⟩ refine ⟨max n m, matrixInclusion (le_max_left n m) M + matrixInclusion (le_max_right n m) N, ?_⟩ simp mul_mem' := by rintro x y ⟨n,M,rfl⟩ ⟨m,N,rfl⟩ refine ⟨max n m, matrixInclusion (le_max_left n m) M * matrixInclusion (le_max_right n m) N, ?_⟩ simp smul_mem' := by rintro c x ⟨n,M,rfl⟩ exact ⟨n,c • M,map_smul _ c M⟩ star_mem' := by rintro x ⟨n,M,rfl⟩ exact ⟨n,star M,map_star _ M⟩ def matrixLimitAlgebra : NonUnitalStarSubalgebra ℂ (FamilyQuotient (FinMatrix A)) := (matrixUnion A).topologicalClosure instance matrixLimitAlgebra_closed : IsClosed (matrixLimitAlgebra A : Set (FamilyQuotient (FinMatrix A))) := NonUnitalStarSubalgebra.isClosed_topologicalClosure _ abbrev MatrixLimit := matrixLimitAlgebra A instance : NonUnitalCStarAlgebra (MatrixLimit A) := NonUnitalStarSubalgebra.nonUnitalCStarAlgebra (matrixLimitAlgebra A) end TraceCone end section open scoped ENNReal Topology CStarAlgebra namespace TraceCone variable (A : Type*) [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] variable {A} def matrixLimitStage (n : ℕ) : FinMatrix A n →⋆ₙₐ[ℂ] MatrixLimit A where toFun M := ⟨matrixStage n M, NonUnitalStarSubalgebra.le_topologicalClosure _ ⟨n,M,rfl⟩⟩ map_zero' := Subtype.ext (map_zero _) map_add' M N := Subtype.ext (map_add _ M N) map_mul' M N := Subtype.ext (map_mul _ M N) map_smul' c M := Subtype.ext (map_smul _ c M) map_star' M := Subtype.ext (map_star _ M) @[simp] lemma matrixLimitStage_norm (n : ℕ) (M : FinMatrix A n) : ‖matrixLimitStage n M‖ = ‖M‖ := matrixStage_norm n M lemma matrixLimitStage_isometry (n : ℕ) : Isometry (matrixLimitStage (A := A) n) := AddMonoidHomClass.isometry_of_norm _ (matrixLimitStage_norm n) @[simp] lemma matrixLimitStage_compatible {n m : ℕ} (h : n ≤ m) (M : FinMatrix A n) : matrixLimitStage m (matrixInclusion h M) = matrixLimitStage n M := Subtype.ext (matrixStage_compatible h M) theorem matrixLimit_finite_approximation (x : MatrixLimit A) {ε : ℝ} (hε : 0 < ε) : ∃ (n : ℕ) (M : FinMatrix A n), ‖x-matrixLimitStage n M‖ < ε := by obtain ⟨y,⟨n,M,rfl⟩,hy⟩ := Metric.mem_closure_iff.mp x.2 ε hε refine ⟨n,M,?_⟩ change ‖(x : FamilyQuotient (FinMatrix A))-matrixStage n M‖ < ε simpa only [dist_eq_norm] using hy end TraceCone end section open scoped Topology namespace TraceCone variable {D B : Type*} [NonUnitalCStarAlgebra D] [NonUnitalCStarAlgebra B] def extendDenseStarHom (S : NonUnitalStarSubalgebra ℂ D) (f : S →⋆ₙₐ[ℂ] B) (hf : ∀ x, ‖f x‖ ≤ ‖x‖) (hd : DenseRange (fun x : S => (x : D))) : D →⋆ₙₐ[ℂ] B := by let l : S →ₗ[ℂ] B := { toFun := f, map_add' := f.map_add, map_smul' := f.map_smul } let L : S →L[ℂ] B := l.mkContinuous 1 (fun x => by simpa [l] using hf x) let E : D →L[ℂ] B := L.extend S.toSubmodule.subtypeL have heq (x : S) : E (x : D) = f x := ContinuousLinearMap.extend_eq L (e := S.toSubmodule.subtypeL) hd isometry_subtype_coe.isUniformInducing x exact { toFun := E map_zero' := E.map_zero map_add' := E.map_add map_smul' := E.map_smul map_mul' := by refine hd.induction_on₂ ?_ ?_ · exact isClosed_eq (E.continuous.comp continuous_mul) ((E.continuous.comp continuous_fst).mul (E.continuous.comp continuous_snd)) · intro x y change E ((x*y : S) : D) = E (x : D)*E (y : D) rw [heq,heq,heq,map_mul] map_star' := by intro a refine hd.induction_on a ?_ ?_ · exact isClosed_eq (E.continuous.comp continuous_star) E.continuous.star · intro x change E ((star x : S) : D) = star (E (x : D)) rw [heq,heq,map_star] } theorem extendDenseStarHom_eq (S : NonUnitalStarSubalgebra ℂ D) (f : S →⋆ₙₐ[ℂ] B) (hf : ∀ x, ‖f x‖ ≤ ‖x‖) (hd : DenseRange (fun x : S => (x : D))) (x : S) : extendDenseStarHom S f hf hd (x : D) = f x := ContinuousLinearMap.extend_eq _ hd isometry_subtype_coe.isUniformInducing x end TraceCone end section open scoped Topology CStarAlgebra namespace TraceCone variable {A B : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] [NonUnitalCStarAlgebra B] def finiteMatrixSubalgebra : NonUnitalStarSubalgebra ℂ (MatrixLimit A) := (matrixUnion A).comap (NonUnitalStarSubalgebraClass.subtype (matrixLimitAlgebra A)) def finiteMatrixStage (n : ℕ) (M : FinMatrix A n) : finiteMatrixSubalgebra (A := A) := ⟨matrixLimitStage n M,⟨n,M,rfl⟩⟩ lemma finiteMatrixStage_surjective (x : finiteMatrixSubalgebra (A := A)) : ∃ (n : ℕ) (M : FinMatrix A n), finiteMatrixStage n M = x := by obtain ⟨n,M,hM⟩ := x.2 exact ⟨n,M,Subtype.ext (Subtype.ext hM)⟩ lemma finiteMatrixSubalgebra_dense : DenseRange (fun x : finiteMatrixSubalgebra (A := A) => (x : MatrixLimit A)) := by intro x rw [Metric.mem_closure_iff] intro ε hε obtain ⟨n,M,hM⟩ := matrixLimit_finite_approximation x hε exact ⟨matrixLimitStage n M,⟨finiteMatrixStage n M,rfl⟩,by simpa only [dist_eq_norm] using hM⟩ def finiteMatrixRepresentative (x : finiteMatrixSubalgebra (A := A)) : Σ n, FinMatrix A n := ⟨(finiteMatrixStage_surjective x).choose,(finiteMatrixStage_surjective x).choose_spec.choose⟩ lemma finiteMatrixRepresentative_spec (x : finiteMatrixSubalgebra (A := A)) : finiteMatrixStage (finiteMatrixRepresentative x).1 (finiteMatrixRepresentative x).2 = x := (finiteMatrixStage_surjective x).choose_spec.choose_spec end TraceCone end section open scoped Topology CStarAlgebra namespace TraceCone variable {A B : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] [NonUnitalCStarAlgebra B] variable (f : ∀ n, FinMatrix A n →⋆ₙₐ[ℂ] B) variable (hf : ∀ {n m : ℕ} (h : n ≤ m) (M : FinMatrix A n), f m (matrixInclusion h M) = f n M) def finiteMatrixLiftValue (x : finiteMatrixSubalgebra (A := A)) : B := f (finiteMatrixRepresentative x).1 (finiteMatrixRepresentative x).2 include hf in lemma finiteMatrixLiftValue_eq (x : finiteMatrixSubalgebra (A := A)) (n : ℕ) (M : FinMatrix A n) (hx : finiteMatrixStage n M = x) : finiteMatrixLiftValue f x = f n M := by let r := finiteMatrixRepresentative x have he : matrixLimitStage r.1 r.2 = matrixLimitStage n M := congrArg Subtype.val ((finiteMatrixRepresentative_spec x).trans hx.symm) have hm : matrixInclusion (le_max_left r.1 n) r.2 = matrixInclusion (le_max_right r.1 n) M := by apply (matrixLimitStage_isometry (max r.1 n)).injective simpa only [matrixLimitStage_compatible] using he change f r.1 r.2 = f n M rw [← hf (le_max_left r.1 n) r.2,← hf (le_max_right r.1 n) M,hm] include hf in @[simp] lemma finiteMatrixLiftValue_stage (n : ℕ) (M : FinMatrix A n) : finiteMatrixLiftValue f (finiteMatrixStage n M) = f n M := finiteMatrixLiftValue_eq f hf _ n M rfl lemma finiteMatrix_common_stage (x y : finiteMatrixSubalgebra (A := A)) : ∃ (n : ℕ) (M N : FinMatrix A n), finiteMatrixStage n M = x ∧ finiteMatrixStage n N = y := by obtain ⟨n,M,rfl⟩ := finiteMatrixStage_surjective x obtain ⟨m,N,rfl⟩ := finiteMatrixStage_surjective y refine ⟨max n m,matrixInclusion (le_max_left n m) M,matrixInclusion (le_max_right n m) N,?_,?_⟩ · exact Subtype.ext (matrixLimitStage_compatible _ _) · exact Subtype.ext (matrixLimitStage_compatible _ _) def finiteMatrixLift : finiteMatrixSubalgebra (A := A) →⋆ₙₐ[ℂ] B where toFun := finiteMatrixLiftValue f map_zero' := by have hz : finiteMatrixStage (A := A) 0 0 = 0 := Subtype.ext (map_zero _) rw [← hz,finiteMatrixLiftValue_stage f hf,map_zero] map_add' x y := by obtain ⟨n,M,N,rfl,rfl⟩ := finiteMatrix_common_stage x y have he : finiteMatrixStage n (M+N) = finiteMatrixStage n M + finiteMatrixStage n N := Subtype.ext (map_add _ _ _) rw [← he,finiteMatrixLiftValue_stage f hf,finiteMatrixLiftValue_stage f hf,finiteMatrixLiftValue_stage f hf,map_add] map_mul' x y := by obtain ⟨n,M,N,rfl,rfl⟩ := finiteMatrix_common_stage x y have he : finiteMatrixStage n (M*N) = finiteMatrixStage n M * finiteMatrixStage n N := Subtype.ext (map_mul _ _ _) rw [← he,finiteMatrixLiftValue_stage f hf,finiteMatrixLiftValue_stage f hf,finiteMatrixLiftValue_stage f hf,map_mul] map_smul' c x := by obtain ⟨n,M,rfl⟩ := finiteMatrixStage_surjective x have he : finiteMatrixStage n (c • M) = c • finiteMatrixStage n M := Subtype.ext (map_smul _ _ _) rw [← he,finiteMatrixLiftValue_stage f hf,finiteMatrixLiftValue_stage f hf,map_smul] rfl map_star' x := by obtain ⟨n,M,rfl⟩ := finiteMatrixStage_surjective x have he : finiteMatrixStage n (star M) = star (finiteMatrixStage n M) := Subtype.ext (map_star _ _) rw [← he,finiteMatrixLiftValue_stage f hf,finiteMatrixLiftValue_stage f hf,map_star] lemma finiteMatrixLift_norm_le (x : finiteMatrixSubalgebra (A := A)) : ‖finiteMatrixLift f hf x‖ ≤ ‖x‖ := by obtain ⟨n,M,rfl⟩ := finiteMatrixStage_surjective x change ‖finiteMatrixLiftValue f (finiteMatrixStage n M)‖ ≤ ‖matrixLimitStage n M‖ rw [finiteMatrixLiftValue_stage f hf,matrixLimitStage_norm] exact NonUnitalStarAlgHom.norm_apply_le (f n) M def matrixLimitLift : MatrixLimit A →⋆ₙₐ[ℂ] B := extendDenseStarHom finiteMatrixSubalgebra (finiteMatrixLift f hf) (finiteMatrixLift_norm_le f hf) finiteMatrixSubalgebra_dense @[simp] theorem matrixLimitLift_stage (n : ℕ) (M : FinMatrix A n) : matrixLimitLift f hf (matrixLimitStage n M) = f n M := by change extendDenseStarHom _ _ _ _ ((finiteMatrixStage n M : finiteMatrixSubalgebra) : MatrixLimit A) = _ rw [extendDenseStarHom_eq] exact finiteMatrixLiftValue_stage f hf n M end TraceCone end section namespace Pureness open Topology variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] omit [PartialOrder A] [StarOrderedRing A] in lemma shared_matrixSuccessor_eq_corner (k : ℕ) (a : MatrixStage A k) : TraceCone.matrixSuccessor k a = corner (Nat.le_succ k) a := by ext row column change Fin.lastCases 0 (fun row => Fin.lastCases 0 (a row) column) row = if hrow : row.val < k then if hcolumn : column.val < k then a ⟨row.val, hrow⟩ ⟨column.val, hcolumn⟩ else 0 else 0 refine Fin.lastCases ?_ (fun row => ?_) row · simp · refine Fin.lastCases ?_ (fun column => ?_) column · simp · simp [row.isLt, column.isLt] lemma shared_matrixInclusion_eq_corner {k l : ℕ} (h : k ≤ l) (a : MatrixStage A k) : TraceCone.matrixInclusion h a = corner h a := by change TraceCone.matrixPad h a = _ induction l, h using Nat.le_induction with | base => simp only [TraceCone.matrixPad, Nat.leRecOn_self, corner_refl] | succ l h ih => rw [TraceCone.matrixPad_succ h, ih, shared_matrixSuccessor_eq_corner, corner_comp] lemma completedMatrixInclude_shared_compatible {k l : ℕ} (h : k ≤ l) (a : MatrixStage A k) : completedMatrixInclude A l (TraceCone.matrixInclusion h a) = completedMatrixInclude A k a := by rw [shared_matrixInclusion_eq_corner, completedMatrixInclude_corner] def sharedMatrixToCompletion : TraceCone.MatrixLimit A →⋆ₙₐ[ℂ] CornerCompletion A := TraceCone.matrixLimitLift (completedMatrixInclude A) completedMatrixInclude_shared_compatible @[simp] lemma sharedMatrixToCompletion_stage (k : ℕ) (a : MatrixStage A k) : sharedMatrixToCompletion (TraceCone.matrixLimitStage k a) = completedMatrixInclude A k a := TraceCone.matrixLimitLift_stage _ _ k a lemma sharedMatrixToCompletion_continuous : Continuous (sharedMatrixToCompletion (A := A)) := by apply LipschitzWith.continuous (K := 1) apply LipschitzWith.of_dist_le_mul intro x y simpa only [dist_eq_norm, ← map_sub, NNReal.coe_one, one_mul] using NonUnitalStarAlgHom.norm_apply_le (sharedMatrixToCompletion (A := A)) (x-y) lemma sharedMatrixToCompletion_norm (x : TraceCone.MatrixLimit A) : ‖sharedMatrixToCompletion x‖ = ‖x‖ := by refine TraceCone.finiteMatrixSubalgebra_dense.induction_on x ?_ ?_ · exact isClosed_eq (sharedMatrixToCompletion_continuous.norm) continuous_norm · intro y obtain ⟨k,a,rfl⟩ := TraceCone.finiteMatrixStage_surjective y change ‖sharedMatrixToCompletion (TraceCone.matrixLimitStage k a)‖ = ‖TraceCone.matrixLimitStage k a‖ rw [sharedMatrixToCompletion_stage, completedMatrixInclude_norm, TraceCone.matrixLimitStage_norm] lemma sharedMatrixToCompletion_isometry : Isometry (sharedMatrixToCompletion (A := A)) := AddMonoidHomClass.isometry_of_norm _ sharedMatrixToCompletion_norm lemma sharedMatrixToCompletion_surjective : Function.Surjective (sharedMatrixToCompletion (A := A)) := by intro x have hc : IsClosed (Set.range (sharedMatrixToCompletion (A := A))) := (sharedMatrixToCompletion_isometry (A := A)).isClosedEmbedding.isClosed_range have hd : Dense (Set.range (sharedMatrixToCompletion (A := A))) := by apply (completedMatrixInclude_dense A).mono rintro y hy obtain ⟨k,a,rfl⟩ := Set.mem_iUnion.mp hy exact ⟨TraceCone.matrixLimitStage k a, sharedMatrixToCompletion_stage k a⟩ have hx := hd x rw [hc.closure_eq] at hx exact hx def sharedMatrixEquiv : TraceCone.MatrixLimit A ≃⋆ₐ[ℂ] CornerCompletion A := StarAlgEquiv.ofBijective sharedMatrixToCompletion ⟨sharedMatrixToCompletion_isometry.injective, sharedMatrixToCompletion_surjective⟩ end Pureness open scoped ENNReal NNReal CStarAlgebra namespace TraceCone variable {A B : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] [NonUnitalCStarAlgebra B] [PartialOrder B] [StarOrderedRing B] namespace Positive def map (f : A →⋆ₙₐ[ℂ] B) (a : Positive A) : Positive B := ⟨f a.1, map_nonneg f a.2⟩ end Positive end TraceCone end section open scoped ENNReal NNReal CStarAlgebra namespace TraceCone variable {A B : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] [NonUnitalCStarAlgebra B] [PartialOrder B] [StarOrderedRing B] namespace ExtendedTrace def pullback (τ : ExtendedTrace B) (f : A →⋆ₙₐ[ℂ] B) : ExtendedTrace A where toFun a := τ (Positive.map f a) map_zero := by have h : Positive.map f Positive.zero = Positive.zero := Subtype.ext (_root_.map_zero f) rw [h, τ.map_zero] map_add a b := by have h : Positive.map f (Positive.add a b) = Positive.add (Positive.map f a) (Positive.map f b) := Subtype.ext (_root_.map_add f _ _) rw [h, τ.map_add] map_smul r a := by have h : Positive.map f (Positive.smul r a) = Positive.smul r (Positive.map f a) := by apply Subtype.ext change f ((r : ℝ) • a.1) = (r : ℝ) • f a.1 simpa only [← Complex.coe_smul] using _root_.map_smul f (r : ℂ) a.1 rw [h, τ.map_smul] tracial x := by have h₁ : Positive.map f (Positive.starMul x) = Positive.starMul (f x) := by apply Subtype.ext simp [Positive.map, Positive.starMul, map_mul, map_star] have h₂ : Positive.map f (Positive.mulStar x) = Positive.mulStar (f x) := by apply Subtype.ext simp [Positive.map, Positive.mulStar, map_mul, map_star] rw [h₁, h₂, τ.tracial] lowerSemicontinuous := τ.lowerSemicontinuous.comp (((map_continuous f).comp continuous_subtype_val).subtype_mk _) end ExtendedTrace end TraceCone end section open scoped NNReal ENNReal Topology namespace TraceCone variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] instance : PartialOrder (MatrixLimit A) := CStarAlgebra.spectralOrder _ instance : StarOrderedRing (MatrixLimit A) := CStarAlgebra.spectralOrderedRing _ end TraceCone end namespace Pureness open Filter Topology variable (A : Type*) [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] lemma completedCornerCut_finite_range (k l : ℕ) (a : MatrixStage A l) : completedCornerCut A k (completedMatrixInclude A l a) ∈ Set.range (completedMatrixInclude A k) := by let m := max k l have hk : k ≤ m := le_max_left _ _ have hl : l ≤ m := le_max_right _ _ refine ⟨compress hk (corner hl a), ?_⟩ rw [completedCornerCut, completedProjection, ← completedMatrixInclude_corner A hk 1, ← completedMatrixInclude_corner A hl a, ← map_mul, ← map_mul, ← cornerProjection_eq hk, ← corner_compress, completedMatrixInclude_corner] theorem completedCornerCut_mem_range (k : ℕ) (a : CornerCompletion A) : completedCornerCut A k a ∈ Set.range (completedMatrixInclude A k) := by have hc : IsClosed {a : CornerCompletion A | completedCornerCut A k a ∈ Set.range (completedMatrixInclude A k)} := (completedMatrixInclude_isometry A k).isClosedEmbedding.isClosed_range.preimage (completedCornerCut_continuous A k) apply hc.closure_subset_iff.mpr ?_ (completedMatrixInclude_dense A a) intro b hb obtain ⟨l, c, rfl⟩ := Set.mem_iUnion.mp hb exact completedCornerCut_finite_range A k l c def completedCompress (k : ℕ) (a : CornerCompletion A) : MatrixStage A k := Classical.choose (completedCornerCut_mem_range A k a) @[simp] lemma include_completedCompress (k : ℕ) (a : CornerCompletion A) : completedMatrixInclude A k (completedCompress A k a) = completedCornerCut A k a := Classical.choose_spec (completedCornerCut_mem_range A k a) lemma completedCompress_continuous (k : ℕ) : Continuous (completedCompress A k) := by apply (completedMatrixInclude_isometry A k).isEmbedding.isInducing.continuous_iff.mpr simpa only [Function.comp_def, include_completedCompress] using completedCornerCut_continuous A k @[simp] lemma completedCompress_include (k : ℕ) (a : MatrixStage A k) : completedCompress A k (completedMatrixInclude A k a) = a := by apply (completedMatrixInclude_isometry A k).injective rw [include_completedCompress, completedCornerCut_fixes A le_rfl] end Pureness namespace Pureness open scoped ComplexOrder variable {A B : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] [NonUnitalCStarAlgebra B] [PartialOrder B] [StarOrderedRing B] theorem nonUnitalStarAlgHom_nonneg_iff (φ : A →⋆ₙₐ[ℂ] B) (hφ : Function.Injective φ) (a : A) : 0 ≤ φ a ↔ 0 ≤ a := by constructor · intro ha let s : NonUnitalStarSubalgebra ℂ B := NonUnitalStarAlgHom.range φ have hs : IsClosed (s : Set B) := (NonUnitalStarAlgHom.isometry φ hφ).isClosedEmbedding.isClosed_range let : IsClosed (s : Set B) := hs have hm : CFC.sqrt (φ a) ∈ s := by rw [CFC.sqrt_eq_nnrpow, CFC.nnrpow_eq_cfcₙ_real _ _ ha] exact cfcₙ_mem (𝕜' := ℂ) _ (NonUnitalStarAlgHom.mem_range_self φ a) obtain ⟨x, hx⟩ := (NonUnitalStarAlgHom.mem_range φ).mp hm have he : star x * x = a := hφ (by rw [map_mul, map_star, hx, (CFC.sqrt_nonneg (φ a)).star_eq, CFC.sqrt_mul_sqrt_self (φ a) ha]) rw [← he] exact star_mul_self_nonneg _ · intro ha have he : star (CFC.sqrt a) * CFC.sqrt a = a := by rw [(CFC.sqrt_nonneg a).star_eq, CFC.sqrt_mul_sqrt_self a ha] rw [← he, map_mul, map_star] exact star_mul_self_nonneg _ end Pureness namespace Pureness open scoped ComplexOrder ENNReal variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] variable {k l : ℕ} lemma matrixTrace_compress_le (τ : TracialState A) (h : k ≤ l) (a : MatrixStage A l) (ha : 0 ≤ a) : matrixTrace τ (compress h a) ≤ matrixTrace τ a := by rw [← matrixTrace_corner τ h, matrixTrace_apply, matrixTrace_apply] apply Finset.sum_le_sum intro i _ by_cases hi : i.val < k · simp [corner, compress, hi] · simp only [corner_row_zero h _ i i hi, map_zero] exact τ.functional.map_nonneg (matrix_entry_nonneg a ha i) lemma completedCompress_nonneg (k : ℕ) (a : CornerCompletion A) (ha : 0 ≤ a) : 0 ≤ completedCompress A k a := by apply (nonUnitalStarAlgHom_nonneg_iff (completedMatrixInclude A k) (completedMatrixInclude_isometry A k).injective _).mp rw [include_completedCompress] exact completedCornerCut_nonneg A k a ha lemma completedProjection_mul_le (h : k ≤ l) : completedProjection A k * completedProjection A l = completedProjection A k := by change completedMatrixInclude A k 1 * completedMatrixInclude A l 1 = _ rw [← completedMatrixInclude_corner A h 1, ← map_mul, mul_one, completedMatrixInclude_corner] rfl lemma completedProjection_mul_ge (h : k ≤ l) : completedProjection A l * completedProjection A k = completedProjection A k := by change completedMatrixInclude A l 1 * completedMatrixInclude A k 1 = _ rw [← completedMatrixInclude_corner A h 1, ← map_mul, one_mul, completedMatrixInclude_corner] rfl lemma completedCornerCut_nested (h : k ≤ l) (a : CornerCompletion A) : completedCornerCut A k (completedCornerCut A l a) = completedCornerCut A k a := by dsimp [completedCornerCut] calc _ = (completedProjection A k * completedProjection A l) * a * (completedProjection A l * completedProjection A k) := by simp only [mul_assoc] _ = _ := by rw [completedProjection_mul_le h, completedProjection_mul_ge h] lemma completedCornerCut_include (h : k ≤ l) (a : MatrixStage A l) : completedCornerCut A k (completedMatrixInclude A l a) = completedMatrixInclude A k (compress h a) := by rw [completedCornerCut, completedProjection, ← completedMatrixInclude_corner A h 1, ← map_mul, ← map_mul, ← cornerProjection_eq h, ← corner_compress, completedMatrixInclude_corner] theorem completedCompress_compat (h : k ≤ l) (a : CornerCompletion A) : compress h (completedCompress A l a) = completedCompress A k a := by apply (completedMatrixInclude_isometry A k).injective rw [← completedCornerCut_include, include_completedCompress, completedCornerCut_nested h, include_completedCompress] lemma completedCompression_trace_monotone (τ : TracialState A) (a : CornerCompletion A) (ha : 0 ≤ a) : Monotone (fun k : ℕ => matrixTrace τ (completedCompress A k a)) := by intro k l h dsimp only rw [← completedCompress_compat h a] exact matrixTrace_compress_le τ h _ (completedCompress_nonneg l a ha) end Pureness namespace Pureness open Filter Topology open scoped ComplexOrder ENNReal variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] lemma completedCornerCut_add (k : ℕ) (a b : CornerCompletion A) : completedCornerCut A k (a + b) = completedCornerCut A k a + completedCornerCut A k b := by simp only [completedCornerCut, mul_add, add_mul] lemma completedCornerCut_smul (k : ℕ) (z : ℂ) (a : CornerCompletion A) : completedCornerCut A k (z • a) = z • completedCornerCut A k a := by simp only [completedCornerCut, mul_smul_comm, smul_mul_assoc] def completedCompressLinear (k : ℕ) : CornerCompletion A →ₗ[ℂ] MatrixStage A k where toFun := completedCompress A k map_add' a b := by apply (completedMatrixInclude_isometry A k).injective rw [include_completedCompress, map_add, include_completedCompress, include_completedCompress, completedCornerCut_add] map_smul' z a := by apply (completedMatrixInclude_isometry A k).injective simp only [map_smul, include_completedCompress, completedCornerCut_smul] rfl lemma completedCompress_mono (k : ℕ) : Monotone (completedCompress A k) := by intro a b hab apply sub_nonneg.mp change 0 ≤ completedCompressLinear k b - completedCompressLinear k a rw [← map_sub] exact completedCompress_nonneg k (b - a) (sub_nonneg.mpr hab) lemma completedCompress_include_of_le {k l : ℕ} (h : k ≤ l) (a : MatrixStage A k) : completedCompress A l (completedMatrixInclude A k a) = corner h a := by apply (completedMatrixInclude_isometry A l).injective rw [include_completedCompress, completedCornerCut_fixes A h, completedMatrixInclude_corner] def completedTraceValue (τ : TracialState A) (k : ℕ) (a : CornerCompletion A) : ℝ≥0∞ := ENNReal.ofReal (matrixTrace τ (completedCompress A k a)).re def completedDiagonalWeight (τ : TracialState A) (a : CornerCompletion A) : ℝ≥0∞ := ⨆ k : ℕ, completedTraceValue τ k a lemma completedTraceValue_continuous (τ : TracialState A) (k : ℕ) : Continuous (completedTraceValue τ k) := ENNReal.continuous_ofReal.comp (Complex.continuous_re.comp ((map_continuous (matrixTrace τ)).comp (completedCompress_continuous A k))) lemma completedTraceValue_mono (τ : TracialState A) (k : ℕ) : Monotone (completedTraceValue τ k) := by intro a b hab apply ENNReal.ofReal_le_ofReal exact (Complex.le_def.mp ((matrixTrace τ).monotone (completedCompress_mono k hab))).1 lemma completedTraceValue_monotone (τ : TracialState A) (a : CornerCompletion A) (ha : 0 ≤ a) : Monotone (fun k => completedTraceValue τ k a) := by intro k l h apply ENNReal.ofReal_le_ofReal exact (Complex.le_def.mp (completedCompression_trace_monotone τ a ha h)).1 lemma completedDiagonalWeight_tendsto (τ : TracialState A) (a : CornerCompletion A) (ha : 0 ≤ a) : Tendsto (fun k : ℕ => completedTraceValue τ k a) atTop (𝓝 (completedDiagonalWeight τ a)) := tendsto_atTop_iSup (completedTraceValue_monotone τ a ha) lemma completedDiagonalWeight_mono (τ : TracialState A) : Monotone (completedDiagonalWeight τ) := by intro a b hab exact iSup_mono fun k => completedTraceValue_mono τ k hab lemma completedTraceValue_add (τ : TracialState A) (k : ℕ) (a b : CornerCompletion A) (ha : 0 ≤ a) (hb : 0 ≤ b) : completedTraceValue τ k (a + b) = completedTraceValue τ k a + completedTraceValue τ k b := by have hca : 0 ≤ (matrixTrace τ (completedCompress A k a)).re := (Complex.nonneg_iff.mp ((matrixTrace τ).map_nonneg (completedCompress_nonneg k a ha))).1 have hcb : 0 ≤ (matrixTrace τ (completedCompress A k b)).re := (Complex.nonneg_iff.mp ((matrixTrace τ).map_nonneg (completedCompress_nonneg k b hb))).1 change ENNReal.ofReal (matrixTrace τ (completedCompressLinear k (a + b))).re = _ rw [map_add, map_add, Complex.add_re] exact ENNReal.ofReal_add hca hcb theorem completedDiagonalWeight_add (τ : TracialState A) (a b : CornerCompletion A) (ha : 0 ≤ a) (hb : 0 ≤ b) : completedDiagonalWeight τ (a + b) = completedDiagonalWeight τ a + completedDiagonalWeight τ b := by apply tendsto_nhds_unique (completedDiagonalWeight_tendsto τ (a + b) (add_nonneg ha hb)) convert (completedDiagonalWeight_tendsto τ a ha).add (completedDiagonalWeight_tendsto τ b hb) using 1 funext k exact completedTraceValue_add τ k a b ha hb theorem completedDiagonalWeight_include (τ : TracialState A) (l : ℕ) (a : MatrixStage A l) (ha : 0 ≤ a) : completedDiagonalWeight τ (completedMatrixInclude A l a) = ENNReal.ofReal (matrixTrace τ a).re := by apply le_antisymm · apply iSup_le intro k have hmono := completedTraceValue_monotone τ (completedMatrixInclude A l a) (completedMatrixInclude_nonneg A l a ha) (le_max_left k l) refine hmono.trans_eq ?_ unfold completedTraceValue dsimp only rw [completedCompress_include_of_le (le_max_right k l), matrixTrace_corner] · have ht := le_iSup (fun k => completedTraceValue τ k (completedMatrixInclude A l a)) l simpa only [completedDiagonalWeight, completedTraceValue, completedCompress_include] using ht theorem completedDiagonalWeight_le_of_tendsto (τ : TracialState A) {a : ℕ → CornerCompletion A} {b : CornerCompletion A} {r : ℝ≥0∞} (ht : Tendsto a atTop (𝓝 b)) (hr : ∀ n, completedDiagonalWeight τ (a n) ≤ r) : completedDiagonalWeight τ b ≤ r := by apply iSup_le intro k apply le_of_tendsto ((completedTraceValue_continuous τ k).continuousAt.tendsto.comp ht) exact Eventually.of_forall fun n => (le_iSup (fun k => completedTraceValue τ k (a n)) k).trans (hr n) lemma completedDiagonalWeight_cut (τ : TracialState A) (k : ℕ) (a : CornerCompletion A) (ha : 0 ≤ a) : completedDiagonalWeight τ (completedCornerCut A k a) = completedTraceValue τ k a := by rw [← include_completedCompress, completedDiagonalWeight_include τ k _ (completedCompress_nonneg k a ha)] rfl lemma completedDiagonalWeight_cut_le (τ : TracialState A) (k : ℕ) (a : CornerCompletion A) (ha : 0 ≤ a) : completedDiagonalWeight τ (completedCornerCut A k a) ≤ completedDiagonalWeight τ a := by rw [completedDiagonalWeight_cut τ k a ha] exact le_iSup (fun k => completedTraceValue τ k a) k lemma completedProjection_conjugate_le (k : ℕ) (x : CornerCompletion A) : x * completedProjection A k * star x ≤ x * star x := by have hq := completedProjection_mul_le (A := A) (k := k) le_rfl have he : (x - x * completedProjection A k) * star (x - x * completedProjection A k) = x * star x - x * completedProjection A k * star x := by simp only [star_sub, star_mul, completedProjection_star, sub_mul, mul_sub, mul_assoc] rw [← mul_assoc (completedProjection A k) (completedProjection A k), hq] noncomm_ring exact sub_nonneg.mp (he ▸ mul_star_self_nonneg (x - x * completedProjection A k)) lemma completedCornerCut_mono (k : ℕ) : Monotone (completedCornerCut A k) := by intro a b hab simpa only [completedCornerCut, completedProjection_star] using star_left_conjugate_le_conjugate hab (completedProjection A k) lemma completedCornerCut_mul_star_le (k : ℕ) (x : CornerCompletion A) : completedCornerCut A k x * star (completedCornerCut A k x) ≤ completedCornerCut A k (x * star x) := by have he : completedCornerCut A k x * star (completedCornerCut A k x) = completedCornerCut A k (x * completedProjection A k * star x) := by simp only [completedCornerCut, star_mul, completedProjection_star, mul_assoc] rw [← mul_assoc (completedProjection A k) (completedProjection A k), completedProjection_mul_le le_rfl] rw [he] exact completedCornerCut_mono k (completedProjection_conjugate_le k x) lemma completedDiagonalWeight_finite_polar (τ : TracialState A) (k : ℕ) (x : MatrixStage A k) : completedDiagonalWeight τ (star (completedMatrixInclude A k x) * completedMatrixInclude A k x) = completedDiagonalWeight τ (completedMatrixInclude A k x * star (completedMatrixInclude A k x)) := by rw [← map_star, ← map_mul, ← map_mul, completedDiagonalWeight_include τ k _ (star_mul_self_nonneg _), completedDiagonalWeight_include τ k _ (mul_star_self_nonneg _), matrixTrace_tracial] lemma completedDiagonalWeight_star_mul_le (τ : TracialState A) (x : CornerCompletion A) : completedDiagonalWeight τ (star x * x) ≤ completedDiagonalWeight τ (x * star x) := by have ht := completedCornerCut_tendsto A x apply completedDiagonalWeight_le_of_tendsto τ (ht.star.mul ht) intro k rw [← include_completedCompress, completedDiagonalWeight_finite_polar, include_completedCompress] exact (completedDiagonalWeight_mono τ (completedCornerCut_mul_star_le k x)).trans (completedDiagonalWeight_cut_le τ k (x * star x) (mul_star_self_nonneg x)) theorem completedDiagonalWeight_tracial (τ : TracialState A) (x : CornerCompletion A) : completedDiagonalWeight τ (star x * x) = completedDiagonalWeight τ (x * star x) := by apply le_antisymm (completedDiagonalWeight_star_mul_le τ x) simpa only [star_star] using completedDiagonalWeight_star_mul_le τ (star x) end Pureness namespace Pureness open scoped ComplexOrder ENNReal variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] lemma completedTraceValue_smul (τ : TracialState A) (k : ℕ) (s : ℝ) (hs : 0 ≤ s) (a : CornerCompletion A) : completedTraceValue τ k (s • a) = ENNReal.ofReal s * completedTraceValue τ k a := by change ENNReal.ofReal (matrixTrace τ (completedCompressLinear k (s • a))).re = _ rw [(completedCompressLinear (A := A) k).map_smul_of_tower, (matrixTrace τ).map_smul_of_tower, Complex.smul_re, smul_eq_mul, ENNReal.ofReal_mul hs] rfl lemma completedDiagonalWeight_smul (τ : TracialState A) (s : ℝ) (hs : 0 ≤ s) (a : CornerCompletion A) : completedDiagonalWeight τ (s • a) = ENNReal.ofReal s * completedDiagonalWeight τ a := by simp only [completedDiagonalWeight, completedTraceValue_smul τ _ s hs, ENNReal.mul_iSup] @[simp] lemma completedDiagonalWeight_zero (τ : TracialState A) : completedDiagonalWeight τ 0 = 0 := by have h := completedDiagonalWeight_smul τ 0 le_rfl (0 : CornerCompletion A) simpa only [zero_smul, ENNReal.ofReal_zero, zero_mul] using h end Pureness namespace Pureness open Filter Topology open scoped ComplexOrder ENNReal NNReal variable {A B : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] [NonUnitalCStarAlgebra B] [PartialOrder B] [StarOrderedRing B] noncomputable def nonUnitalNormalize (a : A) : A := ‖a‖⁻¹ • a noncomputable def nonUnitalRoot (a : A) (j : ℕ) : A := CFC.nnrpow (nonUnitalNormalize a) (((j : ℝ≥0) + 1)⁻¹) end Pureness namespace Pureness open Filter Topology open scoped ComplexOrder ENNReal NNReal variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def completedRootRank (τ : TracialState A) (a : CornerCompletion A) : ℝ≥0∞ := ⨆ n : ℕ, completedDiagonalWeight τ (nonUnitalRoot a n) end Pureness namespace Pureness namespace CStarAlgebraNorm variable {R : Type*} [Ring R] [StarRing R] [Algebra ℂ R] abbrev normedRing (p : CStarAlgebraNorm R) : NormedRing R := p.toAlgebraNorm.toRingNorm.toNormedRing @[instance_reducible] def normedAlgebra (p : CStarAlgebraNorm R) : letI := p.normedRing NormedAlgebra ℂ R := by letI := p.normedRing exact ⟨fun c x => (p.toAlgebraNorm.smul' c x).le⟩ theorem cstarRing (p : CStarAlgebraNorm R) : letI := p.normedRing CStarRing R := by let := p.normedRing exact ⟨fun x => (p.cstar x).ge⟩ end CStarAlgebraNorm end Pureness namespace DirectComparison open Pureness CurrentMain Filter open scoped Topology ComplexOrder def StrictComparison (A : Type*) [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] : Prop := ∀ (a b : CornerCompletion A), 0 ≤ a → 0 ≤ b → b ≠ 0 → (∀ τ : TracialState A, completedRootRank τ a < completedRootRank τ b) → CuntzSubequiv a b def UniformGamma (A : Type) [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] [Nontrivial A] [Nonempty (TracialState A)] (U : Ultrafilter ℕ) : Prop := ∀ m : ℕ, 0 < m → ∃ p : Fin m → FamilyUltrapower (fun t : TracialState A => t) U, (∀ i, IsStarProjection (p i)) ∧ (∑ i, p i)=1 ∧ (∀ i (a : A), Commute (p i) (familyUltrapowerMap (fun t : TracialState A => t) U a)) ∧ ∀ i (a : A) (s : ℕ → TracialState A), (familyLimitTrace (fun t : TracialState A => t) U s).functional (familyUltrapowerMap (fun t : TracialState A => t) U a*p i) = (1/(m:ℂ))*(familyLimitTrace (fun t : TracialState A => t) U s).functional (familyUltrapowerMap (fun t : TracialState A => t) U a) end DirectComparison namespace DirectPacking open Pureness CurrentMain open scoped ComplexOrder class TraceFamily (D : Type*) [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] where carrier : Set (TracialState D) abbrev RestrictedTracialState (D : Type*) [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] [TraceFamily D] := {τ : TracialState D // τ ∈ TraceFamily.carrier (D := D)} end DirectPacking namespace DirectPacking open Pureness CurrentMain open scoped ComplexOrder namespace RestrictedTracialState variable {D : Type*} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] [TraceFamily D] abbrev functional (τ : RestrictedTracialState D) := τ.val.functional lemma normalized (τ : RestrictedTracialState D) : τ.functional 1=1 := τ.val.normalized lemma tracial (τ : RestrictedTracialState D) (a b : D) : τ.functional (a*b)=τ.functional (b*a) := τ.val.tracial a b end RestrictedTracialState end DirectPacking namespace NonunitalGamma open Filter Topology open scoped ComplexOrder InnerProductSpace variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def positiveFunctionalCLM (f : A →ₚ[ℂ] ℂ) : A →L[ℂ] ℂ := ⟨f.toLinearMap,map_continuous f⟩ structure NormalizedTrace (A : Type*) [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] where functional : A →ₚ[ℂ] ℂ norm_one : ‖positiveFunctionalCLM functional‖ = 1 tracial : ∀ a b : A, functional (a*b)=functional (b*a) lemma positiveFunctional_cauchy_schwarz (f : A →ₚ[ℂ] ℂ) (a b : A) : ‖f (star a*b)‖ ≤ Real.sqrt (f (star a*a)).re * Real.sqrt (f (star b*b)).re := by simpa only [PositiveLinearMap.preGNS_inner_def,PositiveLinearMap.preGNS_norm_def, PositiveLinearMap.ofPreGNS_toPreGNS] using norm_inner_le_norm (𝕜 := ℂ) (f.toPreGNS a) (f.toPreGNS b) lemma positiveFunctional_norm_le_sqrt (f : A →ₚ[ℂ] ℂ) (hf : ‖positiveFunctionalCLM f‖ ≤ 1) (a : A) : ‖f a‖ ≤ Real.sqrt (f (star a*a)).re := by have hu := CStarAlgebra.increasingApproximateUnit A have ht : Tendsto (fun e : A => ‖f (e*a)‖) (CStarAlgebra.approximateUnit A) (𝓝 ‖f a‖) := (map_continuous f).norm.tendsto a |>.comp (hu.tendsto_mul_right a) apply le_of_tendsto ht filter_upwards [hu.eventually_nonneg,hu.eventually_norm] with e he hen have hfe : (f (star e*e)).re ≤ 1 := by have h := (positiveFunctionalCLM f).le_opNorm (star e*e) have hn : ‖star e*e‖ ≤ 1 := (norm_mul_le _ _).trans (by simpa using mul_le_mul hen hen (norm_nonneg _) zero_le_one) exact (Complex.re_le_norm _).trans (h.trans (by nlinarith [norm_nonneg (positiveFunctionalCLM f),norm_nonneg (star e*e)])) have hs : Real.sqrt (f (star e*e)).re ≤ 1 := by exact (Real.sqrt_le_iff).mpr ⟨zero_le_one,by simpa using hfe⟩ calc ‖f (e*a)‖ = ‖f (star e*a)‖ := by rw [he.isSelfAdjoint.star_eq] _ ≤ Real.sqrt (f (star e*e)).re * Real.sqrt (f (star a*a)).re := positiveFunctional_cauchy_schwarz f e a _ ≤ Real.sqrt (f (star a*a)).re := by nlinarith [Real.sqrt_nonneg (f (star a*a)).re] lemma positiveFunctional_norm_sq_le (f : A →ₚ[ℂ] ℂ) (hf : ‖positiveFunctionalCLM f‖ ≤ 1) (a : A) : ‖f a‖^2 ≤ (f (star a*a)).re := by have h := positiveFunctional_norm_le_sqrt f hf a have hpos : 0 ≤ (f (star a*a)).re := (f.map_nonneg (star_mul_self_nonneg a)).1 nlinarith [Real.sq_sqrt hpos, norm_nonneg (f a), Real.sqrt_nonneg (f (star a*a)).re] def unitizedFunctionalLinear (f : A →ₚ[ℂ] ℂ) : Unitization ℂ A →ₗ[ℂ] ℂ where toFun x := x.fst + f x.snd map_add' x y := by simp only [Unitization.fst_add,Unitization.snd_add,map_add]; ring map_smul' z x := by simp only [Unitization.fst_smul,Unitization.snd_smul,map_smul,smul_eq_mul,RingHom.id_apply]; ring lemma unitizedFunctional_star_square (f : A →ₚ[ℂ] ℂ) (hf : ‖positiveFunctionalCLM f‖ ≤ 1) (x : Unitization ℂ A) : 0 ≤ unitizedFunctionalLinear f (star x*x) := by have ha := positiveFunctional_norm_sq_le f hf x.snd have hp := f.map_nonneg (star_mul_self_nonneg x.snd) have hi : (f (star x.snd*x.snd)).im=0 := (Complex.nonneg_iff.mp hp).2.symm change 0 ≤ (star x*x).fst + f (star x*x).snd simp only [Unitization.fst_mul, Unitization.fst_star,Unitization.snd_mul, Unitization.snd_star,map_add,map_smul,map_star,smul_eq_mul] apply Complex.nonneg_iff.mpr constructor · have hn := Complex.normSq_nonneg (x.fst+f x.snd) rw [Complex.normSq_eq_norm_sq] at hn have hn' : 0 ≤ Complex.normSq (x.fst+f x.snd) := Complex.normSq_nonneg _ simp only [Complex.normSq_apply,Complex.add_re,Complex.add_im] at hn' rw [← Complex.normSq_eq_norm_sq,Complex.normSq_apply] at ha simp only [Complex.add_re,Complex.mul_re,Complex.star_def,Complex.conj_re,Complex.conj_im] nlinarith · simp only [Complex.add_im,Complex.mul_im,Complex.star_def,Complex.conj_re,Complex.conj_im,hi] ring def unitizedFunctional (f : A →ₚ[ℂ] ℂ) (hf : ‖positiveFunctionalCLM f‖ ≤ 1) : Unitization ℂ A →ₚ[ℂ] ℂ where toLinearMap := unitizedFunctionalLinear f monotone' := by intro x y hxy have h := (CStarAlgebra.nonneg_iff_eq_star_mul_self).mp (sub_nonneg.mpr hxy) obtain ⟨z,hz⟩ := h have hp := unitizedFunctional_star_square f hf z rw [←hz,map_sub,sub_nonneg] at hp exact hp @[simp] lemma unitizedFunctional_one (f : A →ₚ[ℂ] ℂ) (hf : ‖positiveFunctionalCLM f‖ ≤ 1) : unitizedFunctional f hf 1=1 := by change 1+f 0=1 simp only [map_zero,add_zero] lemma unitizedFunctional_tracial (τ : NormalizedTrace A) (x y : Unitization ℂ A) : unitizedFunctional τ.functional τ.norm_one.le (x*y)= unitizedFunctional τ.functional τ.norm_one.le (y*x) := by change (x*y).fst+τ.functional (x*y).snd=(y*x).fst+τ.functional (y*x).snd simp only [Unitization.fst_mul,Unitization.snd_mul,map_add,map_smul,smul_eq_mul] rw [τ.tracial x.snd y.snd] ring end NonunitalGamma namespace NonunitalGamma open Filter Topology open scoped ComplexOrder variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def NormalizedTrace.toWeakDual (τ : NormalizedTrace A) : WeakDual ℂ A := StrongDual.toWeakDual (positiveFunctionalCLM τ.functional) instance : TopologicalSpace (NormalizedTrace A) := TopologicalSpace.induced NormalizedTrace.toWeakDual inferInstance end NonunitalGamma namespace NonunitalGamma open Pureness CurrentMain Filter Topology open scoped ComplexOrder ENNReal variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def NormalizedTrace.unitized (τ : NormalizedTrace A) : TracialState (Unitization ℂ A) where functional := unitizedFunctional τ.functional τ.norm_one.le normalized := unitizedFunctional_one _ _ tracial := unitizedFunctional_tracial τ end NonunitalGamma namespace NonunitalGamma open TraceCone open scoped ENNReal NNReal ComplexOrder ComplexStarModule variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def WeightBounded (τ : ExtendedTrace A) : Prop := ∃ C : ℝ≥0, ∀ a : Positive A, ‖a.1‖ ≤ 1 → τ a ≤ (C : ℝ≥0∞) def WeightDenselyFinite (τ : ExtendedTrace A) : Prop := Dense {a : Positive A | τ a < ∞} lemma weightBounded_finite {τ : ExtendedTrace A} (hτ : WeightBounded τ) (a : Positive A) : τ a ≠ ∞ := by obtain ⟨C,hC⟩ := hτ let r : ℝ≥0 := ‖a.1‖₊+1 have hr : r ≠ 0 := ne_of_gt (by dsimp [r]; positivity) have he : Positive.smul r (Positive.smul r⁻¹ a)=a := by apply Subtype.ext change (r:ℝ) • ((r⁻¹:ℝ≥0):ℝ) • a.1=a.1 rw [NNReal.coe_inv,smul_smul,mul_inv_cancel₀ (by exact_mod_cast hr),one_smul] have hn : ‖(Positive.smul r⁻¹ a).1‖ ≤ 1 := by change ‖((r⁻¹:ℝ≥0):ℝ) • a.1‖ ≤ 1 rw [norm_smul,NNReal.coe_inv,Real.norm_eq_abs,abs_of_nonneg (by positivity)] apply (inv_mul_le_iff₀ (by exact_mod_cast (pos_iff_ne_zero.mpr hr))).mpr dsimp [r] linarith have hf : τ (Positive.smul r⁻¹ a) ≠ ∞ := ne_top_of_le_ne_top ENNReal.coe_ne_top (hC _ hn) rw [←he,τ.map_smul] exact ENNReal.mul_ne_top ENNReal.coe_ne_top hf end NonunitalGamma namespace NonunitalGamma open TraceCone open scoped ENNReal NNReal ComplexOrder ComplexStarModule variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] namespace ExtendedTraceExtension variable (τ : ExtendedTrace A) (hfinite : ∀ a, τ a ≠ ∞) def value (a : Positive A) : ℝ := (τ a).toReal lemma value_nonneg (a : Positive A) : 0 ≤ value τ a := ENNReal.toReal_nonneg lemma value_zero : value τ Positive.zero=0 := by simp [value,τ.map_zero] include hfinite in lemma value_add (a b : Positive A) : value τ (Positive.add a b)=value τ a+value τ b := by exact (congrArg ENNReal.toReal (τ.map_add a b)).trans (ENNReal.toReal_add (hfinite a) (hfinite b)) lemma value_smul (r : ℝ≥0) (a : Positive A) : value τ (Positive.smul r a)=(r:ℝ)*value τ a := by simp only [value,τ.map_smul,ENNReal.toReal_mul,ENNReal.coe_toReal] def selfAdjointValue (a : selfAdjoint A) : ℝ := value τ ⟨a.1⁺,CFC.posPart_nonneg _⟩-value τ ⟨a.1⁻,CFC.negPart_nonneg _⟩ include hfinite in lemma selfAdjointValue_sub (a : selfAdjoint A) (p q : Positive A) (hpq : a.1=p.1-q.1) : selfAdjointValue τ a=value τ p-value τ q := by have hb : Positive.add ⟨a.1⁺,CFC.posPart_nonneg _⟩ q= Positive.add p ⟨a.1⁻,CFC.negPart_nonneg _⟩ := by apply Subtype.ext exact sub_eq_sub_iff_add_eq_add.mp ((CFC.posPart_sub_negPart a.1 a.2).trans hpq) have hv := congrArg (value τ) hb rw [value_add τ hfinite,value_add τ hfinite] at hv unfold selfAdjointValue linarith include hfinite in lemma selfAdjointValue_add (a b : selfAdjoint A) : selfAdjointValue τ (a+b)=selfAdjointValue τ a+selfAdjointValue τ b := by let p := Positive.add (⟨a.1⁺,CFC.posPart_nonneg _⟩ : Positive A) ⟨b.1⁺,CFC.posPart_nonneg _⟩ let q := Positive.add (⟨a.1⁻,CFC.negPart_nonneg _⟩ : Positive A) ⟨b.1⁻,CFC.negPart_nonneg _⟩ have hrep : (a+b).1=p.1-q.1 := by change a.1+b.1=(a.1⁺+b.1⁺)-(a.1⁻+b.1⁻) rw [add_sub_add_comm,CFC.posPart_sub_negPart _ a.2,CFC.posPart_sub_negPart _ b.2] rw [selfAdjointValue_sub τ hfinite (a+b) p q hrep] dsimp [p,q] rw [value_add τ hfinite,value_add τ hfinite] unfold selfAdjointValue ring include hfinite in lemma selfAdjointValue_smul_nonneg (r : ℝ≥0) (a : selfAdjoint A) : selfAdjointValue τ ((r:ℝ) • a)=(r:ℝ)*selfAdjointValue τ a := by rw [selfAdjointValue_sub τ hfinite ((r:ℝ) • a) (Positive.smul r ⟨a.1⁺,CFC.posPart_nonneg _⟩) (Positive.smul r ⟨a.1⁻,CFC.negPart_nonneg _⟩) (by change (r:ℝ) • a.1=(r:ℝ) • a.1⁺-(r:ℝ) • a.1⁻ rw [←smul_sub,CFC.posPart_sub_negPart _ a.2])] rw [value_smul,value_smul] unfold selfAdjointValue ring lemma selfAdjointValue_neg (a : selfAdjoint A) : selfAdjointValue τ (-a) = -selfAdjointValue τ a := by unfold selfAdjointValue change value τ ⟨(-a.1)⁺,_⟩-value τ ⟨(-a.1)⁻,_⟩ = -(value τ ⟨a.1⁺,_⟩-value τ ⟨a.1⁻,_⟩) simp only [CFC.posPart_neg,CFC.negPart_neg] ring include hfinite in lemma selfAdjointValue_smul (r : ℝ) (a : selfAdjoint A) : selfAdjointValue τ (r • a)=r*selfAdjointValue τ a := by by_cases hr : 0 ≤ r · exact selfAdjointValue_smul_nonneg τ hfinite ⟨r,hr⟩ a · have he := selfAdjointValue_smul_nonneg τ hfinite ⟨-r,by linarith⟩ a change selfAdjointValue τ ((-r) • a)=(-r)*selfAdjointValue τ a at he rw [neg_smul,selfAdjointValue_neg] at he linarith include hfinite in lemma selfAdjointValue_positive (a : Positive A) : selfAdjointValue τ ⟨a.1,a.2.isSelfAdjoint⟩=value τ a := by have he := selfAdjointValue_sub τ hfinite ⟨a.1,a.2.isSelfAdjoint⟩ a Positive.zero (by simp [Positive.zero]) simpa only [value_zero,sub_zero] using he def realLinear : selfAdjoint A →ₗ[ℝ] ℝ where toFun := selfAdjointValue τ map_add' := selfAdjointValue_add τ hfinite map_smul' r a := selfAdjointValue_smul τ hfinite r a def complexLinear : A →ₗ[ℂ] ℂ where toFun x := (realLinear τ hfinite (ℜ x):ℂ)+Complex.I*(realLinear τ hfinite (ℑ x):ℂ) map_add' x y := by simp only [map_add,Complex.ofReal_add];ring map_smul' z x := by simp only [realPart_smul,imaginaryPart_smul,map_sub,map_add,_root_.map_smul, RingHom.id_apply,smul_eq_mul,Complex.ofReal_sub,Complex.ofReal_add,Complex.ofReal_mul] apply Complex.ext <;> simp lemma complexLinear_positive (a : Positive A) : complexLinear τ hfinite a.1=(value τ a:ℂ) := by change (realLinear τ hfinite (ℜ a.1):ℂ)+Complex.I*(realLinear τ hfinite (ℑ a.1):ℂ)=_ rw [a.2.isSelfAdjoint.imaginaryPart,map_zero,Complex.ofReal_zero,mul_zero,add_zero] congr 1 change selfAdjointValue τ (ℜ a.1)=value τ a rw [show ℜ a.1=⟨a.1,a.2.isSelfAdjoint⟩ from Subtype.ext a.2.isSelfAdjoint.coe_realPart] exact selfAdjointValue_positive τ hfinite a def functional : A →ₚ[ℂ] ℂ := PositiveLinearMap.mk₀ (complexLinear τ hfinite) (by intro a ha rw [complexLinear_positive τ hfinite ⟨a,ha⟩] exact_mod_cast value_nonneg τ ⟨a,ha⟩) @[simp] lemma functional_positive (a : Positive A) : functional τ hfinite a.1=(τ a).toReal := complexLinear_positive τ hfinite a omit [PartialOrder A] [StarOrderedRing A] in lemma linearMap_tracial_of_star_mul (f : A →ₗ[ℂ] ℂ) (h : ∀ a : A, f (star a*a)=f (a*star a)) : ∀ a b : A, f (a*b)=f (b*a) := by intro a b have h₁ := h (star a+b) have h₂ := h (star a+Complex.I • b) simp only [star_add,star_star,add_mul,mul_add,map_add] at h₁ simp only [star_add,star_star,star_smul,Complex.star_def,Complex.conj_I, add_mul,mul_add,smul_mul_assoc,mul_smul_comm,map_add,map_smul] at h₂ simp only [smul_eq_mul] at h₂ have ha := h (star a) have hb := h b simp only [star_star] at ha linear_combination (norm := ring_nf) (h₁-ha-hb-Complex.I*(h₂-ha-hb))/2 simp [Complex.I_sq] lemma functional_tracial (a b : A) : functional τ hfinite (a*b)=functional τ hfinite (b*a) := by apply linearMap_tracial_of_star_mul (complexLinear τ hfinite) _ a b intro x exact (complexLinear_positive τ hfinite (Positive.starMul x)).trans ((congrArg (fun r : ℝ≥0∞ => (r.toReal:ℂ)) (τ.tracial x)).trans (complexLinear_positive τ hfinite (Positive.mulStar x)).symm) end ExtendedTraceExtension end NonunitalGamma namespace NonunitalGamma open TraceCone open scoped ENNReal NNReal ComplexOrder ComplexStarModule variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def boundedWeightFunctional (τ : ExtendedTrace A) (hτ : WeightBounded τ) : A →ₚ[ℂ] ℂ := ExtendedTraceExtension.functional τ (weightBounded_finite hτ) lemma boundedWeightFunctional_tracial (τ : ExtendedTrace A) (hτ : WeightBounded τ) (a b : A) : boundedWeightFunctional τ hτ (a*b)=boundedWeightFunctional τ hτ (b*a) := ExtendedTraceExtension.functional_tracial τ (weightBounded_finite hτ) a b end NonunitalGamma namespace NonunitalGamma open TraceCone open scoped ENNReal NNReal ComplexOrder variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def scaleFunctional (r : ℝ≥0) (f : A →ₚ[ℂ] ℂ) : A →ₚ[ℂ] ℂ := PositiveLinearMap.mk₀ ((r:ℂ) • f.toLinearMap) (by intro a ha change 0 ≤ (r:ℂ)*f a exact mul_nonneg (by exact_mod_cast r.2) (f.map_nonneg ha)) @[simp] lemma scaleFunctional_apply (r : ℝ≥0) (f : A →ₚ[ℂ] ℂ) (a : A) : scaleFunctional r f a=(r:ℂ)*f a := rfl lemma positiveFunctionalCLM_scale (r : ℝ≥0) (f : A →ₚ[ℂ] ℂ) : positiveFunctionalCLM (scaleFunctional r f)=(r:ℂ) • positiveFunctionalCLM f := by ext a rfl lemma scaleFunctional_norm (r : ℝ≥0) (f : A →ₚ[ℂ] ℂ) : ‖positiveFunctionalCLM (scaleFunctional r f)‖=(r:ℝ)*‖positiveFunctionalCLM f‖ := by rw [positiveFunctionalCLM_scale,norm_smul] congr 1 exact_mod_cast (show ‖(r:ℝ)‖=(r:ℝ) from Real.norm_of_nonneg r.2) lemma boundedWeightFunctional_nonzero {τ : ExtendedTrace A} (hτ : WeightBounded τ) (hne : τ ≠ 0) : positiveFunctionalCLM (boundedWeightFunctional τ hτ) ≠ 0 := by intro hz apply hne apply ExtendedTrace.ext intro a have he := congrArg (fun f : A →L[ℂ] ℂ => f a.1) hz change boundedWeightFunctional τ hτ a.1=0 at he rw [show boundedWeightFunctional τ hτ a.1=((τ a).toReal:ℂ) from ExtendedTraceExtension.functional_positive τ (weightBounded_finite hτ) a] at he have hr : (τ a).toReal=0 := by exact_mod_cast he exact (ENNReal.toReal_eq_zero_iff (τ a)).mp hr |>.resolve_right (weightBounded_finite hτ a) def normalizedWeight (τ : ExtendedTrace A) (hτ : WeightBounded τ) (hne : τ ≠ 0) : NormalizedTrace A where functional := scaleFunctional (‖positiveFunctionalCLM (boundedWeightFunctional τ hτ)‖₊⁻¹) (boundedWeightFunctional τ hτ) norm_one := by rw [scaleFunctional_norm,NNReal.coe_inv,coe_nnnorm,inv_mul_cancel₀] exact norm_ne_zero_iff.mpr (boundedWeightFunctional_nonzero hτ hne) tracial a b := by simp only [scaleFunctional_apply,boundedWeightFunctional_tracial τ hτ a b] end NonunitalGamma namespace NonunitalGamma open Pureness CurrentMain Filter Topology open scoped ComplexOrder variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def TopologicallySimple (A : Type*) [NonUnitalNormedRing A] : Prop := ∀ I : TwoSidedIdeal A, IsClosed (I : Set A) → I=⊥ ∨ I=⊤ end NonunitalGamma namespace NonunitalGamma open Filter Topology variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] open ComplexStarModule open scoped ComplexOrder CStarAlgebra def Projectionless (A : Type*) [NonUnitalCStarAlgebra A] : Prop := ∀ p : A, IsStarProjection p → p=0 end NonunitalGamma section open scoped CStarAlgebra namespace Pureness open Filter Topology TraceCone open scoped ENNReal NNReal variable {A : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def completedExtendedTrace (τ : TracialState A) : ExtendedTrace (CornerCompletion A) where toFun a := completedDiagonalWeight τ a.1 map_zero := completedDiagonalWeight_zero τ map_add a b := completedDiagonalWeight_add τ a.1 b.1 a.2 b.2 map_smul r a := by simpa only [Positive.smul, ENNReal.ofReal_coe_nnreal] using completedDiagonalWeight_smul τ (r : ℝ) r.2 a.1 tracial := completedDiagonalWeight_tracial τ lowerSemicontinuous := by change LowerSemicontinuous (fun a : Positive (CornerCompletion A) => ⨆ k, completedTraceValue τ k a.1) exact lowerSemicontinuous_iSup fun k => ((completedTraceValue_continuous τ k).comp continuous_subtype_val).lowerSemicontinuous def sharedExtendedTrace (τ : TracialState A) : ExtendedTrace (TraceCone.MatrixLimit A) := (completedExtendedTrace τ).pullback sharedMatrixEquiv.toNonUnitalStarAlgHom end Pureness end namespace NonunitalGamma open Filter Topology TraceCone open scoped ComplexOrder ENNReal NNReal CStarAlgebra variable {A B : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] [NonUnitalCStarAlgebra B] [PartialOrder B] [StarOrderedRing B] def finiteMatrixMap (f : A →⋆ₙₐ[ℂ] B) (n : ℕ) : FinMatrix A n →⋆ₙₐ[ℂ] FinMatrix B n := CStarMatrix.mapₙₐ f omit [PartialOrder A] [StarOrderedRing A] [PartialOrder B] [StarOrderedRing B] in lemma finiteMatrixMap_successor (f : A →⋆ₙₐ[ℂ] B) (n : ℕ) (M : FinMatrix A n) : finiteMatrixMap f (n+1) (matrixSuccessor n M)=matrixSuccessor n (finiteMatrixMap f n M) := by ext i j change f (Fin.lastCases 0 (fun row => Fin.lastCases 0 (M row) j) i) = Fin.lastCases 0 (fun row => Fin.lastCases 0 (fun column => f (M row column)) j) i refine Fin.lastCases ?_ (fun i => ?_) i · simp · refine Fin.lastCases ?_ (fun j => ?_) j <;> simp lemma finiteMatrixMap_inclusion (f : A →⋆ₙₐ[ℂ] B) {n m : ℕ} (h : n ≤ m) (M : FinMatrix A n) : finiteMatrixMap f m (matrixInclusion h M)=matrixInclusion h (finiteMatrixMap f n M) := by change finiteMatrixMap f m (matrixPad h M)=matrixPad h (finiteMatrixMap f n M) induction m,h using Nat.le_induction with | base => simp only [matrixPad, Nat.leRecOn_self] | succ m h ih => rw [matrixPad_succ h,matrixPad_succ h,finiteMatrixMap_successor,ih] lemma stabilizationCompatible (f : A →⋆ₙₐ[ℂ] B) {n m : ℕ} (h : n ≤ m) (M : FinMatrix A n) : ((matrixLimitStage m).comp (finiteMatrixMap f m)) (matrixInclusion h M)= ((matrixLimitStage n).comp (finiteMatrixMap f n)) M := by change matrixLimitStage m (finiteMatrixMap f m (matrixInclusion h M))=_ rw [finiteMatrixMap_inclusion,matrixLimitStage_compatible] rfl def stabilizationMap (f : A →⋆ₙₐ[ℂ] B) : MatrixLimit A →⋆ₙₐ[ℂ] MatrixLimit B := matrixLimitLift (fun n => (matrixLimitStage n).comp (finiteMatrixMap f n)) (stabilizationCompatible f) def stabilizationInr : MatrixLimit A →⋆ₙₐ[ℂ] MatrixLimit (Unitization ℂ A) := stabilizationMap (Unitization.inrNonUnitalStarAlgHom ℂ A) def NormalizedTrace.stabilized (τ : NormalizedTrace A) : ExtendedTrace (MatrixLimit A) := (Pureness.sharedExtendedTrace τ.unitized).pullback stabilizationInr end NonunitalGamma namespace NonunitalGamma open Filter Topology TraceCone open scoped ENNReal NNReal ComplexOrder CStarAlgebra variable {A : Type*} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def scaledTrace (r : ℝ≥0) (τ : ExtendedTrace A) : ExtendedTrace A where toFun a := (r:ℝ≥0∞)*τ a map_zero := by rw [τ.map_zero,mul_zero] map_add a b := by rw [τ.map_add,mul_add] map_smul s a := by rw [τ.map_smul];ac_rfl tracial x := by rw [τ.tracial] lowerSemicontinuous := (ENNReal.continuous_const_mul ENNReal.coe_ne_top).comp_lowerSemicontinuous τ.lowerSemicontinuous (fun _ _ h => mul_le_mul_right h _) def boundedStabilized (τ : ExtendedTrace A) (hτ : WeightBounded τ) : ExtendedTrace (MatrixLimit A) := by classical exact if h : τ=0 then 0 else scaledTrace ‖positiveFunctionalCLM (boundedWeightFunctional τ hτ)‖₊ (normalizedWeight τ hτ h).stabilized def AllDenselyFiniteTracesBounded (A : Type*) [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] : Prop := ∀ τ : ExtendedTrace A, WeightDenselyFinite τ → WeightBounded τ def StrictComparison (hcone : AllDenselyFiniteTracesBounded A) : Prop := ∀ a b : Positive (MatrixLimit A), b.1 ≠ 0 → (∀ (τ : ExtendedTrace A) (hτ : WeightDenselyFinite τ), (boundedStabilized τ (hcone τ hτ)).rank b=1 → (boundedStabilized τ (hcone τ hτ)).rank a<1) → CuntzBelow a b end NonunitalGamma namespace NonunitalGamma open Pureness CurrentMain Filter DirectComparison open scoped Topology ComplexOrder variable {A : Type} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] local notation "τ" => (fun t : NormalizedTrace A => NormalizedTrace.unitized t) def UniformGamma (A : Type) [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] [Nontrivial A] [Nonempty (NormalizedTrace A)] (U : Ultrafilter ℕ) : Prop := ∀ m : ℕ, 0 < m → ∃ p : Fin m → FamilyUltrapower (fun t : NormalizedTrace A => t.unitized) U, (∀ i, IsStarProjection (p i)) ∧ (∑ i, p i)=1 ∧ (∀ i (a : A), Commute (p i) (familyUltrapowerMap (fun t : NormalizedTrace A => t.unitized) U (Unitization.inr a))) ∧ ∀ i (a : A) (s : ℕ → NormalizedTrace A), (familyLimitTrace (fun t : NormalizedTrace A => t.unitized) U s).functional (familyUltrapowerMap (fun t : NormalizedTrace A => t.unitized) U (Unitization.inr a)*p i) = (1/(m:ℂ))*(familyLimitTrace (fun t : NormalizedTrace A => t.unitized) U s).functional (familyUltrapowerMap (fun t : NormalizedTrace A => t.unitized) U (Unitization.inr a)) end NonunitalGamma namespace NonunitalGamma open TraceCone Pureness CurrentMain Filter open scoped ComplexOrder variable {A : Type} [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] def StablyProjectionless (A : Type) [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A] : Prop := Projectionless (MatrixLimit A) end NonunitalGamma namespace NuclearUnitization open scoped TensorProduct universe u v structure NonUnitalCStarNorm (R : Type*) [NonUnitalRing R] [StarRing R] [Module ℂ R] extends RingNorm R where smul : ∀ (c : ℂ) x, toRingNorm (c • x)=‖c‖*toRingNorm x cstar : ∀ x, toRingNorm (star x*x)=toRingNorm x*toRingNorm x def IsNuclear (A : Type u) [NonUnitalCStarAlgebra A] : Prop := ∀ (B : Type v) [CStarAlgebra B], Subsingleton (NonUnitalCStarNorm (A ⊗[ℂ] B)) end NuclearUnitization namespace Pureness.CStarAlgebraNorm variable {R : Type*} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] abbrev Completion (p : CStarAlgebraNorm R) := letI := p.normedRing UniformSpace.Completion R instance completionCStarAlgebra (p : CStarAlgebraNorm R) : NonUnitalCStarAlgebra p.Completion := by letI := p.normedRing letI := p.normedAlgebra letI := p.cstarRing exact Pureness.nonUnitalCompletionCStarAlgebra R end Pureness.CStarAlgebraNorm namespace ConcreteMatrixUnits open scoped ComplexOrder variable {ι D : Type*} [Fintype ι] [DecidableEq ι] [CStarAlgebra D] structure System (ι D : Type*) [Fintype ι] [DecidableEq ι] [CStarAlgebra D] where entry : ι → ι → D mul_entry : ∀ i j k l,entry i j*entry k l=if j=k then entry i l else 0 star_entry : ∀ i j,star (entry i j)=entry j i sum_diag : ∑ i,entry i i=1 end ConcreteMatrixUnits namespace JiangSuConstruction open scoped Kronecker ComplexOrder abbrev Mat (n : ℕ) := CStarMatrix (Fin n) (Fin n) ℂ abbrev TensorMat (p q : ℕ) := CStarMatrix (Fin p × Fin q) (Fin p × Fin q) ℂ abbrev Interval := Set.Icc (0 : ℝ) 1 end JiangSuConstruction namespace JiangSuConstruction open scoped Kronecker ComplexOrder local instance (priority := 2000) continuousMatrixSemiring (p q : ℕ) : Semiring C(Interval, TensorMat p q) := (inferInstance : Ring C(Interval, TensorMat p q)).toSemiring def leftAmplification (p q : ℕ) : Mat p →⋆ₐ[ℂ] TensorMat p q where toFun x := CStarMatrix.ofMatrix (CStarMatrix.ofMatrix.symm x ⊗ₖ (1 : Matrix (Fin q) (Fin q) ℂ)) map_one' := Matrix.one_kronecker_one map_zero' := Matrix.zero_kronecker _ map_add' x y := Matrix.add_kronecker _ _ _ map_mul' x y := by change (CStarMatrix.ofMatrix.symm x * CStarMatrix.ofMatrix.symm y) ⊗ₖ (1 : Matrix (Fin q) (Fin q) ℂ) = (CStarMatrix.ofMatrix.symm x ⊗ₖ (1 : Matrix (Fin q) (Fin q) ℂ)) * (CStarMatrix.ofMatrix.symm y ⊗ₖ (1 : Matrix (Fin q) (Fin q) ℂ)) simpa only [Matrix.one_mul] using Matrix.mul_kronecker_mul (CStarMatrix.ofMatrix.symm x) (CStarMatrix.ofMatrix.symm y) (1 : Matrix (Fin q) (Fin q) ℂ) 1 commutes' z := by ext ⟨i,j⟩ ⟨k,l⟩ by_cases hik : i = k <;> by_cases hjl : j = l <;> simp [CStarMatrix.algebraMap_apply, Matrix.kroneckerMap_apply, hik, hjl] map_star' x := by change (CStarMatrix.ofMatrix.symm x).conjTranspose ⊗ₖ (1 : Matrix (Fin q) (Fin q) ℂ) = ((CStarMatrix.ofMatrix.symm x) ⊗ₖ (1 : Matrix (Fin q) (Fin q) ℂ)).conjTranspose simpa only [Matrix.conjTranspose_one] using (Matrix.conjTranspose_kronecker (CStarMatrix.ofMatrix.symm x) (1 : Matrix (Fin q) (Fin q) ℂ)).symm def rightAmplification (p q : ℕ) : Mat q →⋆ₐ[ℂ] TensorMat p q where toFun x := CStarMatrix.ofMatrix ((1 : Matrix (Fin p) (Fin p) ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm x) map_one' := Matrix.one_kronecker_one map_zero' := Matrix.kronecker_zero _ map_add' x y := Matrix.kronecker_add _ _ _ map_mul' x y := by change (1 : Matrix (Fin p) (Fin p) ℂ) ⊗ₖ (CStarMatrix.ofMatrix.symm x * CStarMatrix.ofMatrix.symm y) = ((1 : Matrix (Fin p) (Fin p) ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm x) * ((1 : Matrix (Fin p) (Fin p) ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm y) simpa only [Matrix.one_mul] using Matrix.mul_kronecker_mul (1 : Matrix (Fin p) (Fin p) ℂ) 1 (CStarMatrix.ofMatrix.symm x) (CStarMatrix.ofMatrix.symm y) commutes' z := by ext ⟨i,j⟩ ⟨k,l⟩ by_cases hik : i = k <;> by_cases hjl : j = l <;> simp [CStarMatrix.algebraMap_apply, Matrix.kroneckerMap_apply, hik, hjl] map_star' x := by change (1 : Matrix (Fin p) (Fin p) ℂ) ⊗ₖ (CStarMatrix.ofMatrix.symm x).conjTranspose = ((1 : Matrix (Fin p) (Fin p) ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm x).conjTranspose simpa only [Matrix.conjTranspose_one] using (Matrix.conjTranspose_kronecker (1 : Matrix (Fin p) (Fin p) ℂ) (CStarMatrix.ofMatrix.symm x)).symm def evalHom (p q : ℕ) (t : Interval) : C(Interval, TensorMat p q) →⋆ₐ[ℂ] TensorMat p q where toFun f := f t map_one' := rfl map_zero' := rfl map_add' _ _ := rfl map_mul' _ _ := rfl commutes' _ := rfl map_star' _ := rfl def leftEndpoint : Interval := ⟨0,by norm_num⟩ def rightEndpoint : Interval := ⟨1,by norm_num⟩ def dimensionDrop (p q : ℕ) : StarSubalgebra ℂ C(Interval, TensorMat p q) := (leftAmplification p q).range.comap (evalHom p q leftEndpoint) ⊓ (rightAmplification p q).range.comap (evalHom p q rightEndpoint) instance tensorMat_finiteDimensional (p q : ℕ) : FiniteDimensional ℂ (TensorMat p q) := FiniteDimensional.of_injective (CStarMatrix.ofMatrixₗ (R := ℂ)).symm.toLinearMap (CStarMatrix.ofMatrixₗ (R := ℂ)).symm.injective lemma leftAmplification_closed (p q : ℕ) : IsClosed ((leftAmplification p q).range : Set (TensorMat p q)) := by exact (leftAmplification p q).range.toSubalgebra.toSubmodule.closed_of_finiteDimensional lemma rightAmplification_closed (p q : ℕ) : IsClosed ((rightAmplification p q).range : Set (TensorMat p q)) := by exact (rightAmplification p q).range.toSubalgebra.toSubmodule.closed_of_finiteDimensional instance dimensionDrop_closed (p q : ℕ) : IsClosed (dimensionDrop p q : Set C(Interval, TensorMat p q)) := by change IsClosed ((fun f : C(Interval, TensorMat p q) => f leftEndpoint) ⁻¹' ((leftAmplification p q).range : Set (TensorMat p q)) ∩ (fun f : C(Interval, TensorMat p q) => f rightEndpoint) ⁻¹' ((rightAmplification p q).range : Set (TensorMat p q))) apply IsClosed.inter · exact (leftAmplification_closed p q).preimage (show Continuous (fun f : C(Interval, TensorMat p q) => f leftEndpoint) from continuous_eval_const leftEndpoint) · exact (rightAmplification_closed p q).preimage (show Continuous (fun f : C(Interval, TensorMat p q) => f rightEndpoint) from continuous_eval_const rightEndpoint) abbrev DimensionDrop (p q : ℕ) := dimensionDrop p q instance (p q : ℕ) : CStarAlgebra (DimensionDrop p q) := by letI : SubringClass (StarSubalgebra ℂ C(Interval, TensorMat p q)) C(Interval, TensorMat p q) := @StarSubalgebra.subringClass ℂ C(Interval, TensorMat p q) _ _ _ _ _ _ exact StarSubalgebra.cstarAlgebra (dimensionDrop p q) end JiangSuConstruction section open Filter open scoped ENNReal Topology CStarAlgebra namespace SequentialCStar variable (C : ℕ → Type*) [∀ n, CStarAlgebra (C n)] [∀ n, Nontrivial (C n)] open TraceCone def boundedOne : BoundedFamilies C := ⟨fun _ => 1,memℓp_infty ⟨1,by rintro _ ⟨n,rfl⟩ simp⟩⟩ instance : One (FamilyQuotient C) := ⟨FamilyQuotient.mk (boundedOne C)⟩ lemma quotient_one_mul (x : FamilyQuotient C) : 1*x=x := by obtain ⟨x,rfl⟩ := FamilyQuotient.mk_surjective x change FamilyQuotient.mk (boundedOne C*x)=FamilyQuotient.mk x congr 1 apply lp.ext funext n exact one_mul (x n) lemma quotient_mul_one (x : FamilyQuotient C) : x*1=x := by obtain ⟨x,rfl⟩ := FamilyQuotient.mk_surjective x change FamilyQuotient.mk (x*boundedOne C)=FamilyQuotient.mk x congr 1 apply lp.ext funext n exact mul_one (x n) instance : Monoid (FamilyQuotient C) where one_mul := quotient_one_mul C mul_one := quotient_mul_one C instance : Ring (FamilyQuotient C) where natCast n := n • (1 : FamilyQuotient C) natCast_zero := zero_smul _ _ natCast_succ n := by simp only [add_smul,one_smul] intCast z := z • (1 : FamilyQuotient C) intCast_ofNat n := natCast_zsmul _ _ intCast_negSucc := negSucc_zsmul _ instance : Algebra ℂ (FamilyQuotient C) := Algebra.ofModule smul_mul_assoc mul_smul_comm instance : NormedRing (FamilyQuotient C) where dist_eq := dist_eq_norm_neg_add norm_mul_le := norm_mul_le instance : NormedAlgebra ℂ (FamilyQuotient C) where norm_smul_le := norm_smul_le instance : CStarAlgebra (FamilyQuotient C) where norm_mul_self_le := CStarRing.norm_mul_self_le structure System where map : ∀ {n m}, n≤ m → C n →⋆ₐ[ℂ] C m identity : ∀ n (a : C n), map (le_refl n) a=a composition : ∀ {n m k} (h : n≤ m) (g : m≤k) (a : C n), map g (map h a)=map (h.trans g) a injective : ∀ {n m} (h : n≤ m), Function.Injective (map h) end SequentialCStar end section open Filter open scoped ENNReal Topology CStarAlgebra namespace SequentialCStar variable (C : ℕ → Type*) [∀ n, CStarAlgebra (C n)] [∀ n, Nontrivial (C n)] open TraceCone namespace System variable {C} (S : System C) omit [∀ n, Nontrivial (C n)] in lemma map_norm {n m} (h : n≤ m) (a : C n) : ‖S.map h a‖=‖a‖ := NonUnitalStarAlgHom.norm_map (S.map h).toNonUnitalStarAlgHom (S.injective h) a def family (n : ℕ) : C n →⋆ₙₐ[ℂ] BoundedFamilies C where toFun a := ⟨fun m => if h : n≤ m then S.map h a else 0, memℓp_infty ⟨‖a‖,by rintro _ ⟨m,rfl⟩ change ‖if h : n≤ m then S.map h a else 0‖≤‖a‖ split_ifs <;> simp [map_norm,norm_nonneg]⟩⟩ map_zero' := by apply lp.ext; funext m; change (if h : n≤ m then S.map h 0 else 0)=0; split_ifs <;> simp map_add' a b := by apply lp.ext; funext m change (if h : n≤ m then S.map h (a+b) else 0)=(if h : n≤ m then S.map h a else 0)+(if h : n≤ m then S.map h b else 0) split_ifs <;> simp map_mul' a b := by apply lp.ext; funext m change (if h : n≤ m then S.map h (a*b) else 0)=(if h : n≤ m then S.map h a else 0)*(if h : n≤ m then S.map h b else 0) split_ifs <;> simp map_smul' c a := by apply lp.ext; funext m change (if h : n≤ m then S.map h (c • a) else 0)=c • (if h : n≤ m then S.map h a else 0) split_ifs <;> simp map_star' a := by apply lp.ext; funext m change (if h : n≤ m then S.map h (star a) else 0)=star (if h : n≤ m then S.map h a else 0) by_cases h : n≤ m · rw [dite_eq_left h,dite_eq_left h] exact map_star (S.map h) a · rw [dite_eq_right h,dite_eq_right h] exact (star_zero _).symm def stageNonUnital (n : ℕ) : C n →⋆ₙₐ[ℂ] FamilyQuotient C := FamilyQuotient.quotientHom.comp (S.family n) @[simp] lemma stageNonUnital_norm (n : ℕ) (a : C n) : ‖S.stageNonUnital n a‖=‖a‖ := by change ‖FamilyQuotient.mk (S.family n a)‖=‖a‖ rw [FamilyQuotient.norm_mk_eq_limsup] calc _ = limsup (fun _ : ℕ => ‖a‖) atTop := limsup_congr (by filter_upwards [eventually_ge_atTop n] with m hm change ‖if h : n≤ m then S.map h a else 0‖=‖a‖ simp [hm,map_norm]) _ = ‖a‖ := limsup_const (b := ‖a‖) lemma stageNonUnital_one (n : ℕ) : S.stageNonUnital n 1=1 := by apply FamilyQuotient.mk_eq_of_eventually_eq filter_upwards [eventually_ge_atTop n] with m hm change (if h : n≤ m then S.map h 1 else 0)=1 simp [hm] def stage (n : ℕ) : C n →⋆ₐ[ℂ] FamilyQuotient C where toFun := S.stageNonUnital n map_one' := S.stageNonUnital_one n map_zero' := map_zero _ map_add' := map_add _ map_mul' := map_mul _ commutes' z := by rw [Algebra.algebraMap_eq_smul_one,map_smul,S.stageNonUnital_one,←Algebra.algebraMap_eq_smul_one] map_star' := map_star _ @[simp] lemma stage_norm (n : ℕ) (a : C n) : ‖S.stage n a‖=‖a‖ := S.stageNonUnital_norm n a @[simp] lemma stage_compatible {n m} (h : n ≤ m) (a : C n) : S.stage m (S.map h a) = S.stage n a := by apply FamilyQuotient.mk_eq_of_eventually_eq filter_upwards [eventually_ge_atTop m] with index index_ge change (if bound : m ≤ index then S.map bound (S.map h a) else 0) = (if bound : n ≤ index then S.map bound a else 0) rw [dite_eq_left index_ge, dite_eq_left (h.trans index_ge)] exact S.composition h index_ge a def unionAlgebra : StarSubalgebra ℂ (FamilyQuotient C) where carrier := {element | ∃ (index : ℕ) (value : C index), S.stage index value = element} one_mem' := ⟨0, 1, map_one _⟩ zero_mem' := ⟨0, 0, map_zero _⟩ add_mem' := by rintro first second ⟨left, first, rfl⟩ ⟨right, second, rfl⟩ exact ⟨max left right, S.map (le_max_left left right) first + S.map (le_max_right left right) second, by simp⟩ mul_mem' := by rintro first second ⟨left, first, rfl⟩ ⟨right, second, rfl⟩ exact ⟨max left right, S.map (le_max_left left right) first * S.map (le_max_right left right) second, by simp⟩ algebraMap_mem' scalar := ⟨0, algebraMap ℂ (C 0) scalar, (S.stage 0).commutes scalar⟩ star_mem' := by rintro element ⟨index, value, rfl⟩ exact ⟨index, star value, map_star _ value⟩ def limitAlgebra : StarSubalgebra ℂ (FamilyQuotient C) := S.unionAlgebra.topologicalClosure instance limitAlgebra_closed : IsClosed (S.limitAlgebra : Set (FamilyQuotient C)) := StarSubalgebra.isClosed_topologicalClosure _ abbrev Limit := S.limitAlgebra instance : CStarAlgebra S.Limit := StarSubalgebra.cstarAlgebra _ def inclusion (n : ℕ) : C n →⋆ₐ[ℂ] S.Limit where toFun a := ⟨S.stage n a,StarSubalgebra.le_topologicalClosure _ ⟨n,a,rfl⟩⟩ map_one' := Subtype.ext (map_one _) map_zero' := Subtype.ext (map_zero _) map_add' a b := Subtype.ext (map_add _ a b) map_mul' a b := Subtype.ext (map_mul _ a b) commutes' z := Subtype.ext ((S.stage n).commutes z) map_star' a := Subtype.ext (map_star _ a) @[simp] lemma inclusion_norm (n : ℕ) (a : C n) : ‖S.inclusion n a‖=‖a‖ := S.stage_norm n a lemma inclusion_isometry (n : ℕ) : Isometry (S.inclusion n) := AddMonoidHomClass.isometry_of_norm _ (S.inclusion_norm n) theorem finite_stage_approximation (x : S.Limit) {ε : ℝ} (hε : 0<ε) : ∃ (n : ℕ) (a : C n), ‖x-S.inclusion n a‖<ε := by obtain ⟨y,⟨n,a,rfl⟩,hy⟩ := Metric.mem_closure_iff.mp x.2 ε hε refine ⟨n,a,?_⟩ change ‖(x : FamilyQuotient C)-S.stage n a‖<ε simpa only [dist_eq_norm] using hy end System end SequentialCStar end namespace SequentialCStar variable {C : ℕ → Type*} [∀ n, CStarAlgebra (C n)] variable (step : ∀ n, C n →⋆ₐ[ℂ] C (n+1)) def sequenceHom {n m : ℕ} (h : n≤ m) : C n →⋆ₐ[ℂ] C m := Nat.leRecOn (C := fun k => C n →⋆ₐ[ℂ] C k) h (fun {k} f => (step k).comp f) (StarAlgHom.id ℂ (C n)) @[simp] lemma sequenceHom_self (n : ℕ) (a : C n) : sequenceHom step (le_refl n) a=a := by rw [sequenceHom,Nat.leRecOn_self] rfl lemma sequenceHom_succ {n m : ℕ} (h : n≤ m) (a : C n) : sequenceHom step (h.trans (Nat.le_succ m)) a=step m (sequenceHom step h a) := by rw [sequenceHom,Nat.leRecOn_succ h] rfl lemma sequenceHom_comp {n m k : ℕ} (h : n≤ m) (g : m≤k) (a : C n) : sequenceHom step g (sequenceHom step h a)=sequenceHom step (h.trans g) a := by induction g with | refl => simp | @step k g ih => rw [sequenceHom_succ step g,sequenceHom_succ step (h.trans g),ih] lemma sequenceHom_injective (hs : ∀ n,Function.Injective (step n)) {n m : ℕ} (h : n≤ m) : Function.Injective (sequenceHom step h) := by induction h with | refl => intro x y h; simpa using h | @step m h ih => intro x y hxy rw [sequenceHom_succ step h,sequenceHom_succ step h] at hxy exact ih (hs m hxy) def System.ofSequence (hs : ∀ n,Function.Injective (step n)) : System C where map h := sequenceHom step h identity := sequenceHom_self step composition := sequenceHom_comp step injective := sequenceHom_injective step hs end SequentialCStar namespace JiangSuConstruction structure Multiplicities (p q : ℕ) where k : ℕ l : ℕ lower : ℕ upper : ℕ residual : ℕ gamma : ℕ delta : ℕ k_pos : 0 ⟨t.1/((2 : ℕ) : ℝ),by constructor <;> linarith [t.2.1,t.2.2]⟩, by fun_prop⟩ def upperEigenvalue : C(Interval,Interval) := ⟨fun t => ⟨(t.1+1)/((2 : ℕ) : ℝ),by constructor <;> linarith [t.2.1,t.2.2]⟩, by fun_prop⟩ theorem midpoint_value_mem : (1 / 2 : ℝ) ∈ Set.Icc (0 : ℝ) 1 := ⟨le_of_lt one_half_pos, le_of_lt one_half_lt_one⟩ def midpoint : Interval := ⟨(1 / ((2 : ℕ) : ℝ) : ℝ), midpoint_value_mem⟩ open Complex NormedSpace selfAdjoint Unitary open scoped CStarAlgebra ComplexOrder variable {n : Type*} [Fintype n] [DecidableEq n] lemma matrix_finite_spectrum (a : CStarMatrix n n ℂ) : (spectrum ℂ a).Finite := by have h := Matrix.finite_spectrum (CStarMatrix.ofMatrix.symm a) rwa [← AlgEquiv.spectrum_eq (CStarMatrix.ofMatrixStarAlgEquiv (n := n) (A := ℂ)).toAlgEquiv] at h lemma finite_spectrum_unitary_exp {A : Type*} [CStarAlgebra A] (u : unitary A) (hf : (spectrum ℂ (u : A)).Finite) : expUnitary (argSelfAdjoint u)=u := by ext have : ContinuousOn arg (spectrum ℂ (u : A)) := hf.continuousOn arg rw [expUnitary_coe,argSelfAdjoint_coe,← CFC.exp_eq_normedSpace_exp (𝕜 := ℂ), ← cfc_comp_smul ..,← cfc_comp' ..] conv_rhs => rw [← cfc_id' ℂ (u : A)] refine cfc_congr fun y hy => ?_ have hy₁ : ‖y‖=1 := spectrum.norm_eq_one_of_unitary u.2 hy have : I*y.arg=log y := Complex.ext (by simp [log_re,hy₁]) (by simp [log_im]) simpa [← exp_eq_exp_ℂ,this] using exp_log (by aesop) lemma finite_matrix_unitary_joined_one (u : unitary (CStarMatrix n n ℂ)) : Joined 1 u := by have hf : (spectrum ℂ (u : CStarMatrix n n ℂ)).Finite := matrix_finite_spectrum _ have he : expUnitary (argSelfAdjoint u)=u := finite_spectrum_unitary_exp u hf exact he ▸ selfAdjoint.joined_one_expUnitary (argSelfAdjoint u) def finiteMatrixUnitaryPath (u v : unitary (CStarMatrix n n ℂ)) : Path u v := ((finite_matrix_unitary_joined_one u).symm.trans (finite_matrix_unitary_joined_one v)).somePath end JiangSuConstruction namespace JiangSuConstruction open scoped ComplexOrder CStarAlgebra variable {ι κ : Type*} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ] def blockDiagonalHom : (κ → CStarMatrix ι ι ℂ) →⋆ₐ[ℂ] CStarMatrix (ι × κ) (ι × κ) ℂ where toFun x := CStarMatrix.ofMatrix (Matrix.blockDiagonal (fun i => CStarMatrix.ofMatrix.symm (x i))) map_one' := Matrix.blockDiagonal_one map_zero' := Matrix.blockDiagonal_zero map_add' x y := Matrix.blockDiagonal_add _ _ map_mul' x y := Matrix.blockDiagonal_mul _ _ commutes' z := by ext ⟨i,k⟩ ⟨j,l⟩ by_cases h : k=l <;> by_cases g : i=j <;> simp [Matrix.blockDiagonal_apply, CStarMatrix.algebraMap_apply,h,g] map_star' x := (Matrix.blockDiagonal_conjTranspose _).symm @[simp] lemma blockDiagonalHom_apply (x : κ → CStarMatrix ι ι ℂ) (i j : ι) (k : κ) : blockDiagonalHom x (i,k) (j,k)=x k i j := by exact Matrix.blockDiagonal_apply_eq _ i j k lemma blockDiagonalHom_injective : Function.Injective (blockDiagonalHom (ι := ι) (κ := κ)) := by intro x y h funext k ext i j simpa only [blockDiagonalHom_apply] using congrArg (fun a : CStarMatrix (ι×κ) (ι×κ) ℂ => a (i,k) (j,k)) h lemma blockDiagonalHom_continuous : Continuous (blockDiagonalHom (ι := ι) (κ := κ)) := map_continuous (blockDiagonalHom (ι := ι) (κ := κ)) def diagonalContinuousHom (ξ : κ → C(Interval,Interval)) : C(Interval,CStarMatrix ι ι ℂ) →⋆ₐ[ℂ] C(Interval,CStarMatrix (ι×κ) (ι×κ) ℂ) where toFun f := ⟨fun t => blockDiagonalHom (fun k => f (ξ k t)), blockDiagonalHom_continuous.comp (continuous_pi fun k => f.continuous.comp (ξ k).continuous)⟩ map_one' := by apply ContinuousMap.ext; intro t; exact map_one blockDiagonalHom map_zero' := by apply ContinuousMap.ext; intro t; exact map_zero blockDiagonalHom map_add' f g := by apply ContinuousMap.ext; intro t; exact map_add blockDiagonalHom _ _ map_mul' f g := by apply ContinuousMap.ext; intro t; exact map_mul blockDiagonalHom _ _ commutes' z := by apply ContinuousMap.ext; intro t; exact blockDiagonalHom.commutes z map_star' f := by apply ContinuousMap.ext; intro t; exact map_star blockDiagonalHom _ def unitaryConjugation {A : Type*} [CStarAlgebra A] (u : unitary A) : A →⋆ₐ[ℂ] A where toFun a := (u:A)*a*star (u:A) map_one' := by simp only [mul_one]; exact u.2.2 map_zero' := by simp map_add' a b := by simp [mul_add,add_mul] map_mul' a b := by simp only [mul_assoc] rw [←mul_assoc (star (u:A)),u.2.1,one_mul] commutes' z := by rw [← (Algebra.commutes z (u:A)), mul_assoc,u.2.2,mul_one] map_star' a := by simp [star_mul,mul_assoc] lemma unitaryConjugation_injective {A : Type*} [CStarAlgebra A] (u : unitary A) : Function.Injective (unitaryConjugation u) := by intro a b h have h' := congrArg (fun x : A => star (u:A)*x*(u:A)) h simpa [unitaryConjugation,mul_assoc,←mul_assoc (star (u:A)) (u:A),u.2.1] using h' def continuousUnitaryConjugation (u : C(Interval,unitary (CStarMatrix ι ι ℂ))) : C(Interval,CStarMatrix ι ι ℂ) →⋆ₐ[ℂ] C(Interval,CStarMatrix ι ι ℂ) where toFun f := ⟨fun t => unitaryConjugation (u t) (f t), (((continuous_subtype_val.comp u.continuous).mul f.continuous).mul (continuous_star.comp (continuous_subtype_val.comp u.continuous)))⟩ map_one' := by apply ContinuousMap.ext; intro t; exact map_one (unitaryConjugation (u t)) map_zero' := by apply ContinuousMap.ext; intro t; exact map_zero (unitaryConjugation (u t)) map_add' f g := by apply ContinuousMap.ext; intro t; exact map_add (unitaryConjugation (u t)) _ _ map_mul' f g := by apply ContinuousMap.ext; intro t; exact map_mul (unitaryConjugation (u t)) _ _ commutes' z := by apply ContinuousMap.ext; intro t; exact (unitaryConjugation (u t)).commutes z map_star' f := by apply ContinuousMap.ext; intro t; exact map_star (unitaryConjugation (u t)) _ lemma continuousUnitaryConjugation_injective (u : C(Interval,unitary (CStarMatrix ι ι ℂ))) : Function.Injective (continuousUnitaryConjugation u) := by intro f g h apply ContinuousMap.ext intro t exact unitaryConjugation_injective (u t) (congrArg (fun x : C(Interval,CStarMatrix ι ι ℂ) => x t) h) end JiangSuConstruction namespace JiangSuConstruction open scoped Kronecker ComplexOrder CStarAlgebra variable {ι κ α β ν : Type*} def endpointLeftEquiv : ((ι×κ)×((α×ν)⊕(β×(κ×ν)))) ≃ (((ι×α)⊕((ι×κ)×β))×(κ×ν)) where toFun x := match x with | ((i,k),Sum.inl (a,l)) => (Sum.inl (i,a),(k,l)) | ((i,k),Sum.inr (b,kl)) => (Sum.inr ((i,k),b),kl) invFun x := match x with | (Sum.inl (i,a),(k,l)) => ((i,k),Sum.inl (a,l)) | (Sum.inr ((i,k),b),kl) => ((i,k),Sum.inr (b,kl)) left_inv := by rintro ⟨⟨i,k⟩,⟨a,l⟩|⟨b,kl⟩⟩ <;> rfl right_inv := by rintro ⟨⟨i,a⟩|⟨⟨i,k⟩,b⟩,⟨k',l⟩⟩ <;> rfl def endpointRightEquiv : ((ι×κ)×((α×ν)⊕(β×(ι×ν)))) ≃ ((ι×ν)×((κ×α)⊕((ι×κ)×β))) where toFun x := match x with | ((i,k),Sum.inl (a,l)) => ((i,l),Sum.inl (k,a)) | ((i,k),Sum.inr (b,il)) => (il,Sum.inr ((i,k),b)) invFun x := match x with | ((i,l),Sum.inl (k,a)) => ((i,k),Sum.inl (a,l)) | (il,Sum.inr ((i,k),b)) => ((i,k),Sum.inr (b,il)) left_inv := by rintro ⟨⟨i,k⟩,⟨a,l⟩|⟨b,il⟩⟩ <;> rfl right_inv := by rintro ⟨⟨i,l⟩,⟨k,a⟩|⟨⟨i',k⟩,b⟩⟩ <;> rfl end JiangSuConstruction namespace JiangSuConstruction open scoped Kronecker ComplexOrder CStarAlgebra variable {ι κ α β ν : Type*} variable [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ] [Fintype α] [DecidableEq α] [Fintype β] [DecidableEq β] [Fintype ν] [DecidableEq ν] def endpointReduced (a : CStarMatrix ι ι ℂ) (b : CStarMatrix (ι×κ) (ι×κ) ℂ) : CStarMatrix ((ι×α)⊕((ι×κ)×β)) ((ι×α)⊕((ι×κ)×β)) ℂ := CStarMatrix.ofMatrix (Matrix.fromBlocks (Matrix.blockDiagonal fun _ : α => CStarMatrix.ofMatrix.symm a) 0 0 (Matrix.blockDiagonal fun _ : β => CStarMatrix.ofMatrix.symm b)) lemma endpoint_left_regroup (a : CStarMatrix ι ι ℂ) (b : CStarMatrix (ι×κ) (ι×κ) ℂ) : CStarMatrix.reindexₐ ℂ ℂ (endpointLeftEquiv (ι:=ι) (κ:=κ) (α:=α) (β:=β) (ν:=ν)) (blockDiagonalHom (fun x : (α×ν)⊕(β×(κ×ν)) => match x with | Sum.inl _ => CStarMatrix.ofMatrix (CStarMatrix.ofMatrix.symm a ⊗ₖ (1 : Matrix κ κ ℂ)) | Sum.inr _ => b)) = CStarMatrix.ofMatrix (CStarMatrix.ofMatrix.symm (endpointReduced (α:=α) (β:=β) a b) ⊗ₖ (1 : Matrix (κ×ν) (κ×ν) ℂ)) := by let x : (α×ν)⊕(β×(κ×ν)) → Matrix (ι×κ) (ι×κ) ℂ := fun z => match z with | Sum.inl _ => CStarMatrix.ofMatrix.symm a ⊗ₖ (1 : Matrix κ κ ℂ) | Sum.inr _ => CStarMatrix.ofMatrix.symm b ext ⟨s,⟨k,l⟩⟩ ⟨t,⟨k',l'⟩⟩ cases s with | inl ia => rcases ia with ⟨i,a'⟩ cases t with | inl ja => rcases ja with ⟨j,a''⟩ change Matrix.blockDiagonal x (((i,k),Sum.inl (a',l))) (((j,k'),Sum.inl (a'',l'))) = _ by_cases ha : a'=a'' <;> by_cases hk : k=k' <;> by_cases hl : l=l' <;> simp [x,Matrix.blockDiagonal_apply,endpointReduced,Matrix.kroneckerMap_apply,ha,hk,hl] | inr jb => rcases jb with ⟨⟨j,h⟩,b'⟩ change Matrix.blockDiagonal x (((i,k),Sum.inl (a',l))) (((j,h),Sum.inr (b',(k',l')))) = _ simp [x,Matrix.blockDiagonal_apply,endpointReduced,Matrix.kroneckerMap_apply] | inr ib => rcases ib with ⟨⟨i,h⟩,b'⟩ cases t with | inl ja => rcases ja with ⟨j,a'⟩ change Matrix.blockDiagonal x (((i,h),Sum.inr (b',(k,l)))) (((j,k'),Sum.inl (a',l'))) = _ simp [x,Matrix.blockDiagonal_apply,endpointReduced,Matrix.kroneckerMap_apply] | inr jb => rcases jb with ⟨⟨j,h'⟩,b''⟩ change Matrix.blockDiagonal x (((i,h),Sum.inr (b',(k,l)))) (((j,h'),Sum.inr (b'',(k',l')))) = _ by_cases hb : b'=b'' <;> by_cases hk : k=k' <;> by_cases hl : l=l' <;> simp [x,Matrix.blockDiagonal_apply,endpointReduced,Matrix.kroneckerMap_apply,hb,hk,hl] def endpointRightReduced (a : CStarMatrix κ κ ℂ) (b : CStarMatrix (ι×κ) (ι×κ) ℂ) : CStarMatrix ((κ×α)⊕((ι×κ)×β)) ((κ×α)⊕((ι×κ)×β)) ℂ := CStarMatrix.ofMatrix (Matrix.fromBlocks (Matrix.blockDiagonal fun _ : α => CStarMatrix.ofMatrix.symm a) 0 0 (Matrix.blockDiagonal fun _ : β => CStarMatrix.ofMatrix.symm b)) lemma endpoint_right_regroup (a : CStarMatrix κ κ ℂ) (b : CStarMatrix (ι×κ) (ι×κ) ℂ) : CStarMatrix.reindexₐ ℂ ℂ (endpointRightEquiv (ι:=ι) (κ:=κ) (α:=α) (β:=β) (ν:=ν)) (blockDiagonalHom (fun x : (α×ν)⊕(β×(ι×ν)) => match x with | Sum.inl _ => CStarMatrix.ofMatrix ((1 : Matrix ι ι ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm a) | Sum.inr _ => b)) = CStarMatrix.ofMatrix ((1 : Matrix (ι×ν) (ι×ν) ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm (endpointRightReduced (α:=α) (β:=β) a b)) := by let x : (α×ν)⊕(β×(ι×ν)) → Matrix (ι×κ) (ι×κ) ℂ := fun z => match z with | Sum.inl _ => (1 : Matrix ι ι ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm a | Sum.inr _ => CStarMatrix.ofMatrix.symm b ext ⟨⟨i,l⟩,s⟩ ⟨⟨i',l'⟩,t⟩ cases s with | inl ka => rcases ka with ⟨k,a'⟩ cases t with | inl ja => rcases ja with ⟨j,a''⟩ change Matrix.blockDiagonal x (((i,k),Sum.inl (a',l))) (((i',j),Sum.inl (a'',l'))) = _ by_cases ha : a'=a'' <;> by_cases hi : i=i' <;> by_cases hl : l=l' <;> simp [x,Matrix.blockDiagonal_apply,endpointRightReduced,Matrix.kroneckerMap_apply,ha,hi,hl] | inr jb => rcases jb with ⟨⟨j,h⟩,b'⟩ change Matrix.blockDiagonal x (((i,k),Sum.inl (a',l))) (((j,h),Sum.inr (b',(i',l')))) = _ simp [x,Matrix.blockDiagonal_apply,endpointRightReduced,Matrix.kroneckerMap_apply] | inr ib => rcases ib with ⟨⟨j,h⟩,b'⟩ cases t with | inl ka => rcases ka with ⟨k,a'⟩ change Matrix.blockDiagonal x (((j,h),Sum.inr (b',(i,l)))) (((i',k),Sum.inl (a',l'))) = _ simp [x,Matrix.blockDiagonal_apply,endpointRightReduced,Matrix.kroneckerMap_apply] | inr jb => rcases jb with ⟨⟨j',h'⟩,b''⟩ change Matrix.blockDiagonal x (((j,h),Sum.inr (b',(i,l)))) (((j',h'),Sum.inr (b'',(i',l')))) = _ by_cases hb : b'=b'' <;> by_cases hi : i=i' <;> by_cases hl : l=l' <;> simp [x,Matrix.blockDiagonal_apply,endpointRightReduced,Matrix.kroneckerMap_apply,hb,hi,hl] end JiangSuConstruction namespace JiangSuConstruction open scoped ComplexOrder CStarAlgebra variable {ι κ : Type*} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ] def continuousReindex (e : ι ≃ κ) : C(Interval,CStarMatrix ι ι ℂ) →⋆ₐ[ℂ] C(Interval,CStarMatrix κ κ ℂ) := ContinuousMap.compStarAlgHom Interval (CStarMatrix.reindexₐ ℂ ℂ e).toStarAlgHom (map_continuous (CStarMatrix.reindexₐ ℂ ℂ e).toStarAlgHom) lemma continuousReindex_injective (e : ι≃κ) : Function.Injective (continuousReindex e) := by intro f g h apply ContinuousMap.ext intro t apply (CStarMatrix.reindexₐ ℂ ℂ e).injective exact congrArg (fun x : C(Interval,CStarMatrix κ κ ℂ) => x t) h end JiangSuConstruction namespace JiangSuConstruction open scoped ComplexOrder CStarAlgebra variable {ι κ : Type*} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ] variable {p q P Q : ℕ} {ρ : Type*} [Fintype ρ] [DecidableEq ρ] def connectingAmbient (ξ : ρ → C(Interval,Interval)) (e : ((Fin p×Fin q)×ρ)≃(Fin P×Fin Q)) (u₀ u₁ : unitary (TensorMat P Q)) : C(Interval,TensorMat p q) →⋆ₐ[ℂ] C(Interval,TensorMat P Q) := (continuousUnitaryConjugation (finiteMatrixUnitaryPath u₀ u₁).toContinuousMap).comp ((continuousReindex e).comp (diagonalContinuousHom ξ)) lemma connectingAmbient_zero (ξ : ρ → C(Interval,Interval)) (e : ((Fin p×Fin q)×ρ)≃(Fin P×Fin Q)) (u₀ u₁ : unitary (TensorMat P Q)) (f : C(Interval,TensorMat p q)) : connectingAmbient ξ e u₀ u₁ f leftEndpoint= unitaryConjugation u₀ ((CStarMatrix.reindexₐ ℂ ℂ e) (blockDiagonalHom (fun k => f (ξ k leftEndpoint)))) := by change unitaryConjugation ((finiteMatrixUnitaryPath u₀ u₁) 0) _=_ rw [Path.source] rfl lemma connectingAmbient_one (ξ : ρ → C(Interval,Interval)) (e : ((Fin p×Fin q)×ρ)≃(Fin P×Fin Q)) (u₀ u₁ : unitary (TensorMat P Q)) (f : C(Interval,TensorMat p q)) : connectingAmbient ξ e u₀ u₁ f rightEndpoint= unitaryConjugation u₁ ((CStarMatrix.reindexₐ ℂ ℂ e) (blockDiagonalHom (fun k => f (ξ k rightEndpoint)))) := by change unitaryConjugation ((finiteMatrixUnitaryPath u₀ u₁) 1) _=_ rw [Path.target] rfl def connectingMap (ξ : ρ → C(Interval,Interval)) (e : ((Fin p×Fin q)×ρ)≃(Fin P×Fin Q)) (u₀ u₁ : unitary (TensorMat P Q)) (h₀ : ∀ f : DimensionDrop p q, unitaryConjugation u₀ ((CStarMatrix.reindexₐ ℂ ℂ e) (blockDiagonalHom (fun k => (f : C(Interval,TensorMat p q)) (ξ k leftEndpoint)))) ∈ (leftAmplification P Q).range) (h₁ : ∀ f : DimensionDrop p q, unitaryConjugation u₁ ((CStarMatrix.reindexₐ ℂ ℂ e) (blockDiagonalHom (fun k => (f : C(Interval,TensorMat p q)) (ξ k rightEndpoint)))) ∈ (rightAmplification P Q).range) : DimensionDrop p q →⋆ₐ[ℂ] DimensionDrop P Q := ((connectingAmbient ξ e u₀ u₁).comp (dimensionDrop p q).subtype).codRestrict (dimensionDrop P Q) (fun f => by constructor · change connectingAmbient ξ e u₀ u₁ (f : C(Interval,TensorMat p q)) leftEndpoint ∈ (leftAmplification P Q).range rw [connectingAmbient_zero] exact h₀ f · change connectingAmbient ξ e u₀ u₁ (f : C(Interval,TensorMat p q)) rightEndpoint ∈ (rightAmplification P Q).range rw [connectingAmbient_one] exact h₁ f) end JiangSuConstruction namespace JiangSuConstruction open scoped ComplexOrder CStarAlgebra variable {ι : Type*} [Fintype ι] [DecidableEq ι] local instance (priority := 2000) permutationMatrixSemiring : Semiring (CStarMatrix ι ι ℂ) := (inferInstance : CStarAlgebra (CStarMatrix ι ι ℂ)).toSemiring def permutationUnitary (e : Equiv.Perm ι) : unitary (CStarMatrix ι ι ℂ) := ⟨CStarMatrix.ofMatrix ((e⁻¹).permMatrix ℂ),by constructor · change ((e⁻¹).permMatrix ℂ).conjTranspose * (e⁻¹).permMatrix ℂ = 1 rw [Matrix.conjTranspose_permMatrix, ← Matrix.permMatrix_mul] simp · change (e⁻¹).permMatrix ℂ * ((e⁻¹).permMatrix ℂ).conjTranspose = 1 rw [Matrix.conjTranspose_permMatrix, ← Matrix.permMatrix_mul] simp⟩ lemma permutationUnitary_conjugation (e : Equiv.Perm ι) (a : CStarMatrix ι ι ℂ) : unitaryConjugation (permutationUnitary e) a = CStarMatrix.reindexₐ ℂ ℂ e a := by change (e⁻¹).permMatrix ℂ * CStarMatrix.ofMatrix.symm a * ((e⁻¹).permMatrix ℂ).conjTranspose = Matrix.reindex e e a rw [Matrix.conjTranspose_permMatrix] change (e⁻¹).toPEquiv.toMatrix * CStarMatrix.ofMatrix.symm a * e.toPEquiv.toMatrix = _ rw [PEquiv.toMatrix_toPEquiv_mul, PEquiv.mul_toMatrix_toPEquiv] rfl end JiangSuConstruction namespace JiangSuConstruction open scoped Kronecker ComplexOrder CStarAlgebra variable {ι κ ρ σ τ : Type*} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ] [Fintype ρ] [DecidableEq ρ] [Fintype σ] [DecidableEq σ] [Fintype τ] [DecidableEq τ] local instance (priority := 2000) reindexMatrixSemiring {index : Type*} [Fintype index] [DecidableEq index] : Semiring (CStarMatrix index index ℂ) := (inferInstance : CStarAlgebra (CStarMatrix index index ℂ)).toSemiring omit [DecidableEq ι] [DecidableEq κ] [DecidableEq ρ] in lemma reindex_trans (e : ι≃κ) (f : κ≃ρ) (a : CStarMatrix ι ι ℂ) : CStarMatrix.reindexₐ ℂ ℂ (e.trans f) a = CStarMatrix.reindexₐ ℂ ℂ f (CStarMatrix.reindexₐ ℂ ℂ e a) := rfl lemma reindex_blockDiagonal (e : κ≃ρ) (x : κ→CStarMatrix ι ι ℂ) : CStarMatrix.reindexₐ ℂ ℂ (Equiv.prodCongr (Equiv.refl ι) e) (blockDiagonalHom x) = blockDiagonalHom (fun k => x (e.symm k)) := by ext ⟨i,k⟩ ⟨j,l⟩ change Matrix.blockDiagonal (fun z => CStarMatrix.ofMatrix.symm (x z)) (i,e.symm k) (j,e.symm l) = Matrix.blockDiagonal (fun z => CStarMatrix.ofMatrix.symm (x (e.symm z))) (i,k) (j,l) simp only [Matrix.blockDiagonal_apply,Equiv.symm_apply_eq] by_cases h : k=l · subst l; simp · simp [h] omit [DecidableEq ι] [DecidableEq κ] [DecidableEq ρ] [DecidableEq σ] in lemma reindex_kronecker (e : ι≃κ) (f : ρ≃σ) (a : CStarMatrix ι ι ℂ) (b : CStarMatrix ρ ρ ℂ) : CStarMatrix.reindexₐ ℂ ℂ (Equiv.prodCongr e f) (CStarMatrix.ofMatrix (CStarMatrix.ofMatrix.symm a ⊗ₖ CStarMatrix.ofMatrix.symm b)) = CStarMatrix.ofMatrix (CStarMatrix.ofMatrix.symm (CStarMatrix.reindexₐ ℂ ℂ e a) ⊗ₖ CStarMatrix.ofMatrix.symm (CStarMatrix.reindexₐ ℂ ℂ f b)) := rfl omit [DecidableEq ι] in lemma reindex_left_amplification {P Q : ℕ} (e : ι≃Fin P) (f : κ≃Fin Q) (a : CStarMatrix ι ι ℂ) : CStarMatrix.reindexₐ ℂ ℂ (Equiv.prodCongr e f) (CStarMatrix.ofMatrix (CStarMatrix.ofMatrix.symm a ⊗ₖ (1 : Matrix κ κ ℂ))) = leftAmplification P Q (CStarMatrix.reindexₐ ℂ ℂ e a) := by rw [show (1 : Matrix κ κ ℂ)=CStarMatrix.ofMatrix.symm (1 : CStarMatrix κ κ ℂ) from rfl,reindex_kronecker,map_one] rfl omit [DecidableEq κ] in lemma reindex_right_amplification {P Q : ℕ} (e : ι≃Fin P) (f : κ≃Fin Q) (a : CStarMatrix κ κ ℂ) : CStarMatrix.reindexₐ ℂ ℂ (Equiv.prodCongr e f) (CStarMatrix.ofMatrix ((1 : Matrix ι ι ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm a)) = rightAmplification P Q (CStarMatrix.reindexₐ ℂ ℂ f a) := by rw [show (1 : Matrix ι ι ℂ)=CStarMatrix.ofMatrix.symm (1 : CStarMatrix ι ι ℂ) from rfl,reindex_kronecker,map_one] rfl omit [DecidableEq ι] in lemma permutation_after_reindex (e f : ι≃κ) (a : CStarMatrix ι ι ℂ) : unitaryConjugation (permutationUnitary (e.symm.trans f)) (CStarMatrix.reindexₐ ℂ ℂ e a) = CStarMatrix.reindexₐ ℂ ℂ f a := by rw [permutationUnitary_conjugation] ext i j change a (e.symm (e (f.symm i))) (e.symm (e (f.symm j))) = a (f.symm i) (f.symm j) simp end JiangSuConstruction namespace OriginalJiangSu open JiangSuConstruction structure Pair where p : ℕ q : ℕ p_gt : 1 < p q_gt : 1 < q coprime : p.Coprime q structure Multiplicities (p q : ℕ) where k : ℕ l : ℕ r : ℕ s : ℕ gamma : ℕ delta : ℕ lower : ℕ upper : ℕ middle : ℕ k_pos : 0 < k l_pos : 0 < l r_pos : 0 < r s_pos : 0 < s lower_pos : 0 < lower upper_pos : 0 < upper middle_pos : 0 < middle lower_eq : lower = l*r upper_eq : upper = k*s total : lower+upper+middle=k*l zero_count : upper+middle=(q*l)*delta one_count : lower+middle=(p*k)*gamma zero_reduced : p*r+(p*q)*delta=p*k one_reduced : q*s+(p*q)*gamma=q*l target_coprime : (p*k).Coprime (q*l) r_lt : r < q s_lt : s < p k_prime : Nat.Prime k l_prime : Nat.Prime l k_large : 4*q ≤ k l_large : 4*p ≤ l lemma mod_pos_of_coprime {k q : ℕ} (hq : 1 ⟨2,3,by decide,by decide,by decide⟩ | n+1 => (pair n).next end OriginalJiangSu namespace OriginalJiangSu open JiangSuConstruction variable {p q : ℕ} abbrev Index (m : Multiplicities p q) := Fin m.lower ⊕ (Fin m.upper ⊕ Fin m.middle) def family (m : Multiplicities p q) : Index m → C(Interval,Interval) | .inl _ => lowerEigenvalue | .inr (.inl _) => upperEigenvalue | .inr (.inr _) => ContinuousMap.const _ JiangSuConstruction.midpoint def sumSwapFirst (α β γ : Type*) : (α ⊕ (β ⊕ γ)) ≃ (β ⊕ (α ⊕ γ)) where toFun | .inl a => .inr (.inl a) | .inr (.inl b) => .inl b | .inr (.inr c) => .inr (.inr c) invFun | .inl b => .inr (.inl b) | .inr (.inl a) => .inl a | .inr (.inr c) => .inr (.inr c) left_inv := by rintro (a|b|c) <;> rfl right_inv := by rintro (b|a|c) <;> rfl def zeroCountEquiv (m : Multiplicities p q) : Fin m.lower ≃ (Fin m.r × Fin m.l) := Fintype.equivOfCardEq (by simpa only [Fintype.card_prod,Fintype.card_fin,Nat.mul_comm] using m.lower_eq) def zeroMidEquiv (m : Multiplicities p q) : (Fin m.upper ⊕ Fin m.middle) ≃ (Fin m.delta × (Fin q × Fin m.l)) := Fintype.equivOfCardEq (by simpa only [Fintype.card_sum,Fintype.card_prod,Fintype.card_fin,Nat.mul_comm] using m.zero_count) def oneCountEquiv (m : Multiplicities p q) : Fin m.upper ≃ (Fin m.s × Fin m.k) := Fintype.equivOfCardEq (by simpa only [Fintype.card_prod,Fintype.card_fin,Nat.mul_comm] using m.upper_eq) def oneMidEquiv (m : Multiplicities p q) : (Fin m.lower ⊕ Fin m.middle) ≃ (Fin m.gamma × (Fin p × Fin m.k)) := Fintype.equivOfCardEq (by simpa only [Fintype.card_sum,Fintype.card_prod,Fintype.card_fin,Nat.mul_comm] using m.one_count) def zeroBlockEquiv (m : Multiplicities p q) : Index m ≃ ((Fin m.r × Fin m.l) ⊕ (Fin m.delta × (Fin q × Fin m.l))) := Equiv.sumCongr (zeroCountEquiv m) (zeroMidEquiv m) def oneBlockEquiv (m : Multiplicities p q) : Index m ≃ ((Fin m.s × Fin m.k) ⊕ (Fin m.gamma × (Fin p × Fin m.k))) := (sumSwapFirst _ _ _).trans (Equiv.sumCongr (oneCountEquiv m) (oneMidEquiv m)) lemma family_zero (m : Multiplicities p q) (z) : family m ((zeroBlockEquiv m).symm z) leftEndpoint = (match z with | Sum.inl _ => leftEndpoint | Sum.inr _ => JiangSuConstruction.midpoint) := by cases z with | inl z => apply Subtype.ext; norm_num [zeroBlockEquiv,family,lowerEigenvalue,leftEndpoint] | inr z => change family m (Sum.inr ((zeroMidEquiv m).symm z)) leftEndpoint=JiangSuConstruction.midpoint cases (zeroMidEquiv m).symm z <;> apply Subtype.ext <;> norm_num [family,upperEigenvalue,leftEndpoint,JiangSuConstruction.midpoint] lemma family_one (m : Multiplicities p q) (z) : family m ((oneBlockEquiv m).symm z) rightEndpoint = (match z with | Sum.inl _ => rightEndpoint | Sum.inr _ => JiangSuConstruction.midpoint) := by cases z with | inl z => apply Subtype.ext; norm_num [oneBlockEquiv,sumSwapFirst,family,upperEigenvalue,rightEndpoint] | inr z => change family m ((sumSwapFirst _ _ _).symm (Sum.inr ((oneMidEquiv m).symm z))) rightEndpoint=JiangSuConstruction.midpoint cases (oneMidEquiv m).symm z <;> apply Subtype.ext <;> norm_num [sumSwapFirst,family,lowerEigenvalue,rightEndpoint,JiangSuConstruction.midpoint] lemma family_cover (m : Multiplicities p q) (t : Interval) : ∃ j : Index m,∃ s : Interval,family m j s=t := by by_cases ht : t.1≤1/2 · refine ⟨Sum.inl ⟨0,m.lower_pos⟩,⟨2*t.1,by constructor <;> linarith [t.2.1]⟩,?_⟩ apply Subtype.ext change 2*t.1/2=t.1 ring · refine ⟨Sum.inr (Sum.inl ⟨0,m.upper_pos⟩),⟨2*t.1-1,by constructor <;> linarith [t.2.2]⟩,?_⟩ apply Subtype.ext change (2*t.1-1+1)/2=t.1 ring end OriginalJiangSu namespace OriginalJiangSu open JiangSuConstruction open scoped Kronecker ComplexOrder CStarAlgebra variable {p q : ℕ} def zeroReducedEquiv (m : Multiplicities p q) : ((Fin p×Fin m.r) ⊕ ((Fin p×Fin q)×Fin m.delta)) ≃ Fin (p*m.k) := Fintype.equivOfCardEq (by simpa only [Fintype.card_sum,Fintype.card_prod,Fintype.card_fin] using m.zero_reduced) def zeroTensorEquiv (m : Multiplicities p q) : (Fin q×Fin m.l) ≃ Fin (q*m.l) := Fintype.equivOfCardEq (by simp) def oneReducedEquiv (m : Multiplicities p q) : ((Fin q×Fin m.s) ⊕ ((Fin p×Fin q)×Fin m.gamma)) ≃ Fin (q*m.l) := Fintype.equivOfCardEq (by simpa only [Fintype.card_sum,Fintype.card_prod,Fintype.card_fin] using m.one_reduced) def oneTensorEquiv (m : Multiplicities p q) : (Fin p×Fin m.k) ≃ Fin (p*m.k) := Fintype.equivOfCardEq (by simp) def zeroIndexEquiv (m : Multiplicities p q) : ((Fin p×Fin q)×Index m) ≃ (Fin (p*m.k)×Fin (q*m.l)) := (Equiv.prodCongr (Equiv.refl _) (zeroBlockEquiv m)).trans (endpointLeftEquiv.trans (Equiv.prodCongr (zeroReducedEquiv m) (zeroTensorEquiv m))) def oneIndexEquiv (m : Multiplicities p q) : ((Fin p×Fin q)×Index m) ≃ (Fin (p*m.k)×Fin (q*m.l)) := (Equiv.prodCongr (Equiv.refl _) (oneBlockEquiv m)).trans (endpointRightEquiv.trans (Equiv.prodCongr (oneTensorEquiv m) (oneReducedEquiv m))) lemma zeroIndex_endpoint (m : Multiplicities p q) (f : DimensionDrop p q) : CStarMatrix.reindexₐ ℂ ℂ (zeroIndexEquiv m) (blockDiagonalHom (fun z => (f : C(Interval,TensorMat p q)) (family m z leftEndpoint))) ∈ (leftAmplification (p*m.k) (q*m.l)).range := by obtain ⟨a,ha⟩ := f.2.1 have hfamily : (fun z => (f : C(Interval,TensorMat p q)) (family m ((zeroBlockEquiv m).symm z) leftEndpoint)) = (fun z => match z with | Sum.inl _ => leftAmplification p q a | Sum.inr _ => (f : C(Interval,TensorMat p q)) JiangSuConstruction.midpoint) := by funext z rw [family_zero] cases z · exact ha.symm · rfl unfold zeroIndexEquiv rw [reindex_trans,reindex_blockDiagonal,hfamily,reindex_trans] change CStarMatrix.reindexₐ ℂ ℂ (Equiv.prodCongr (zeroReducedEquiv m) (zeroTensorEquiv m)) (CStarMatrix.reindexₐ ℂ ℂ endpointLeftEquiv (blockDiagonalHom (fun z => match z with | Sum.inl _ => CStarMatrix.ofMatrix (CStarMatrix.ofMatrix.symm a ⊗ₖ (1 : Matrix (Fin q) (Fin q) ℂ)) | Sum.inr _ => (f : C(Interval,TensorMat p q)) JiangSuConstruction.midpoint))) ∈ _ have he := congrArg (CStarMatrix.reindexₐ ℂ ℂ (Equiv.prodCongr (zeroReducedEquiv m) (zeroTensorEquiv m))) (endpoint_left_regroup (α := Fin m.r) (β := Fin m.delta) (ν := Fin m.l) a ((f : C(Interval,TensorMat p q)) JiangSuConstruction.midpoint)) rw [reindex_left_amplification] at he refine ⟨CStarMatrix.reindexₐ ℂ ℂ (zeroReducedEquiv m) (endpointReduced a ((f : C(Interval,TensorMat p q)) JiangSuConstruction.midpoint)), ?_⟩ convert he.symm using 1 · congr 2 apply congrArg blockDiagonalHom funext index cases index <;> rfl lemma oneIndex_endpoint (m : Multiplicities p q) (f : DimensionDrop p q) : CStarMatrix.reindexₐ ℂ ℂ (oneIndexEquiv m) (blockDiagonalHom (fun z => (f : C(Interval,TensorMat p q)) (family m z rightEndpoint))) ∈ (rightAmplification (p*m.k) (q*m.l)).range := by obtain ⟨a,ha⟩ := f.2.2 have hfamily : (fun z => (f : C(Interval,TensorMat p q)) (family m ((oneBlockEquiv m).symm z) rightEndpoint)) = (fun z => match z with | Sum.inl _ => rightAmplification p q a | Sum.inr _ => (f : C(Interval,TensorMat p q)) JiangSuConstruction.midpoint) := by funext z rw [family_one] cases z · exact ha.symm · rfl unfold oneIndexEquiv rw [reindex_trans,reindex_blockDiagonal,hfamily,reindex_trans] change CStarMatrix.reindexₐ ℂ ℂ (Equiv.prodCongr (oneTensorEquiv m) (oneReducedEquiv m)) (CStarMatrix.reindexₐ ℂ ℂ endpointRightEquiv (blockDiagonalHom (fun z => match z with | Sum.inl _ => CStarMatrix.ofMatrix ((1 : Matrix (Fin p) (Fin p) ℂ) ⊗ₖ CStarMatrix.ofMatrix.symm a) | Sum.inr _ => (f : C(Interval,TensorMat p q)) JiangSuConstruction.midpoint))) ∈ _ have he := congrArg (CStarMatrix.reindexₐ ℂ ℂ (Equiv.prodCongr (oneTensorEquiv m) (oneReducedEquiv m))) (endpoint_right_regroup (α := Fin m.s) (β := Fin m.gamma) (ν := Fin m.k) a ((f : C(Interval,TensorMat p q)) JiangSuConstruction.midpoint)) rw [reindex_right_amplification] at he refine ⟨CStarMatrix.reindexₐ ℂ ℂ (oneReducedEquiv m) (endpointRightReduced a ((f : C(Interval,TensorMat p q)) JiangSuConstruction.midpoint)), ?_⟩ convert he.symm using 1 · congr 2 apply congrArg blockDiagonalHom funext index cases index <;> rfl def step (m : Multiplicities p q) : DimensionDrop p q →⋆ₐ[ℂ] DimensionDrop (p*m.k) (q*m.l) := connectingMap (family m) (zeroIndexEquiv m) (permutationUnitary ((zeroIndexEquiv m).symm.trans (zeroIndexEquiv m))) (permutationUnitary ((zeroIndexEquiv m).symm.trans (oneIndexEquiv m))) (fun f => by rw [permutation_after_reindex]; exact zeroIndex_endpoint m f) (fun f => by rw [permutation_after_reindex]; exact oneIndex_endpoint m f) lemma diagonalContinuousHom_injective_cover {ι κ : Type*} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ] (ξ : κ → C(Interval,Interval)) (hc : ∀ t,∃ j,∃ s,ξ j s=t) : Function.Injective (diagonalContinuousHom (ι:=ι) ξ) := by intro f g h apply ContinuousMap.ext intro t obtain ⟨j,s,rfl⟩ := hc t exact congrFun (blockDiagonalHom_injective (congrArg (fun x : C(Interval,CStarMatrix (ι×κ) (ι×κ) ℂ) => x s) h)) j lemma connectingAmbient_injective_cover {P Q : ℕ} {ρ : Type*} [Fintype ρ] [DecidableEq ρ] (ξ : ρ → C(Interval,Interval)) (e : ((Fin p×Fin q)×ρ)≃(Fin P×Fin Q)) (u₀ u₁ : unitary (TensorMat P Q)) (hc : ∀ t,∃ j,∃ s,ξ j s=t) : Function.Injective (connectingAmbient ξ e u₀ u₁) := (continuousUnitaryConjugation_injective _).comp ((continuousReindex_injective e).comp (diagonalContinuousHom_injective_cover ξ hc)) theorem step_injective (m : Multiplicities p q) : Function.Injective (step m) := by intro f g h apply Subtype.ext apply connectingAmbient_injective_cover _ _ _ _ (family_cover m) exact congrArg (fun x : DimensionDrop (p*m.k) (q*m.l) => (x : C(Interval,TensorMat (p*m.k) (q*m.l)))) h end OriginalJiangSu namespace OriginalJiangSu open JiangSuConstruction open scoped CStarAlgebra ComplexOrder abbrev Stage (n : ℕ) : Type := ↥(DimensionDrop (pair n).p (pair n).q) end OriginalJiangSu namespace OriginalJiangSu open JiangSuConstruction open scoped CStarAlgebra ComplexOrder local instance (priority := 2000) stageSemiring (n : ℕ) : Semiring (Stage n) := (inferInstance : CStarAlgebra (Stage n)).toSemiring instance stageNontrivial (n : ℕ) : Nontrivial (Stage n) := by let : NeZero (pair n).p := ⟨by have := (pair n).p_gt; omega⟩ let : NeZero (pair n).q := ⟨by have := (pair n).q_gt; omega⟩ infer_instance def stageStep (n : ℕ) : Stage n →⋆ₐ[ℂ] Stage (n+1) := step (multiplicities (pair n)) lemma stageStep_injective (n : ℕ) : Function.Injective (stageStep n) := step_injective _ def system : SequentialCStar.System Stage := SequentialCStar.System.ofSequence stageStep stageStep_injective abbrev Algebra := system.Limit instance limitNontrivial : Nontrivial Algebra := (system.inclusion_isometry 0).injective.nontrivial instance algebraOrder : PartialOrder Algebra := CStarAlgebra.spectralOrder _ instance algebraStarOrder : StarOrderedRing Algebra := CStarAlgebra.spectralOrderedRing _ end OriginalJiangSu namespace SequentialCStar.System open Filter Topology variable {C : ℕ→Type*} [∀ n,CStarAlgebra (C n)] [∀ n,Nontrivial (C n)] variable [∀ n,TopologicalSpace.SeparableSpace (C n)] (S : System C) theorem exists_dense_stage_sequence : ∃ d : ℕ→S.Limit,DenseRange d ∧ d 0=algebraMap ℂ S.Limit Complex.I ∧ ∀ j,∃ (n : ℕ) (a : C n),S.inclusion n a=d j := by classical choose c hc using (fun n=>TopologicalSpace.exists_dense_seq (C n)) let e : ℕ×ℕ→S.Limit := fun z=>S.inclusion z.1 (c z.1 z.2) have he : DenseRange e := by intro x apply Metric.mem_closure_iff.mpr intro ε hε obtain ⟨n,b,hb⟩ := S.finite_stage_approximation x (half_pos hε) obtain ⟨z,⟨k,rfl⟩,hz⟩ := Metric.mem_closure_iff.mp (hc n b) (ε/2) (half_pos hε) refine ⟨e (n,k),⟨(n,k),rfl⟩,?_⟩ have hin := (S.inclusion_isometry n).dist_eq b (c n k) change dist x (S.inclusion n (c n k))<ε have htri := dist_triangle x (S.inclusion n b) (S.inclusion n (c n k)) rw [hin] at htri simp only [dist_eq_norm] at htri hz ⊢ linarith let d : ℕ→S.Limit | 0=>algebraMap ℂ S.Limit Complex.I | j+1=>e (Nat.unpair j) refine ⟨d,he.mono ?_,rfl,?_⟩ · rintro x ⟨⟨n,k⟩,rfl⟩ exact ⟨Nat.pair n k+1,by simp [d,Nat.unpair_pair]⟩ · intro j cases j with | zero => exact ⟨0,algebraMap ℂ (C 0) Complex.I,(S.inclusion 0).commutes _⟩ | succ j => exact ⟨(Nat.unpair j).1,c (Nat.unpair j).1 (Nat.unpair j).2,rfl⟩ end SequentialCStar.System namespace OriginalJiangSu open Pureness JiangSuConstruction open scoped CStarAlgebra ComplexOrder local instance stageSeparable (n : ℕ) : TopologicalSpace.SeparableSpace (Stage n) := by infer_instance instance algebraSeparable : TopologicalSpace.SeparableSpace Algebra := by obtain ⟨d,hd,-,-⟩ := system.exists_dense_stage_sequence exact hd.separableSpace (continuous_of_discreteTopology) end OriginalJiangSu namespace FourEdgeSurgery variable {G : Type*} [Group G] structure Flow (G : Type*) [Group G] where toFun : ℝ → G zero : toFun 0=1 add : ∀ r s,toFun (r+s)=toFun r*toFun s instance : CoeFun (Flow G) (fun _ => ℝ → G) := ⟨Flow.toFun⟩ lemma Flow.map_add (p : Flow G) (r s : ℝ) : p (r+s)=p r*p s := p.add r s end FourEdgeSurgery namespace Pureness open scoped TensorProduct variable {A B N : Type*} [CStarAlgebra A] [CStarAlgebra B] [CStarAlgebra N] variable (φ : A →⋆ₐ[ℂ] N) (ψ : B →⋆ₐ[ℂ] N) variable (hc : ∀ a b, Commute (φ a) (ψ b)) def commutingTensorClosure : StarSubalgebra ℂ N := (commutingStarTensorHom φ ψ hc).range.topologicalClosure instance commutingTensorClosure_closed : IsClosed (commutingTensorClosure φ ψ hc : Set N) := StarSubalgebra.isClosed_topologicalClosure _ instance commutingTensorClosureCStarAlgebra : CStarAlgebra (commutingTensorClosure φ ψ hc) := StarSubalgebra.cstarAlgebra _ end Pureness namespace NonunitalTensor open scoped CStarAlgebra TensorProduct variable {A D E : Type*} [NonUnitalCStarAlgebra A] [CStarAlgebra D] [CStarAlgebra E] variable (j : A →⋆ₙₐ[ℂ] E) (κ : D →⋆ₐ[ℂ] E) def elementarySet : Set E := {x | ∃ a : A,∃ d : D,x=j a*κ d} def coefficientSpan : Submodule ℂ E := Submodule.span ℂ (elementarySet j κ) lemma coefficientSpan_mem (a : A) (d : D) : j a*κ d∈coefficientSpan j κ := Submodule.subset_span ⟨a,d,rfl⟩ end NonunitalTensor namespace NonunitalTensor open scoped CStarAlgebra TensorProduct variable {A D E : Type*} [NonUnitalCStarAlgebra A] [CStarAlgebra D] [CStarAlgebra E] variable (j : A →⋆ₙₐ[ℂ] E) (κ : D →⋆ₐ[ℂ] E) variable (hc : ∀ a d,Commute (j a) (κ d)) include hc lemma span_mul_mem {x y : E} (hx : x∈coefficientSpan j κ) (hy : y∈coefficientSpan j κ) : x*y∈coefficientSpan j κ := by induction hx using Submodule.span_induction with | mem x hx => obtain ⟨a,d,rfl⟩ := hx induction hy using Submodule.span_induction with | mem y hy => obtain ⟨b,e,rfl⟩ := hy have he : (j a*κ d)*(j b*κ e)=j (a*b)*κ (d*e) := by rw [map_mul,map_mul] calc _=j a*(κ d*j b)*κ e := by simp only [mul_assoc] _=j a*(j b*κ d)*κ e := by rw [(hc b d).symm.eq] _=_ := by simp only [mul_assoc] rw [he] exact coefficientSpan_mem j κ _ _ | zero => simp | add y z hy hz ihy ihz => simpa only [mul_add] using (coefficientSpan j κ).add_mem ihy ihz | smul c y hy ih => simpa only [mul_smul_comm] using (coefficientSpan j κ).smul_mem c ih | zero => simp | add x z hx hz ihx ihz => simpa only [add_mul] using (coefficientSpan j κ).add_mem ihx ihz | smul c x hx ih => simpa only [smul_mul_assoc] using (coefficientSpan j κ).smul_mem c ih lemma span_star_mem {x : E} (hx : x∈coefficientSpan j κ) : star x∈coefficientSpan j κ := by induction hx using Submodule.span_induction with | mem x hx => obtain ⟨a,d,rfl⟩ := hx rw [star_mul,←map_star,←map_star,←(hc (star a) (star d)).eq] exact coefficientSpan_mem j κ _ _ | zero => simp | add x y hx hy ihx ihy => simpa only [star_add] using (coefficientSpan j κ).add_mem ihx ihy | smul c x hx ih => simpa only [star_smul] using (coefficientSpan j κ).smul_mem (star c) ih def coefficientAlgebra : NonUnitalStarSubalgebra ℂ E where carrier := coefficientSpan j κ zero_mem' := (coefficientSpan j κ).zero_mem add_mem' := (coefficientSpan j κ).add_mem smul_mem' := fun c _ hx => (coefficientSpan j κ).smul_mem c hx mul_mem' := span_mul_mem j κ hc star_mem' := span_star_mem j κ hc def tensorIdeal : NonUnitalStarSubalgebra ℂ E := (coefficientAlgebra j κ hc).topologicalClosure instance tensorIdeal_closed : IsClosed (tensorIdeal j κ hc : Set E) := NonUnitalStarSubalgebra.isClosed_topologicalClosure _ instance : NonUnitalCStarAlgebra (tensorIdeal j κ hc) := NonUnitalStarSubalgebra.nonUnitalCStarAlgebra _ end NonunitalTensor namespace NonunitalTensor open scoped CStarAlgebra TensorProduct variable {A D E : Type*} [NonUnitalCStarAlgebra A] [CStarAlgebra D] [CStarAlgebra E] variable (γ : Unitization ℂ A →⋆ₐ[ℂ] E) (κ : D →⋆ₐ[ℂ] E) variable (hc : ∀ a d,Commute (γ a) (κ d)) def originalHom : A →⋆ₙₐ[ℂ] E := γ.toNonUnitalStarAlgHom.comp (Unitization.inrNonUnitalStarAlgHom ℂ A) include hc in lemma original_commute (a : A) (d : D) : Commute (originalHom γ a) (κ d) := hc (Unitization.inr a) d end NonunitalTensor namespace ActualHilbertTensor open scoped TensorProduct InnerProductSpace variable (H K : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] [NormedAddCommGroup K] [InnerProductSpace ℂ K] def TensorSpace := UniformSpace.Completion (H ⊗[ℂ] K) instance normedAddCommGroup : NormedAddCommGroup (TensorSpace H K) := inferInstanceAs (NormedAddCommGroup (UniformSpace.Completion (H ⊗[ℂ] K))) instance innerProductSpace : InnerProductSpace ℂ (TensorSpace H K) := inferInstanceAs (InnerProductSpace ℂ (UniformSpace.Completion (H ⊗[ℂ] K))) instance completeSpace : CompleteSpace (TensorSpace H K) := inferInstanceAs (CompleteSpace (UniformSpace.Completion (H ⊗[ℂ] K))) end ActualHilbertTensor namespace ActualSpatial open Pureness UnitalTomsWinter open scoped CStarAlgebra TensorProduct InnerProductSpace variable (A D : Type*) [CStarAlgebra A] [CStarAlgebra D] variable [PartialOrder A] [StarOrderedRing A] [PartialOrder D] [StarOrderedRing D] def Hilbert := ActualHilbertTensor.TensorSpace (StateHilbertSpace A) (StateHilbertSpace D) instance hilbertNormedAddCommGroup : NormedAddCommGroup (Hilbert A D) := inferInstanceAs (NormedAddCommGroup (ActualHilbertTensor.TensorSpace (StateHilbertSpace A) (StateHilbertSpace D))) instance hilbertInnerProductSpace : InnerProductSpace ℂ (Hilbert A D) := inferInstanceAs (InnerProductSpace ℂ (ActualHilbertTensor.TensorSpace (StateHilbertSpace A) (StateHilbertSpace D))) instance hilbertCompleteSpace : CompleteSpace (Hilbert A D) := inferInstanceAs (CompleteSpace (ActualHilbertTensor.TensorSpace (StateHilbertSpace A) (StateHilbertSpace D))) abbrev Op := Hilbert A D →L[ℂ] Hilbert A D abbrev repA := stateHilbertRepresentation A def leftAction : A →⋆ₐ[ℂ] Op A D := spatialLeftHom (K := StateHilbertSpace D) (repA A) def rightAction : D →⋆ₐ[ℂ] Op A D := spatialRightHom (H := StateHilbertSpace A) (repA D) lemma commute (a : A) (d : D) : Commute (leftAction A D a) (rightAction A D d) := spatialLeftRight_commute (repA A) (repA D) a d abbrev Tensor := commutingTensorClosure (N := Op A D) (leftAction A D) (rightAction A D) (commute A D) instance : PartialOrder (Tensor A D) := CStarAlgebra.spectralOrder _ instance : StarOrderedRing (Tensor A D) := CStarAlgebra.spectralOrderedRing _ def leftHom : A →⋆ₐ[ℂ] Tensor A D := (leftAction A D).codRestrict _ (fun a => by apply StarSubalgebra.le_topologicalClosure exact ⟨a ⊗ₜ[ℂ] (1 : D),by simp [commutingStarTensorHom_tmul]⟩) def rightHom : D →⋆ₐ[ℂ] Tensor A D := (rightAction A D).codRestrict _ (fun d => by apply StarSubalgebra.le_topologicalClosure exact ⟨(1 : A) ⊗ₜ[ℂ] d,by simp [commutingStarTensorHom_tmul]⟩) lemma homs_commute (a : A) (d : D) : Commute (leftHom A D a) (rightHom A D d) := by apply Subtype.ext exact commute A D a d end ActualSpatial namespace ActualSpatial open Pureness Filter open scoped CStarAlgebra TensorProduct universe u v variable (A : Type u) (D : Type v) [CStarAlgebra A] [CStarAlgebra D] variable [PartialOrder A] [StarOrderedRing A] [PartialOrder D] [StarOrderedRing D] lemma commuting_range_eq_span : Set.range (commutingStarTensorHom (leftAction A D) (rightAction A D) (commute A D)) = (Submodule.span ℂ (Set.range (fun z : A×D => leftAction A D z.1*rightAction A D z.2)) : Set (Op A D)) := by let f := commutingStarTensorHom (leftAction A D) (rightAction A D) (commute A D) let M := Submodule.span ℂ (Set.range (fun z : A×D => leftAction A D z.1*rightAction A D z.2)) apply Set.Subset.antisymm · rintro _ ⟨z,rfl⟩ change _ ∈ M induction z using TensorProduct.inductionOn with | tmul a d => exact Submodule.subset_span ⟨(a,d),rfl⟩ | add x y hx hy => simpa only [map_add] using M.add_mem hx hy · change (M : Set (Op A D)) ⊆ f.toLinearMap.range apply SetLike.coe_subset_coe.mpr apply Submodule.span_le.mpr rintro _ ⟨⟨a,d⟩,rfl⟩ exact ⟨a ⊗ₜ[ℂ] d,rfl⟩ instance tensorSeparable [TopologicalSpace.SeparableSpace A] [TopologicalSpace.SeparableSpace D] : TopologicalSpace.SeparableSpace (Tensor A D) := by have hs : TopologicalSpace.IsSeparable (Set.range (fun z : A×D => leftAction A D z.1*rightAction A D z.2)) := TopologicalSpace.isSeparable_range (by fun_prop) have he : (Tensor A D : Set (Op A D)) = closure (Submodule.span ℂ (Set.range (fun z : A×D => leftAction A D z.1*rightAction A D z.2)) : Set (Op A D)) := by change closure (Set.range (commutingStarTensorHom (leftAction A D) (rightAction A D) (commute A D))) = _ rw [commuting_range_eq_span] apply TopologicalSpace.IsSeparable.separableSpace rw [he] exact (hs.span (R := ℂ)).closure end ActualSpatial namespace ActualSpatial open Pureness NonunitalTensor NonunitalGamma Filter open scoped CStarAlgebra TensorProduct universe u variable (A : Type*) (D : Type u) [NonUnitalCStarAlgebra A] [CStarAlgebra D] variable [PartialOrder A] [StarOrderedRing A] [PartialOrder D] [StarOrderedRing D] abbrev nonunitalIdeal : NonUnitalStarSubalgebra ℂ (Tensor (Unitization ℂ A) D) := tensorIdeal (originalHom (leftHom (Unitization ℂ A) D)) (rightHom (Unitization ℂ A) D) (original_commute (leftHom (Unitization ℂ A) D) (rightHom (Unitization ℂ A) D) (homs_commute (Unitization ℂ A) D)) def NonunitalTensor : Type _ := ↥(nonunitalIdeal A D) instance : NonUnitalCStarAlgebra (NonunitalTensor A D) := NonUnitalStarSubalgebra.nonUnitalCStarAlgebra (A := Tensor (Unitization ℂ A) D) (nonunitalIdeal A D) end ActualSpatial end end OAI