| import OAI.Analysis.CStarAlgebra.PureInfiniteness.Hereditary |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Filter |
| open scoped Topology CStarAlgebra ComplexOrder InnerProductSpace |
|
|
| namespace MainGap |
|
|
| variable {A : Type*} [NonUnitalCStarAlgebra A] |
|
|
| local instance positivityOrder : PartialOrder A := CStarAlgebra.spectralOrder A |
| local instance positivityStarOrder : StarOrderedRing A := CStarAlgebra.spectralOrderedRing A |
|
|
| def FiniteCuntzLE {m n : ℕ} (d : CStarMatrix (Fin n) (Fin n) A) |
| (v : CStarMatrix (Fin m) (Fin m) A) : Prop := |
| ∃ r : ℕ → CStarMatrix (Fin m) (Fin n) A, |
| Tendsto (fun j => (r j).conjTranspose * v * r j) atTop (𝓝 d) |
|
|
| def scalarCorner (h : A) : CStarMatrix (Fin 1) (Fin 1) A := |
| CStarMatrix.ofMatrix (fun _ _ => h) |
|
|
| def doubleCorner (h : A) : CStarMatrix (Fin 2) (Fin 2) A := |
| CStarMatrix.ofMatrix (Matrix.diagonal (fun _ => h)) |
|
|
| def ProperlyInfinite (h : A) : Prop := |
| FiniteCuntzLE (doubleCorner h) (scalarCorner h) |
|
|
| def PropertyP (A : Type*) [NonUnitalCStarAlgebra A] : Prop := |
| ∀ h : A, 0 ≤ h → ProperlyInfinite h |
|
|
| def Diagonalization (a b c : A) (ε : ℝ) : Prop := |
| ∃ s t : A, |
| ‖star s * a * s - a‖ < ε ∧ |
| ‖star t * b * t - b‖ < ε ∧ |
| ‖star s * c * t‖ < ε |
|
|
| def UnrestrictedDiagonalization (A : Type*) [NonUnitalCStarAlgebra A] : Prop := |
| ∀ a b : A, 0 ≤ a → 0 ≤ b → ∀ c : A, ∀ ε : ℝ, 0 < ε → |
| Diagonalization a b c ε |
|
|
| def StronglyPurelyInfinite (A : Type*) [NonUnitalCStarAlgebra A] : Prop := |
| ∀ x y : A, 0 ≤ x → 0 ≤ y → ∀ ε : ℝ, 0 < ε → |
| Diagonalization (x * x) (y * y) (x * y) ε |
|
|
| lemma matrix_mul_assoc {l m n k : ℕ} (x : CStarMatrix (Fin l) (Fin m) A) |
| (y : CStarMatrix (Fin m) (Fin n) A) (z : CStarMatrix (Fin n) (Fin k) A) : |
| (x * y) * z = x * (y * z) := Matrix.mul_assoc x y z |
|
|
| lemma matrix_star_mul {l m n : ℕ} (x : CStarMatrix (Fin l) (Fin m) A) |
| (y : CStarMatrix (Fin m) (Fin n) A) : |
| (x * y).conjTranspose = y.conjTranspose * x.conjTranspose := |
| Matrix.conjTranspose_mul x y |
|
|
| lemma continuous_matrix_mul {X : Type*} [TopologicalSpace X] {l m n : ℕ} |
| {x : X → CStarMatrix (Fin l) (Fin m) A} {y : X → CStarMatrix (Fin m) (Fin n) A} |
| (hx : Continuous x) (hy : Continuous y) : Continuous (fun t => x t * y t) := |
| hx.matrix_mul hy |
|
|
| lemma continuous_matrix_star {X : Type*} [TopologicalSpace X] {l m : ℕ} |
| {x : X → CStarMatrix (Fin l) (Fin m) A} (hx : Continuous x) : |
| Continuous (fun t => (x t).conjTranspose) := by |
| change Continuous (fun t => Matrix.conjTranspose (x t)) |
| fun_prop |
|
|
| lemma finiteCuntzLE_iff_closure {m n : ℕ} (d : CStarMatrix (Fin n) (Fin n) A) |
| (v : CStarMatrix (Fin m) (Fin m) A) : |
| FiniteCuntzLE d v ↔ d ∈ closure (Set.range |
| (fun r : CStarMatrix (Fin m) (Fin n) A => r.conjTranspose * v * r)) := by |
| rw [mem_closure_iff_seq_limit] |
| constructor |
| · rintro ⟨r, hr⟩ |
| exact ⟨_, fun j => ⟨r j, rfl⟩, hr⟩ |
| · rintro ⟨x, hx, ht⟩ |
| choose r hr using hx |
| exact ⟨r, by simpa only [hr] using ht⟩ |
|
|
| lemma FiniteCuntzLE.exists_approx {m n : ℕ} {d : CStarMatrix (Fin n) (Fin n) A} |
| {v : CStarMatrix (Fin m) (Fin m) A} (h : FiniteCuntzLE d v) |
| {ε : ℝ} (hε : 0 < ε) : |
| ∃ r : CStarMatrix (Fin m) (Fin n) A, ‖d - r.conjTranspose * v * r‖ < ε := by |
| rw [finiteCuntzLE_iff_closure, Metric.mem_closure_iff] at h |
| obtain ⟨x, ⟨r, rfl⟩, hr⟩ := h ε hε |
| exact ⟨r, by simpa only [dist_eq_norm] using hr⟩ |
|
|
| lemma finiteCuntzLE_of_forall_approx {m n : ℕ} {d : CStarMatrix (Fin n) (Fin n) A} |
| {v : CStarMatrix (Fin m) (Fin m) A} |
| (h : ∀ ε > 0, ∃ r : CStarMatrix (Fin m) (Fin n) A, |
| ‖d - r.conjTranspose * v * r‖ < ε) : FiniteCuntzLE d v := by |
| rw [finiteCuntzLE_iff_closure, Metric.mem_closure_iff] |
| intro ε hε |
| obtain ⟨r, hr⟩ := h ε hε |
| exact ⟨_, ⟨r, rfl⟩, by simpa only [dist_eq_norm] using hr⟩ |
|
|
| lemma FiniteCuntzLE.conjugate {l m n : ℕ} {d : CStarMatrix (Fin n) (Fin n) A} |
| {v : CStarMatrix (Fin m) (Fin m) A} (hdv : FiniteCuntzLE d v) |
| (x : CStarMatrix (Fin n) (Fin l) A) : |
| FiniteCuntzLE (x.conjTranspose * d * x) v := by |
| obtain ⟨r, hr⟩ := hdv |
| refine ⟨fun j => r j * x, ?_⟩ |
| have hc : Continuous (fun d : CStarMatrix (Fin n) (Fin n) A => |
| x.conjTranspose * d * x) := |
| continuous_matrix_mul (continuous_matrix_mul continuous_const continuous_id) continuous_const |
| convert hc.continuousAt.tendsto.comp hr using 1 |
| ext j |
| rw [matrix_star_mul] |
| simp only [Function.comp_apply, matrix_mul_assoc] |
|
|
| lemma FiniteCuntzLE.trans {l m n : ℕ} {d : CStarMatrix (Fin n) (Fin n) A} |
| {v : CStarMatrix (Fin m) (Fin m) A} {w : CStarMatrix (Fin l) (Fin l) A} |
| (hdv : FiniteCuntzLE d v) (hvw : FiniteCuntzLE v w) : FiniteCuntzLE d w := by |
| rw [finiteCuntzLE_iff_closure] at hdv ⊢ |
| apply closure_minimal _ isClosed_closure hdv |
| rintro _ ⟨x, rfl⟩ |
| exact (finiteCuntzLE_iff_closure _ _).mp (hvw.conjugate x) |
|
|
| lemma isClosed_finiteCuntzLE {m n : ℕ} (v : CStarMatrix (Fin m) (Fin m) A) : |
| IsClosed {d : CStarMatrix (Fin n) (Fin n) A | FiniteCuntzLE d v} := by |
| simp_rw [finiteCuntzLE_iff_closure] |
| exact isClosed_closure |
|
|
| lemma FiniteCuntzLE.of_tendsto {m n : ℕ} {v : CStarMatrix (Fin m) (Fin m) A} |
| {d : ℕ → CStarMatrix (Fin n) (Fin n) A} {u : CStarMatrix (Fin n) (Fin n) A} |
| (hd : ∀ j, FiniteCuntzLE (d j) v) (ht : Tendsto d atTop (𝓝 u)) : |
| FiniteCuntzLE u v := (isClosed_finiteCuntzLE v).mem_of_tendsto ht (Eventually.of_forall hd) |
|
|
| lemma FiniteCuntzLE.refl {n : ℕ} (v : CStarMatrix (Fin n) (Fin n) A) : |
| FiniteCuntzLE v v := by |
| let M := CStarMatrix (Fin n) (Fin n) A |
| let : PartialOrder M := CStarAlgebra.spectralOrder M |
| let : StarOrderedRing M := CStarAlgebra.spectralOrderedRing M |
| have hu := CStarAlgebra.increasingApproximateUnit M |
| apply finiteCuntzLE_of_forall_approx |
| intro ε hε |
| have hl : ∀ᶠ e : M in CStarAlgebra.approximateUnit M, ‖v - v * e‖ < ε / 2 := by |
| have ht := ((tendsto_const_nhds (x := v)).sub (hu.tendsto_mul_left v)).norm |
| simpa only [sub_self, norm_zero] using ht.eventually (Iio_mem_nhds (by simpa only [sub_self, norm_zero] using half_pos hε)) |
| have hr : ∀ᶠ e : M in CStarAlgebra.approximateUnit M, ‖v - e * v‖ < ε / 2 := by |
| have ht := ((tendsto_const_nhds (x := v)).sub (hu.tendsto_mul_right v)).norm |
| simpa only [sub_self, norm_zero] using ht.eventually (Iio_mem_nhds (by simpa only [sub_self, norm_zero] using half_pos hε)) |
| obtain ⟨e, hesa, hen, hel, her⟩ := |
| (hu.eventually_star_eq.and (hu.eventually_norm.and (hl.and hr))).exists |
| refine ⟨e, ?_⟩ |
| change ‖v - star e * v * e‖ < ε |
| rw [hesa] |
| calc |
| ‖v - e * v * e‖ = ‖(v - e * v) + e * (v - v * e)‖ := by rw [mul_sub, ← mul_assoc]; congr 1; abel |
| _ ≤ ‖v - e * v‖ + ‖e‖ * ‖v - v * e‖ := |
| (norm_add_le _ _).trans (add_le_add_right (norm_mul_le _ _) _) |
| _ ≤ ‖v - e * v‖ + ‖v - v * e‖ := by nlinarith [norm_nonneg (v - v * e)] |
| _ < ε := by linarith |
|
|
| def matrixBlock {m n p q : ℕ} (x : CStarMatrix (Fin m) (Fin n) A) |
| (y : CStarMatrix (Fin p) (Fin q) A) : CStarMatrix (Fin (m+p)) (Fin (n+q)) A := |
| CStarMatrix.ofMatrix ((Matrix.fromBlocks (CStarMatrix.ofMatrix.symm x) 0 0 (CStarMatrix.ofMatrix.symm y)).submatrix |
| finSumFinEquiv.symm finSumFinEquiv.symm) |
|
|
| lemma matrixBlock_mul {m n p q r s : ℕ} |
| (x : CStarMatrix (Fin m) (Fin n) A) (y : CStarMatrix (Fin p) (Fin q) A) |
| (u : CStarMatrix (Fin n) (Fin r) A) (v : CStarMatrix (Fin q) (Fin s) A) : |
| matrixBlock x y * matrixBlock u v = matrixBlock (x * u) (y * v) := by |
| apply CStarMatrix.ofMatrix.symm.injective |
| change (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm x) 0 0 (CStarMatrix.ofMatrix.symm y)).submatrix |
| finSumFinEquiv.symm finSumFinEquiv.symm * |
| (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm u) 0 0 (CStarMatrix.ofMatrix.symm v)).submatrix |
| finSumFinEquiv.symm finSumFinEquiv.symm = |
| (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm x * CStarMatrix.ofMatrix.symm u) 0 0 |
| (CStarMatrix.ofMatrix.symm y * CStarMatrix.ofMatrix.symm v)).submatrix _ _ |
| rw [Matrix.submatrix_mul_equiv, Matrix.fromBlocks_multiply] |
| simp only [Matrix.zero_mul, Matrix.mul_zero, add_zero, zero_add] |
|
|
| lemma matrixBlock_star {m n p q : ℕ} |
| (x : CStarMatrix (Fin m) (Fin n) A) (y : CStarMatrix (Fin p) (Fin q) A) : |
| (matrixBlock x y).conjTranspose = matrixBlock x.conjTranspose y.conjTranspose := by |
| apply CStarMatrix.ext |
| intro i j |
| change star (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm x) 0 0 (CStarMatrix.ofMatrix.symm y) (finSumFinEquiv.symm j) (finSumFinEquiv.symm i)) = _ |
| generalize hi : finSumFinEquiv.symm i = i' |
| generalize hj : finSumFinEquiv.symm j = j' |
| cases i' <;> cases j' <;> simp [matrixBlock, Matrix.fromBlocks, Matrix.submatrix, hi, hj] |
|
|
| lemma continuous_matrixBlock {X : Type*} [TopologicalSpace X] {m n p q : ℕ} |
| {x : X → CStarMatrix (Fin m) (Fin n) A} {y : X → CStarMatrix (Fin p) (Fin q) A} |
| (hx : Continuous x) (hy : Continuous y) : Continuous (fun t => matrixBlock (x t) (y t)) := by |
| change Continuous (fun t => (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm (x t)) 0 0 |
| (CStarMatrix.ofMatrix.symm (y t))).submatrix finSumFinEquiv.symm finSumFinEquiv.symm) |
| apply continuous_pi |
| intro i |
| apply continuous_pi |
| intro j |
| change Continuous (fun t => Matrix.fromBlocks (CStarMatrix.ofMatrix.symm (x t)) 0 0 |
| (CStarMatrix.ofMatrix.symm (y t)) (finSumFinEquiv.symm i) (finSumFinEquiv.symm j)) |
| cases finSumFinEquiv.symm i with |
| | inl i' => |
| cases finSumFinEquiv.symm j with |
| | inl j' => |
| change Continuous (fun t => CStarMatrix.ofMatrix.symm (x t) i' j') |
| exact (continuous_apply j').comp ((continuous_apply i').comp hx) |
| | inr j' => exact continuous_const |
| | inr i' => |
| cases finSumFinEquiv.symm j with |
| | inl j' => exact continuous_const |
| | inr j' => |
| change Continuous (fun t => CStarMatrix.ofMatrix.symm (y t) i' j') |
| exact (continuous_apply j').comp ((continuous_apply i').comp hy) |
|
|
| lemma tendsto_matrixBlock {X : Type*} {f : Filter X} {m n p q : ℕ} |
| {x : X → CStarMatrix (Fin m) (Fin n) A} {y : X → CStarMatrix (Fin p) (Fin q) A} |
| {u : CStarMatrix (Fin m) (Fin n) A} {v : CStarMatrix (Fin p) (Fin q) A} |
| (hx : Tendsto x f (𝓝 u)) (hy : Tendsto y f (𝓝 v)) : |
| Tendsto (fun t => matrixBlock (x t) (y t)) f (𝓝 (matrixBlock u v)) := by |
| change Tendsto (fun t => CStarMatrix.ofMatrix.symm (matrixBlock (x t) (y t))) f |
| (𝓝 (CStarMatrix.ofMatrix.symm (matrixBlock u v))) |
| apply tendsto_pi_nhds.mpr |
| intro i |
| apply tendsto_pi_nhds.mpr |
| intro j |
| change Tendsto (fun t => Matrix.fromBlocks (CStarMatrix.ofMatrix.symm (x t)) 0 0 |
| (CStarMatrix.ofMatrix.symm (y t)) (finSumFinEquiv.symm i) (finSumFinEquiv.symm j)) f |
| (𝓝 (Matrix.fromBlocks (CStarMatrix.ofMatrix.symm u) 0 0 |
| (CStarMatrix.ofMatrix.symm v) (finSumFinEquiv.symm i) (finSumFinEquiv.symm j))) |
| cases finSumFinEquiv.symm i with |
| | inl i' => |
| cases finSumFinEquiv.symm j with |
| | inl j' => exact (hx.apply_nhds i').apply_nhds j' |
| | inr j' => exact tendsto_const_nhds |
| | inr i' => |
| cases finSumFinEquiv.symm j with |
| | inl j' => exact tendsto_const_nhds |
| | inr j' => exact (hy.apply_nhds i').apply_nhds j' |
|
|
| lemma matrixBlock_conjugate {m n p q : ℕ} |
| (r : CStarMatrix (Fin m) (Fin n) A) (s : CStarMatrix (Fin p) (Fin q) A) |
| (v : CStarMatrix (Fin m) (Fin m) A) (w : CStarMatrix (Fin p) (Fin p) A) : |
| (matrixBlock r s).conjTranspose * matrixBlock v w * matrixBlock r s = |
| matrixBlock (r.conjTranspose * v * r) (s.conjTranspose * w * s) := by |
| rw [matrixBlock_star, matrixBlock_mul, matrixBlock_mul] |
|
|
| lemma FiniteCuntzLE.block {m n p q : ℕ} |
| {d : CStarMatrix (Fin n) (Fin n) A} {v : CStarMatrix (Fin m) (Fin m) A} |
| {d' : CStarMatrix (Fin q) (Fin q) A} {v' : CStarMatrix (Fin p) (Fin p) A} |
| (h : FiniteCuntzLE d v) (h' : FiniteCuntzLE d' v') : |
| FiniteCuntzLE (matrixBlock d d') (matrixBlock v v') := by |
| obtain ⟨r, hr⟩ := h |
| obtain ⟨s, hs⟩ := h' |
| refine ⟨fun j => matrixBlock (r j) (s j), ?_⟩ |
| have heq : (fun j => (matrixBlock (r j) (s j)).conjTranspose * |
| matrixBlock v v' * matrixBlock (r j) (s j)) = |
| (fun j => matrixBlock ((r j).conjTranspose * v * r j) |
| ((s j).conjTranspose * v' * s j)) := by |
| funext j |
| exact matrixBlock_conjugate (r j) (s j) v v' |
| rw [heq] |
| exact tendsto_matrixBlock hr hs |
|
|
| def diagonalCorner (n : ℕ) (h : A) : CStarMatrix (Fin n) (Fin n) A := |
| CStarMatrix.ofMatrix (Matrix.diagonal (fun _ => h)) |
|
|
| lemma matrixBlock_diagonal (n m : ℕ) (h : A) : |
| matrixBlock (diagonalCorner n h) (diagonalCorner m h) = diagonalCorner (n+m) h := by |
| apply CStarMatrix.ext |
| intro i j |
| change (Matrix.fromBlocks (Matrix.diagonal (fun _ => h)) 0 0 |
| (Matrix.diagonal (fun _ => h))).submatrix _ _ i j = _ |
| rw [Matrix.fromBlocks_diagonal] |
| simp only [Matrix.submatrix_apply, Matrix.diagonal_apply, diagonalCorner, |
| CStarMatrix.ofMatrix_apply, Equiv.apply_eq_iff_eq] |
| split_ifs with hij |
| · cases finSumFinEquiv.symm i <;> rfl |
| · rfl |
|
|
| lemma diagonalCorner_one (h : A) : diagonalCorner 1 h = scalarCorner h := by |
| ext i j |
| have hij : i = j := Subsingleton.elim _ _ |
| change Matrix.diagonal (fun _ => h) i j = h |
| simp [Matrix.diagonal, hij] |
|
|
| lemma ProperlyInfinite.finite_copies {h : A} (hh : ProperlyInfinite h) (n : ℕ) : |
| FiniteCuntzLE (diagonalCorner n h) (scalarCorner h) := by |
| induction n with |
| | zero => |
| refine ⟨fun _ => 0, ?_⟩ |
| have heq : (fun _ : ℕ => (0 : CStarMatrix (Fin 1) (Fin 0) A).conjTranspose * |
| scalarCorner h * (0 : CStarMatrix (Fin 1) (Fin 0) A)) = fun _ => diagonalCorner 0 h := by |
| funext j |
| apply CStarMatrix.ext |
| intro i |
| exact Fin.elim0 i |
| rw [heq] |
| exact tendsto_const_nhds |
| | succ n hn => |
| have hblock := hn.block (FiniteCuntzLE.refl (scalarCorner h)) |
| rw [← diagonalCorner_one h, matrixBlock_diagonal, matrixBlock_diagonal] at hblock |
| exact hblock.trans hh |
|
|
| end MainGap |
|
|
| end |
|
|
| end OAI |
|
|
