Add lean source and binary files (part 33)

lean/OAI/Analysis/OInfinity/ProjectionCorner.lean

@@ -0,0 +1,166 @@
+import OAI.Analysis.OInfinity.RowCocycleDefect
+
+namespace OAI
+
+/-! # Unital C⋆ structure and unitary paths in a projection corner
+
+The corner has unit `q`; its inclusion in the ambient algebra is nonunital.
+A corner unitary becomes an ambient unitary by adding `1-q`, preserving
+norm differences and therefore the quantitative path estimates.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+def projectionCornerAlgebra (q : E) (hq : star q = q) : NonUnitalStarSubalgebra ℂ E where
+  carrier := {x | q * x = x ∧ x * q = x}
+  zero_mem' := by simp
+  add_mem' hx hy := by
+    exact ⟨by rw [mul_add, hx.1, hy.1], by rw [add_mul, hx.2, hy.2]⟩
+  mul_mem' hx hy := ⟨by rw [← mul_assoc, hx.1], by rw [mul_assoc, hy.2]⟩
+  smul_mem' c x hx :=
+    ⟨by rw [mul_smul_comm, hx.1], by rw [smul_mul_assoc, hx.2]⟩
+  star_mem' hx := ⟨by simpa only [star_mul, hq] using congrArg star hx.2,
+    by simpa only [star_mul, hq] using congrArg star hx.1⟩
+
+lemma projectionCornerAlgebra_closed (q : E) (hq : star q = q) :
+    IsClosed (projectionCornerAlgebra q hq : Set E) :=
+  (isClosed_eq (by fun_prop) continuous_id).inter
+    (isClosed_eq (by fun_prop) continuous_id)
+
+/-- The closed supported corner, equipped below with unit `q`. -/
+abbrev ProjectionCorner (q : E) (hq : star q = q) (_hqq : q * q = q) : Type _ :=
+  projectionCornerAlgebra q hq
+
+instance projectionCornerClosed (q : E) (hq : star q = q) :
+    IsClosed (projectionCornerAlgebra q hq : Set E) := projectionCornerAlgebra_closed q hq
+
+instance projectionCornerSemiring (q : E) (hq : star q = q) (hqq : q * q = q) :
+    Semiring (ProjectionCorner q hq hqq) where
+  __ : NonUnitalSemiring (ProjectionCorner q hq hqq) :=
+    inferInstanceAs (NonUnitalSemiring (projectionCornerAlgebra q hq))
+  one := ⟨q, hqq, hqq⟩
+  one_mul x := Subtype.ext x.property.1
+  mul_one x := Subtype.ext x.property.2
+
+instance projectionCornerRing (q : E) (hq : star q = q) (hqq : q * q = q) :
+    Ring (ProjectionCorner q hq hqq) where
+  __ : Semiring (ProjectionCorner q hq hqq) := projectionCornerSemiring q hq hqq
+  __ : NonUnitalRing (ProjectionCorner q hq hqq) :=
+    inferInstanceAs (NonUnitalRing (projectionCornerAlgebra q hq))
+
+instance projectionCornerNormedRing (q : E) (hq : star q = q) (hqq : q * q = q) :
+    NormedRing (ProjectionCorner q hq hqq) where
+  __ : Ring (ProjectionCorner q hq hqq) := projectionCornerRing q hq hqq
+  __ : NonUnitalNormedRing (ProjectionCorner q hq hqq) :=
+    inferInstanceAs (NonUnitalNormedRing (projectionCornerAlgebra q hq))
+
+instance projectionCornerAlgebraStructure (q : E) (hq : star q = q) (hqq : q * q = q) :
+    Algebra ℂ (ProjectionCorner q hq hqq) :=
+  Algebra.ofModule (fun _ _ _ => Subtype.ext (smul_mul_assoc _ _ _))
+    (fun _ _ _ => Subtype.ext (mul_smul_comm _ _ _))
+
+instance projectionCornerNormedAlgebra (q : E) (hq : star q = q) (hqq : q * q = q) :
+    NormedAlgebra ℂ (ProjectionCorner q hq hqq) where
+  __ := projectionCornerAlgebraStructure q hq hqq
+  norm_smul_le c x := by exact norm_smul_le c (x : E)
+
+instance projectionCornerCStarAlgebra (q : E) (hq : star q = q) (hqq : q * q = q) :
+    CStarAlgebra (ProjectionCorner q hq hqq) where
+  __ : NormedRing (ProjectionCorner q hq hqq) := projectionCornerNormedRing q hq hqq
+  __ : NormedAlgebra ℂ (ProjectionCorner q hq hqq) := projectionCornerNormedAlgebra q hq hqq
+  __ : StarRing (ProjectionCorner q hq hqq) :=
+    inferInstanceAs (StarRing (projectionCornerAlgebra q hq))
+  __ : CompleteSpace (ProjectionCorner q hq hqq) :=
+    inferInstanceAs (CompleteSpace (projectionCornerAlgebra q hq))
+  __ : StarModule ℂ (ProjectionCorner q hq hqq) :=
+    inferInstanceAs (StarModule ℂ (projectionCornerAlgebra q hq))
+  norm_mul_self_le x := (CStarRing.norm_star_mul_self (x := (x : E))).symm.le
+
+instance projectionCornerNontrivial (q : E) (hq : star q = q) (hqq : q * q = q)
+    [NeZero q] : Nontrivial (ProjectionCorner q hq hqq) := by
+  apply nontrivial_of_ne (0 : ProjectionCorner q hq hqq) 1
+  intro h
+  have he := congrArg (fun x : ProjectionCorner q hq hqq => (x : E)) h
+  exact (NeZero.ne q) he.symm
+
+/-- The algebra inclusion sends the corner unit to `q`. -/
+def projectionCornerInclusion (q : E) (hq : star q = q) (hqq : q * q = q) :
+    ProjectionCorner q hq hqq →⋆ₙₐ[ℂ] E where
+  toFun x := x
+  map_zero' := rfl
+  map_add' _ _ := rfl
+  map_mul' _ _ := rfl
+  map_smul' _ _ := rfl
+  map_star' _ := rfl
+
+lemma projectionCornerInclusion_one (q : E) (hq : star q = q) (hqq : q * q = q) :
+    projectionCornerInclusion q hq hqq 1 = q := rfl
+
+/-- Extending by the complementary identity gives an ambient unitary. -/
+def projectionCornerUnitary (q : E) (hq : star q = q) (hqq : q * q = q)
+    (u : unitary (ProjectionCorner q hq hqq)) : unitary E := by
+  let x : E := (u : ProjectionCorner q hq hqq)
+  have hl : q * x = x := (u : ProjectionCorner q hq hqq).property.1
+  have hr : x * q = x := (u : ProjectionCorner q hq hqq).property.2
+  have hxs : star x * x = q := congrArg
+    (fun y : ProjectionCorner q hq hqq => (y : E)) u.property.1
+  have hsx : x * star x = q := congrArg
+    (fun y : ProjectionCorner q hq hqq => (y : E)) u.property.2
+  have hls : q * star x = star x := by
+    simpa only [star_mul, hq] using congrArg star hr
+  have hrs : star x * q = star x := by
+    simpa only [star_mul, hq] using congrArg star hl
+  refine ⟨x + (1 - q), ?_, ?_⟩
+  · change star (x + (1 - q)) * (x + (1 - q)) = 1
+    simp only [star_add, star_sub, star_one, hq, add_mul, mul_add, mul_sub,
+      sub_mul, one_mul, mul_one, hxs, hqq, hl, hrs]
+    abel
+  · change (x + (1 - q)) * star (x + (1 - q)) = 1
+    simp only [star_add, star_sub, star_one, hq, add_mul, mul_add, mul_sub,
+      sub_mul, one_mul, mul_one, hsx, hqq, hr, hls]
+    abel
+
+lemma projectionCornerUnitary_one (q : E) (hq : star q = q) (hqq : q * q = q) :
+    projectionCornerUnitary q hq hqq 1 = 1 := by
+  apply Subtype.ext
+  change q + (1 - q) = 1
+  abel
+
+lemma projectionCornerUnitary_continuous (q : E) (hq : star q = q) (hqq : q * q = q) :
+    Continuous (projectionCornerUnitary q hq hqq) := by
+  apply Continuous.subtype_mk
+  change Continuous (fun u : unitary (ProjectionCorner q hq hqq) =>
+    ((u : ProjectionCorner q hq hqq) : E) + (1 - q))
+  exact (continuous_subtype_val.comp continuous_subtype_val).add continuous_const
+
+lemma projectionCornerUnitary_sub_norm (q : E) (hq : star q = q) (hqq : q * q = q)
+    (u v : unitary (ProjectionCorner q hq hqq)) :
+    ‖(projectionCornerUnitary q hq hqq u : E) - projectionCornerUnitary q hq hqq v‖ =
+      ‖(u : ProjectionCorner q hq hqq) - v‖ := by
+  change ‖(((u : ProjectionCorner q hq hqq) : E) + (1 - q)) -
+    (((v : ProjectionCorner q hq hqq) : E) + (1 - q))‖ =
+      ‖((u : ProjectionCorner q hq hqq) : E) - ((v : ProjectionCorner q hq hqq) : E)‖
+  congr 1
+  abel
+
+/-- Quantitative paths lift to the ambient algebra with no loss. -/
+lemma projectionCornerPath_controlled (q : E) (hq : star q = q) (hqq : q * q = q)
+    {u v : unitary (ProjectionCorner q hq hqq)}
+    (p : Path u v) (L : ℝ)
+    (hp : ∀ a b, ‖(p a : ProjectionCorner q hq hqq) - p b‖ ≤ L * |(a : ℝ) - b|) :
+    ∃ r : Path (projectionCornerUnitary q hq hqq u) (projectionCornerUnitary q hq hqq v),
+      ∀ a b, ‖(r a : E) - r b‖ ≤ L * |(a : ℝ) - b| := by
+  refine ⟨p.map (projectionCornerUnitary_continuous q hq hqq), ?_⟩
+  intro a b
+  exact (projectionCornerUnitary_sub_norm q hq hqq (p a) (p b)).trans_le (hp a b)
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/ProperBufferAbsorption.lean

@@ -0,0 +1,261 @@
+import OAI.Analysis.OInfinity.BufferAnchor
+import OAI.Analysis.OInfinity.ZeroUnitRows
+
+namespace OAI
+
+/-! # Connected absorption of an arbitrary finite proper row
+
+The target row is completed inside the zero-unit buffer corner.  Only the
+prescribed original entries must commute with the binary buffer; the
+auxiliary completing entry is never included in that requirement.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+section Selected
+variable {I : Type*} [Fintype I] [DecidableEq I]
+
+/-- The finite Fock estimate only needs coefficient commutation at the
+indices at which an intertwining estimate is requested. -/
+lemma BufferAbsorptionCorner.exists_finite_absorption_on [Nontrivial E]
+    (D : BufferAbsorptionCorner E) (s t : I → E) (r : E) (P : I → Prop)
+    (hrr : star r * r = 1) (hr : ∀ i, star r * s i = 0)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (hqr : Commute D.q r) (hqs : ∀ i, Commute D.q (s i))
+    (htq : ∀ i, t i * D.q = t i) (ht : ∑ i, t i * star (t i) = D.q)
+    (htt : ∀ i j, star (t i) * t j = if i = j then D.q else 0)
+    (hat : ∀ i, P i → Commute (star D.a) (t i))
+    (hbt : ∀ i, P i → Commute (star D.b) (t i))
+    (ε : ℝ) (hε : 0 < ε) :
+    ∃ W : unitary E, Joined D.anchor W ∧
+      ∀ i, P i → ‖(W : E) * s i - (t i + D.w * s i * star D.w) * (W : E)‖ < ε := by
+  let δ := ε / 6
+  have hδ : 0 < δ := by dsimp only [δ]; positivity
+  obtain ⟨m, hm⟩ := exists_nat_gt (2 / δ ^ 2)
+  have hsmall : 2 / ((m : ℝ) + 1) < δ ^ 2 := by
+    have hδsq : 0 < δ ^ 2 := sq_pos_of_pos hδ
+    have hm' : 2 < (m : ℝ) * δ ^ 2 := (div_lt_iff₀ hδsq).mp hm
+    apply (div_lt_iff₀ (by positivity : 0 < (m : ℝ) + 1)).mpr
+    nlinarith
+  let v := finiteRowIsometry s t r D.q m
+  have hvg : star v * v = D.q := finiteRowIsometry_gram s t r D.q
+    D.projection.isIdempotentElem.eq D.projection.isSelfAdjoint.star_eq hrr hr hs htq ht m
+  have hvq : v * D.q = v := relativeIsometry_mul_support v D.q hvg
+    D.projection.isSelfAdjoint.star_eq D.projection.isIdempotentElem.eq
+  have hqv : D.q * v = v := finiteRowIsometry_left_of_commute s t r D.q
+    D.projection.isIdempotentElem.eq hqr hqs m
+  have hvstarq : star v * D.q = star v := by
+    simpa only [star_mul, D.projection.isSelfAdjoint.star_eq] using congrArg star hqv
+  have hvw : star v * D.w = 0 := by
+    rw [← hvstarq, mul_assoc, D.w_orthogonal, mul_zero]
+  obtain ⟨u, hu, _, huv⟩ := exists_explicit_connected_unitary_extension v D.w
+    (by rw [mul_assoc, hvg, hvq]) D.w_gram (by rw [hvg]; exact D.w_orthogonal)
+    (by rw [mul_assoc, hvw, mul_zero])
+  have huq : (u : E) * D.q = v := by simpa only [hvg] using huv
+  have hvn : ‖v‖ ≤ 1 := finiteRowIsometry_norm_le s t r D.q
+    D.projection.isIdempotentElem.eq D.projection.isSelfAdjoint.star_eq hrr hr hs htq ht m
+  refine ⟨D.absorption u, D.absorption_joined_anchor u hu, ?_⟩
+  intro i hi
+  have hf : ‖s i * v - v * t i‖ < δ := by
+    have h := finiteRowIsometry_forward_norm_sq s t r D.q
+      D.projection.isIdempotentElem.eq D.projection.isSelfAdjoint.star_eq
+      hrr hr hs htq ht htt m i
+    change ‖s i * v - v * t i‖ ^ 2 ≤ _ at h
+    nlinarith [norm_nonneg (s i * v - v * t i)]
+  have hb : ‖star v * s i - t i * star v‖ < δ := by
+    have h := finiteRowIsometry_backward_norm_sq s t r D.q
+      D.projection.isIdempotentElem.eq D.projection.isSelfAdjoint.star_eq
+      hrr hr hs htq ht htt m i
+    have he : star v * s i - t i * star v =
+        star (star (s i) * v - v * star (t i)) := by
+      simp only [star_sub, star_mul, star_star]
+    rw [he, norm_star]
+    have hone : ((m : ℝ) + 1)⁻¹ ≤ 2 / ((m : ℝ) + 1) := by
+      rw [← one_div]
+      exact div_le_div_of_nonneg_right (by norm_num) (by positivity)
+    change ‖star (s i) * v - v * star (t i)‖ ^ 2 ≤ _ at h
+    nlinarith [norm_nonneg (star (s i) * v - v * star (t i))]
+  calc
+    _ ≤ 2 * ‖s i * v - v * t i‖ + 3 * ‖star v * s i - t i * star v‖ :=
+      D.absorption_error_bound u v (s i) (t i) huq (htq i) (hat i hi) (hbt i hi) hvn
+    _ < ε := by dsimp only [δ] at hf hb; linarith
+
+end Selected
+
+lemma BufferAbsorptionCorner.extend_finite_proper_row
+    (D : BufferAbsorptionCorner E) (n : ℕ) (x : Fin (n + 1) → E)
+    (hxs : ∀ i, D.q * x i = x i ∧ x i * D.q = x i)
+    (hx : ∀ i j, star (x i) * x j = if i = j then D.q else 0) :
+    ∃ t : Fin (n + 1) → E,
+      (∀ i : Fin n, t i.succ = x i.castSucc) ∧
+      (∀ i, D.q * t i = t i ∧ t i * D.q = t i) ∧
+      (∀ i j, star (t i) * t j = if i = j then D.q else 0) ∧
+      (∑ i, t i * star (t i)) = D.q := by
+  let C := ProjectionCorner D.q D.projection.isSelfAdjoint.star_eq
+    D.projection.isIdempotentElem.eq
+  let x' : Fin (n + 1) → C := fun i => ⟨x i, hxs i⟩
+  let a' : C := ⟨D.a, D.a_left, D.a_right⟩
+  let b' : C := ⟨D.b, D.b_left, D.b_right⟩
+  have hx' (i j : Fin (n + 1)) : star (x' i) * x' j = if i = j then 1 else 0 := by
+    apply Subtype.ext
+    change star (x i) * x j = ↑(if i = j then (1 : C) else 0)
+    split_ifs with h
+    · change star (x i) * x j = D.q
+      simpa only [h, ite_true] using hx i j
+    · change star (x i) * x j = 0
+      simpa only [h, ite_false] using hx i j
+  have hlast (i : Fin n) : star (x' (Fin.last n)) * x' i.castSucc = 0 := by
+    rw [hx']
+    have hne : Fin.last n ≠ i.castSucc := by
+      intro h
+      have hh := congrArg Fin.val h
+      change n = (i : ℕ) at hh
+      omega
+    rw [ite_eq_right hne]
+  obtain ⟨t, htx, ht, hts⟩ := finite_zero_unit_full_row
+    (fun i : Fin n => x' i.castSucc) (x' (Fin.last n)) a' b'
+    (fun i j => by simpa only [Fin.castSucc_inj] using hx' i.castSucc j.castSucc)
+    (by simpa only [ite_true] using hx' (Fin.last n) (Fin.last n)) hlast
+    (Subtype.ext D.a_gram) (Subtype.ext D.b_gram)
+    (Subtype.ext D.orthogonal) (Subtype.ext D.ranges)
+  refine ⟨fun i => (t i : E), fun i => congrArg (fun y : C => (y : E)) (htx i),
+    fun i => (t i).property, ?_, ?_⟩
+  · intro i j
+    by_cases hij : i = j
+    · subst j
+      simp only [ite_true]
+      have h := ht i i
+      simp only [ite_true] at h
+      have he := congrArg (fun y : C => (y : E)) h
+      change star (t i : E) * (t i : E) = D.q at he
+      exact he
+    · rw [ite_eq_right hij]
+      have h := ht i j
+      rw [ite_eq_right hij] at h
+      have he := congrArg (fun y : C => (y : E)) h
+      change star (t i : E) * (t j : E) = 0 at he
+      exact he
+
+  · have h := congrArg (projectionCornerInclusion D.q D.projection.isSelfAdjoint.star_eq
+      D.projection.isIdempotentElem.eq) hts
+    simp only [map_sum, map_mul, map_star, projectionCornerInclusion_one] at h
+    exact h
+
+/-- Connected absorption of any finite original proper-row prefix. The
+complementary source row remains as an explicit summand. -/
+lemma exists_connected_proper_buffer_absorption [Nontrivial E]
+    (s t r : ℕ → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then 1 else 0)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (hrs : bergRowsCommute r s) (hrt : bergRowsCommute r t)
+    (n : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ U : unitary E, Joined (1 : unitary E) U ∧
+      ∀ i : Fin n,
+        ‖(U : E) * s i * star (U : E) -
+          (t i * (1 - r 0 * star (r 0)) + s i * (r 0 * star (r 0)))‖ < ε := by
+  have rc (i j : ℕ) : Commute (r i) (s j) ∧ Commute (star (r i)) (s j) :=
+    ⟨(hrs i j).1, by simpa only [star_star] using (hrs i j).2.star_star⟩
+  have tc (i j : ℕ) : Commute (r i) (t j) ∧ Commute (star (r i)) (t j) :=
+    ⟨(hrt i j).1, by simpa only [star_star] using (hrt i j).2.star_star⟩
+  obtain ⟨D, hDq, hDw, _, hDjoin, hDc⟩ := exists_connected_buffer_corner (r 0) (r 1) (r 2)
+    (by simpa only [ite_true] using hr 0 0)
+    (by simpa only [ite_true] using hr 1 1)
+    (by simpa only [ite_true] using hr 2 2)
+    (by simpa using hr 0 1) (by simpa using hr 0 2) (by simpa using hr 1 2)
+  have hqs (i : ℕ) : Commute D.q (s i) := by
+    rw [hDq]
+    exact (Commute.one_left _).sub_left ((rc 0 i).1.mul_left (rc 0 i).2)
+  have hqt (i : ℕ) : Commute D.q (t i) := by
+    rw [hDq]
+    exact (Commute.one_left _).sub_left ((tc 0 i).1.mul_left (tc 0 i).2)
+  let x : Fin (n + 1) → E := fun i => t i * D.q
+  have hxs (i : Fin (n + 1)) : D.q * x i = x i ∧ x i * D.q = x i := by
+    constructor
+    · change D.q * (t i * D.q) = t i * D.q
+      rw [← mul_assoc, (hqt i).eq, mul_assoc, D.projection.isIdempotentElem.eq]
+    · change (t i * D.q) * D.q = t i * D.q
+      rw [mul_assoc, D.projection.isIdempotentElem.eq]
+  have hx (i j : Fin (n + 1)) : star (x i) * x j = if i = j then D.q else 0 := by
+    change star (t i * D.q) * (t j * D.q) = _
+    rw [star_mul, D.projection.isSelfAdjoint.star_eq]
+    calc
+      _ = D.q * (star (t i) * t j) * D.q := by noncomm_ring
+      _ = _ := by
+        by_cases hij : i = j
+        · subst j
+          simp only [ht, ite_true, mul_one, D.projection.isIdempotentElem.eq]
+        · rw [ht, ite_eq_right (fun h => hij (Fin.ext h)),
+            ite_eq_right hij, mul_zero, zero_mul]
+  obtain ⟨T, hTx, hTq, hT, hTs⟩ := D.extend_finite_proper_row n x hxs hx
+  let S : Fin (n + 1) → E := Fin.cons (s n) (fun i : Fin n => s i)
+  have hS (i j : Fin (n + 1)) : star (S i) * S j = if i = j then 1 else 0 := by
+    refine Fin.cases ?_ (fun i => ?_) i <;> refine Fin.cases ?_ (fun j => ?_) j
+    · simpa only [S, Fin.cons_zero, ite_true] using hs n n
+    · have hne : n ≠ (j : ℕ) := by omega
+      simpa only [S, Fin.cons_zero, Fin.cons_succ, hne, ite_false,
+        (Fin.succ_ne_zero j).symm] using hs n j
+    · have hne : (i : ℕ) ≠ n := by omega
+      simpa only [S, Fin.cons_zero, Fin.cons_succ, hne, ite_false,
+        Fin.succ_ne_zero] using hs i n
+    · simpa only [S, Fin.cons_succ, Fin.succ_inj, Fin.ext_iff, Fin.val_succ, Nat.succ.injEq] using hs i j
+  have hroot (i : Fin (n + 1)) : star (s (n + 1)) * S i = 0 := by
+    refine Fin.cases ?_ (fun j => ?_) i
+    · simpa only [S, Fin.cons_zero, Nat.add_one_ne_self, ite_false] using hs (n + 1) n
+    · have hne : n + 1 ≠ (j : ℕ) := by omega
+      simpa only [S, Fin.cons_succ, hne, ite_false] using hs (n + 1) j
+  have hqS (i : Fin (n + 1)) : Commute D.q (S i) := by
+    refine Fin.cases (hqs n) (fun j => hqs j) i
+  have haT (i : Fin (n + 1)) (hi : 0 < (i : ℕ)) : Commute (star D.a) (T i) := by
+    revert hi
+    refine Fin.cases ?_ (fun j => ?_) i
+    · intro h; exact (Nat.lt_irrefl 0 h).elim
+    · intro _
+      rw [hTx]
+      change Commute (star D.a) (t j * D.q)
+      exact ((hDc (t j) (tc 0 j).1 (tc 0 j).2 (tc 1 j).1 (tc 1 j).2
+        (tc 2 j).1 (tc 2 j).2).2.1).mul_right
+          (D.a_star_right.trans D.a_star_left.symm)
+  have hbT (i : Fin (n + 1)) (hi : 0 < (i : ℕ)) : Commute (star D.b) (T i) := by
+    revert hi
+    refine Fin.cases ?_ (fun j => ?_) i
+    · intro h; exact (Nat.lt_irrefl 0 h).elim
+    · intro _
+      rw [hTx]
+      change Commute (star D.b) (t j * D.q)
+      exact ((hDc (t j) (tc 0 j).1 (tc 0 j).2 (tc 1 j).1 (tc 1 j).2
+        (tc 2 j).1 (tc 2 j).2).2.2.2).mul_right
+          (D.b_star_right.trans D.b_star_left.symm)
+  obtain ⟨U, hU, hUi⟩ := D.exists_finite_absorption_on S T (s (n + 1))
+    (fun i => 0 < (i : ℕ)) (by simpa only [ite_true] using hs (n + 1) (n + 1))
+    hroot hS (hqs (n + 1)) hqS (fun i => (hTq i).2) hTs hT haT hbT ε hε
+  refine ⟨U, hDjoin.trans hU, fun i => ?_⟩
+  have hi := hUi i.succ (by simp)
+  rw [hTx] at hi
+  have he : D.w * s i * star D.w = s i * (r 0 * star (r 0)) := by
+    rw [hDw, (rc 0 i).1.eq, mul_assoc]
+  change ‖(U : E) * s i - (x i.castSucc + D.w * s i * star D.w) * (U : E)‖ < ε at hi
+  have hmul : ((U : E) * s i - (x i.castSucc + D.w * s i * star D.w) * (U : E)) *
+      star (U : E) = (U : E) * s i * star (U : E) -
+        (x i.castSucc + D.w * s i * star D.w) := by
+    rw [sub_mul, mul_assoc _ (U : E), Unitary.mul_star_self_of_mem U.property, mul_one]
+  have hnorm := CStarRing.norm_mul_mem_unitary
+    ((U : E) * s i - (x i.castSucc + D.w * s i * star D.w) * (U : E))
+    (Unitary.star_mem U.property)
+  rw [hmul] at hnorm
+  have hc : ‖(U : E) * s i * star (U : E) -
+      (x i.castSucc + D.w * s i * star D.w)‖ < ε := by
+    rw [hnorm]
+    exact hi
+  simpa only [x, Fin.val_castSucc, hDq, he] using hc
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RelativeCocycle.lean

@@ -0,0 +1,152 @@
+import OAI.Analysis.OInfinity.ProjectionCorner
+
+namespace OAI
+
+/-! # Actual binary row cocycles in a proper projection corner
+
+The corner unitary is extended by the identity on the complementary
+projection. The complement is retained explicitly; this is not yet an
+ambient approximate intertwining statement for the canonical O∞ rows.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+/-- A supported element, regarded as an element of the unital corner. -/
+def projectionCornerElement (q : E) (hq : star q = q) (hqq : q * q = q)
+    (x : E) (hx : q * x = x ∧ x * q = x) : ProjectionCorner q hq hqq := ⟨x, hx⟩
+
+lemma projectionCornerElement_gram {I : Type*} [DecidableEq I]
+    (q : E) (hq : star q = q) (hqq : q * q = q) (s : I → E)
+    (hsp : ∀ i, q * s i = s i ∧ s i * q = s i)
+    (hs : ∀ i j, star (s i) * s j = if i = j then q else 0) (i j : I) :
+    star (projectionCornerElement q hq hqq (s i) (hsp i)) *
+      projectionCornerElement q hq hqq (s j) (hsp j) = if i = j then 1 else 0 := by
+  apply Subtype.ext
+  split_ifs with hij
+  · change star (s i) * s j = q
+    simpa only [hij, ite_true] using hs i j
+  · change star (s i) * s j = 0
+    simpa only [hij, ite_false] using hs i j
+
+lemma projectionCornerElement_range_sum {I : Type*} [Fintype I]
+    (q : E) (hq : star q = q) (hqq : q * q = q) (s : I → E)
+    (hsp : ∀ i, q * s i = s i ∧ s i * q = s i)
+    (hsum : (∑ i, s i * star (s i)) = q) :
+    (∑ i, projectionCornerElement q hq hqq (s i) (hsp i) *
+      star (projectionCornerElement q hq hqq (s i) (hsp i))) = 1 := by
+  apply Subtype.ext
+  change projectionCornerInclusion q hq hqq (∑ i,
+    projectionCornerElement q hq hqq (s i) (hsp i) *
+      star (projectionCornerElement q hq hqq (s i) (hsp i))) = q
+  rw [map_sum]
+  exact hsum
+
+lemma projectionCornerInclusion_rowCocycle {I : Type*} [Fintype I]
+    (q : E) (hq : star q = q) (hqq : q * q = q)
+    (s t : I → ProjectionCorner q hq hqq) :
+    projectionCornerInclusion q hq hqq (finiteRowCocycle s t) =
+      finiteRowCocycle (fun i => (s i : E)) (fun i => (t i : E)) := by
+  simp only [finiteRowCocycle, map_sum, map_mul, map_star]
+  rfl
+
+lemma projectionCornerInclusion_rowShift {I : Type*} [Fintype I]
+    (q : E) (hq : star q = q) (hqq : q * q = q)
+    (s : I → ProjectionCorner q hq hqq) (x : ProjectionCorner q hq hqq) :
+    projectionCornerInclusion q hq hqq (finiteRowShift s x) =
+      finiteRowShift (fun i => (s i : E)) (x : E) := by
+  simp only [finiteRowShift, map_sum, map_mul, map_star]
+  rfl
+
+/-- The actual product cocycle, with the corner unit as its zeroth term. -/
+def relativeRowProduct {I : Type*} [Fintype I] (q : E) (s t : I → E) : ℕ → E
+  | 0 => q
+  | n + 1 => finiteRowCocycle s t * finiteRowShift s (relativeRowProduct q s t n)
+
+lemma projectionCorner_rowProduct (q : E) (hq : star q = q) (hqq : q * q = q)
+    (s t : Fin 2 → ProjectionCorner q hq hqq)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then 1 else 0)
+    (hsum : (∑ i, s i * star (s i)) = 1)
+    (htsum : (∑ i, t i * star (t i)) = 1) (n : ℕ) :
+    ((binaryRowCocycleUnitary s t hs ht hsum htsum n : ProjectionCorner q hq hqq) : E) =
+      relativeRowProduct q (fun i => (s i : E)) (fun i => (t i : E)) n := by
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+      change projectionCornerInclusion q hq hqq
+        (finiteRowCocycle s t *
+          (binarySplitHom (s 0) (s 1) (by simpa using hs 0 0)
+            (by simpa using hs 1 1) (by simpa using hs 0 1)
+            (binaryRowCocycleUnitary s t hs ht hsum htsum n) : ProjectionCorner q hq hqq)) = _
+      rw [map_mul, binarySplitHom_coe s hs hsum,
+        projectionCornerInclusion_rowCocycle, projectionCornerInclusion_rowShift, ih]
+      rfl
+
+lemma projectionCornerUnitary_complement (q : E) (hq : star q = q) (hqq : q * q = q)
+    (u : unitary (ProjectionCorner q hq hqq)) :
+    (projectionCornerUnitary q hq hqq u : E) * (1 - q) = 1 - q ∧
+      (1 - q) * (projectionCornerUnitary q hq hqq u : E) = 1 - q := by
+  have hl := (u : ProjectionCorner q hq hqq).property.1
+  have hr := (u : ProjectionCorner q hq hqq).property.2
+  change (((u : ProjectionCorner q hq hqq) : E) + (1 - q)) * (1 - q) = 1 - q ∧
+    (1 - q) * (((u : ProjectionCorner q hq hqq) : E) + (1 - q)) = 1 - q
+  constructor
+  · simp only [add_mul, mul_sub, sub_mul, one_mul, mul_one, hqq, hr]
+    abel
+  · simp only [mul_add, mul_sub, sub_mul, one_mul, mul_one, hqq, hl]
+    abel
+
+/-- The uniform `192π` contraction survives proper-corner transport.
+The constructed ambient unitary is exactly the product cocycle plus `1-q`
+and fixes the complementary corner on both sides. -/
+lemma exists_relative_binaryRowCocycle_path
+    (q : E) (hq : star q = q) (hqq : q * q = q) (hqne : q ≠ 0)
+    (s t : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then q else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then q else 0)
+    (hsum : (∑ i, s i * star (s i)) = q)
+    (htsum : (∑ i, t i * star (t i)) = q)
+    (hc : ∀ i j, Commute (s i) (t j)) (n : ℕ) :
+    ∃ u : unitary E, (u : E) = relativeRowProduct q s t n + (1 - q) ∧
+      (u : E) * (1 - q) = 1 - q ∧ (1 - q) * (u : E) = 1 - q ∧
+      ∃ p : Path u 1, ∀ a b, ‖(p a : E) - p b‖ ≤ (192 * Real.pi) * |(a : ℝ) - b| := by
+  have : NeZero q := ⟨hqne⟩
+  have hsp (i : Fin 2) : q * s i = s i ∧ s i * q = s i :=
+    ⟨finiteRow_left_support q s hq hqq hs hsum i,
+      finiteRow_right_support q s hq hqq hs i⟩
+  have htp (i : Fin 2) : q * t i = t i ∧ t i * q = t i :=
+    ⟨finiteRow_left_support q t hq hqq ht htsum i,
+      finiteRow_right_support q t hq hqq ht i⟩
+  let S : Fin 2 → ProjectionCorner q hq hqq := fun i =>
+    projectionCornerElement q hq hqq (s i) (hsp i)
+  let T : Fin 2 → ProjectionCorner q hq hqq := fun i =>
+    projectionCornerElement q hq hqq (t i) (htp i)
+  have hS := projectionCornerElement_gram q hq hqq s hsp hs
+  have hT := projectionCornerElement_gram q hq hqq t htp ht
+  have hSsum := projectionCornerElement_range_sum q hq hqq s hsp hsum
+  have hTsum := projectionCornerElement_range_sum q hq hqq t htp htsum
+  have hST (i j : Fin 2) : Commute (S i) (T j) := by
+    change S i * T j = T j * S i
+    apply Subtype.ext
+    exact (hc i j).eq
+  obtain ⟨p, hp⟩ := exists_uniform_binaryRowCocycle_path S T hS hT hSsum hTsum hST n
+  let v := binaryRowCocycleUnitary S T hS hT hSsum hTsum n
+  let u := projectionCornerUnitary q hq hqq v
+  obtain ⟨r, hr⟩ := projectionCornerPath_controlled q hq hqq p (192 * Real.pi) hp
+  refine ⟨u, ?_, (projectionCornerUnitary_complement q hq hqq v).1,
+    (projectionCornerUnitary_complement q hq hqq v).2, ?_⟩
+  · change ((v : ProjectionCorner q hq hqq) : E) + (1 - q) = _
+    rw [projectionCorner_rowProduct q hq hqq S T hS hT hSsum hTsum n]
+    rfl
+  · exact ⟨r.cast rfl (projectionCornerUnitary_one q hq hqq).symm, hr⟩
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RelativeCompletedComparison.lean

@@ -0,0 +1,147 @@
+import OAI.Analysis.OInfinity.BufferedProperComparison
+
+namespace OAI
+
+/-! # Relative comparison with the prescribed complementary action
+
+The corner path below is constructed from the pointwise complementary
+identity, rather than inferred from ambient connectedness. It allows the
+completed-row comparison to keep the external corner fixed exactly.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+lemma exists_projectionCorner_unitary_path
+    (q : E) (hq : star q = q) (hqq : q * q = q)
+    (u : unitary E) (P : Path (1 : unitary E) u)
+    (hP : ∀ t, (P t : E) * (1 - q) = 1 - q ∧
+      (1 - q) * (P t : E) = 1 - q) :
+    ∃ v : unitary (ProjectionCorner q hq hqq), Joined 1 v ∧
+      ((v : ProjectionCorner q hq hqq) : E) = (u : E) * q := by
+  let H := ProjectionCorner q hq hqq
+  have hcomm (t : unitInterval) : Commute (P t : E) q :=
+    unitary_commutes_projection_of_fixed_complement q (P t) (hP t)
+  have hs (t : unitInterval) : q * ((P t : E) * q) = (P t : E) * q ∧
+      ((P t : E) * q) * q = (P t : E) * q := by
+    constructor
+    · rw [← mul_assoc, ← (hcomm t).eq, mul_assoc, hqq]
+    · rw [mul_assoc, hqq]
+  let F : unitInterval → H := fun t => projectionCornerElement q hq hqq ((P t : E) * q) (hs t)
+  have hFunit (t : unitInterval) : F t ∈ unitary H := by
+    constructor
+    · apply Subtype.ext
+      change star ((P t : E) * q) * ((P t : E) * q) = q
+      rw [star_mul, hq]
+      calc
+        _ = q * (star (P t : E) * (P t : E)) * q := by noncomm_ring
+        _ = q := by rw [(P t).property.1, mul_one, hqq]
+    · apply Subtype.ext
+      change ((P t : E) * q) * star ((P t : E) * q) = q
+      rw [star_mul, hq]
+      calc
+        _ = (P t : E) * (q * q) * star (P t : E) := by noncomm_ring
+        _ = (P t : E) * q * star (P t : E) := by rw [hqq]
+        _ = q * ((P t : E) * star (P t : E)) := by rw [(hcomm t).eq, mul_assoc]
+        _ = q := by rw [(P t).property.2, mul_one]
+  let V : unitInterval → unitary H := fun t => ⟨F t, hFunit t⟩
+  have hF : Continuous F := Continuous.subtype_mk
+    ((continuous_subtype_val.comp P.continuous).mul continuous_const) _
+  have hV : Continuous V := Continuous.subtype_mk hF _
+  have hV0 : V 0 = 1 := by
+    apply Subtype.ext
+    apply Subtype.ext
+    change (P 0 : E) * q = q
+    rw [P.source, OneMemClass.coe_one, one_mul]
+  refine ⟨V 1, ?_, ?_⟩
+  · exact ⟨{ toFun := V
+             continuous_toFun := hV
+             source' := hV0
+             target' := rfl }⟩
+  · change (P 1 : E) * q = (u : E) * q
+    rw [P.target]
+
+/-- Both actual completion records are used in the same corner. The
+three-buffer row constructs the intermediate binary pair; the final
+ambient unitary fixes the complement exactly. -/
+lemma exists_relative_completed_row_comparison {n : ℕ}
+    (q : E) (hq : star q = q) (hqq : q * q = q) (hq0 : q ≠ 0)
+    (b : Fin 2 → E)
+    (hb : ∀ i j, star (b i) * b j = if i = j then q else 0)
+    (hbs : (∑ i, b i * star (b i)) = q)
+    (x y : Fin (n + 1) → E)
+    (A : RelativeBinaryCompletion q b x) (B : RelativeBinaryCompletion q b y)
+    (R : Fin 3 → E)
+    (hRs : ∀ i, q * R i = R i ∧ R i * q = R i)
+    (hR : ∀ i j, star (R i) * R j = if i = j then q else 0)
+    (hAR : bergRowsCommute A.row R) (hBR : bergRowsCommute B.row R)
+    (ε : ℝ) (hε : 0 < ε) :
+    ∃ w : unitary E, Joined (1 : unitary E) w ∧
+      (w : E) * (1 - q) = 1 - q ∧ (1 - q) * (w : E) = 1 - q ∧
+      ∀ i : Fin (n + 1), ‖(w : E) * x i * star (w : E) - y i‖ < ε := by
+  let : NeZero q := ⟨hq0⟩
+  let H := ProjectionCorner q hq hqq
+  let f := projectionCornerInclusion q hq hqq
+  have hbsup (i : Fin 2) : q * b i = b i ∧ b i * q = b i :=
+    ⟨finiteRow_left_support q b hq hqq hb hbs i,
+      finiteRow_right_support q b hq hqq hb i⟩
+  let a : Fin 2 → H := fun i => projectionCornerElement q hq hqq (A.row i) (A.support i)
+  let c : Fin 2 → H := fun i => projectionCornerElement q hq hqq (B.row i) (B.support i)
+  let d : Fin 2 → H := fun i => projectionCornerElement q hq hqq (b i) (hbsup i)
+  let r : Fin 3 → H := fun i => projectionCornerElement q hq hqq (R i) (hRs i)
+  have ha := projectionCornerElement_gram q hq hqq A.row A.support A.gram
+  have hc := projectionCornerElement_gram q hq hqq B.row B.support B.gram
+  have hd := projectionCornerElement_gram q hq hqq b hbsup hb
+  have has := projectionCornerElement_range_sum q hq hqq A.row A.support A.range_sum
+  have hcs := projectionCornerElement_range_sum q hq hqq B.row B.support B.range_sum
+  have hds := projectionCornerElement_range_sum q hq hqq b hbsup hbs
+  have hr := projectionCornerElement_gram q hq hqq R hRs hR
+  obtain ⟨u, hu, hue⟩ := exists_projectionCorner_unitary_path q hq hqq
+    A.implementer A.deformation A.fixes_complement
+  obtain ⟨v, hv, hve⟩ := exists_projectionCorner_unitary_path q hq hqq
+    B.implementer B.deformation B.fixes_complement
+  have hua (j : Fin 2) : (u : H) * a j = d j := by
+    apply Subtype.ext
+    change (((u : H) : E) * A.row j) = b j
+    rw [hue, mul_assoc, (A.support j).1, A.cocycle]
+  have hvc (j : Fin 2) : (v : H) * c j = d j := by
+    apply Subtype.ext
+    change (((v : H) : E) * B.row j) = b j
+    rw [hve, mul_assoc, (B.support j).1, B.cocycle]
+  have har : bergRowsCommute a r := fun i j =>
+    ⟨Subtype.ext (hAR i j).1.eq, Subtype.ext (hAR i j).2.eq⟩
+  have hcr : bergRowsCommute c r := fun i j =>
+    ⟨Subtype.ext (hBR i j).1.eq, Subtype.ext (hBR i j).2.eq⟩
+  obtain ⟨w, hw, he⟩ := exists_connected_encoded_comparison_of_buffer r hr d a c
+    hd hds ha has hc hcs har hcr u v hu hv hua hvc n ε hε
+  let W := projectionCornerUnitary q hq hqq w
+  have hW : Joined (1 : unitary E) W := by
+    simpa only [projectionCornerUnitary_one] using
+      hw.map (projectionCornerUnitary_continuous q hq hqq)
+  refine ⟨W, hW, (projectionCornerUnitary_complement q hq hqq w).1,
+    (projectionCornerUnitary_complement q hq hqq w).2, fun i => ?_⟩
+  have hh := he (i : ℕ) (by omega)
+  change ‖f ((w : H) * (a 0 ^ (i : ℕ) * a 1) * star (w : H) -
+    (c 0 ^ (i : ℕ) * c 1))‖ < ε at hh
+  have hax : f (a 0 ^ (i : ℕ) * a 1) = x i := by
+    rw [nonunital_map_pow_mul]
+    exact A.encoded_prefix i
+  have hcy : f (c 0 ^ (i : ℕ) * c 1) = y i := by
+    rw [nonunital_map_pow_mul]
+    exact B.encoded_prefix i
+  rw [map_sub] at hh
+  have hconj := projectionCornerUnitary_conjugate q hq hqq w (a 0 ^ (i : ℕ) * a 1)
+  change (W : E) * f (a 0 ^ (i : ℕ) * a 1) * star (W : E) =
+    f ((w : H) * (a 0 ^ (i : ℕ) * a 1) * star (w : H)) at hconj
+  rw [← hconj, hax, hcy] at hh
+  exact hh
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RelativeGramCorrection.lean

@@ -0,0 +1,291 @@
+import OAI.Analysis.WeakInfiniteness.CuntzPairCorrection
+import OAI.Analysis.OInfinity.MaskedBandRows
+
+namespace OAI
+
+/-! # Gram correction with a common initial projection
+
+The removed cyclic cell is not filled. Adding its complementary projection
+only to the square Gram matrix permits inverse-square-root normalization;
+the corrected rectangular row still has the original initial projection.
+-/
+
+noncomputable section
+open scoped CStarAlgebra ComplexOrder
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E] [PartialOrder E] [StarOrderedRing E]
+
+local instance relativeGramRealModule (n : Type*) [Fintype n] :
+    Module ℝ (CStarMatrix n n E) := Module.complexToReal _
+local instance relativeGramRealAlgebra (n : Type*) [Fintype n] [DecidableEq n] :
+    Algebra ℝ (CStarMatrix n n E) := Algebra.complexToReal
+
+/-- Rectangular normalization preserves an exact right support. -/
+lemma exists_relative_rectangular_isometry_near
+    {m n : Type*} [Fintype m] [Fintype n] [DecidableEq n]
+    (M ε : ℝ) (hM : 0 ≤ M) (hε : 0 < ε) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ (u : CStarMatrix m n E) (q : CStarMatrix n n E),
+      IsStarProjection q → u * q = u → ‖u‖ ≤ M →
+      ‖u.conjTranspose * u - q‖ < δ →
+      ∃ v : CStarMatrix m n E,
+        v * q = v ∧ v.conjTranspose * v = q ∧ ‖v - u‖ < ε := by
+  obtain ⟨δ, hδ, hcorr⟩ := exists_inverse_sqrt_tolerance
+    (A := CStarMatrix n n E) (ε / (M + 1)) (div_pos hε (by linarith))
+  refine ⟨δ, hδ, ?_⟩
+  intro u q hq huq hu hgram
+  let h := u.conjTranspose * u
+  let g := h + (1 - q)
+  have hhq : h * q = h := by
+    change (u.conjTranspose * u) * q = u.conjTranspose * u
+    rw [rectangular_mul_assoc, huq]
+  have hqh : q * h = h := by
+    have hqu : q * u.conjTranspose = u.conjTranspose := by
+      have hz := congrArg (fun a : CStarMatrix m n E => a.conjTranspose) huq
+      rw [rectangular_star_mul] at hz
+      change star q * u.conjTranspose = u.conjTranspose at hz
+      rwa [hq.isSelfAdjoint.star_eq] at hz
+    change q * (u.conjTranspose * u) = u.conjTranspose * u
+    rw [← rectangular_mul_assoc, hqu]
+  have hgq : g * q = h := by
+    change (h + (1 - q)) * q = h
+    rw [add_mul, hhq, hq.one_sub_mul_self, add_zero]
+  have hqg : q * g = h := by
+    change q * (h + (1 - q)) = h
+    rw [mul_add, hqh, hq.mul_one_sub_self, add_zero]
+  have hg0 : 0 ≤ g := add_nonneg (rectangular_initial_nonneg u) hq.one_sub.nonneg
+  have hgn : ‖g - 1‖ < δ := by
+    have he : g - 1 = h - q := by dsimp only [g]; noncomm_ring
+    rw [he]
+    exact hgram
+  obtain ⟨hgp, hkn⟩ := hcorr g hg0 hgn
+  let k : CStarMatrix n n E := g ^ (-(1 / 2) : ℝ)
+  have hk : star k = k := (CFC.rpow_nonneg (a := g)).star_eq
+  have hkg : k * g * k = 1 := CFC.conjugate_rpow_neg_one_half g hgp
+  have hkq : k * q = q * k := by
+    have hcomm : Commute g q := hgq.trans hqg.symm
+    exact (hcomm.cfc_nnreal (fun t => t ^ (-(1 / 2) : ℝ))).eq
+  have hkh : k * h * k = q := by
+    calc
+      k * h * k = k * (q * g * q) * k := by rw [hqg, hhq]
+      _ = q * (k * g * k) * q := by
+        calc
+          _ = (k * q) * g * (q * k) := by noncomm_ring
+          _ = (q * k) * g * (k * q) := by rw [hkq]
+          _ = _ := by noncomm_ring
+      _ = q := by rw [hkg, mul_one, hq.isIdempotentElem.eq]
+  refine ⟨u * k, ?_, ?_, ?_⟩
+  · calc
+      (u * k) * q = u * (k * q) := rectangular_mul_assoc _ _ _
+      _ = u * (q * k) := by rw [hkq]
+      _ = u * k := by rw [← rectangular_mul_assoc, huq]
+  · rw [rectangular_initial_mul, hk]
+    exact hkh
+  · have hu1 : u * (1 : CStarMatrix n n E) = u := by
+      ext i j
+      change (∑ l, u i l * (if l = j then 1 else 0)) = u i j
+      simp
+    have hsub : u * (k - 1) = u * k - u * (1 : CStarMatrix n n E) := by
+      ext i j
+      change (∑ l, u i l * (k l j - (1 : CStarMatrix n n E) l j)) =
+        (∑ l, u i l * k l j) - ∑ l, u i l * (1 : CStarMatrix n n E) l j
+      simp only [mul_sub, Finset.sum_sub_distrib]
+    have he : u * k - u = u * (k - 1) := by rw [hsub, hu1]
+    rw [he]
+    calc
+      _ ≤ ‖u‖ * ‖k - 1‖ := rectangular_norm_mul_le _ _
+      _ ≤ M * ‖k - 1‖ := mul_le_mul_of_nonneg_right hu (norm_nonneg _)
+      _ < (M + 1) * (ε / (M + 1)) := by
+        change ‖k - 1‖ < ε / (M + 1) at hkn
+        have hp : 0 < ε / (M + 1) := div_pos hε (by linarith)
+        nlinarith [norm_nonneg (k - 1)]
+      _ = ε := mul_div_cancel₀ _ (by linarith : M + 1 ≠ 0)
+
+/-- The common initial projection of a two-column row. -/
+def relativePairProjection (p : E) : CStarMatrix (Fin 2) (Fin 2) E :=
+  CStarMatrix.ofMatrix (fun i j => if i = j then p else 0)
+
+omit [PartialOrder E] [StarOrderedRing E] in
+lemma relativePairProjection_apply (p : E) (i j : Fin 2) :
+    relativePairProjection p i j = if i = j then p else 0 := rfl
+
+omit [PartialOrder E] [StarOrderedRing E] in
+lemma relativePairProjection_isStarProjection (p : E) (hp : IsStarProjection p) :
+    IsStarProjection (relativePairProjection p) := by
+  apply isStarProjection_iff'.mpr
+  constructor
+  · ext i j
+    change (∑ k : Fin 2, (if i = k then p else 0) * (if k = j then p else 0)) =
+      (if i = j then p else 0)
+    fin_cases i <;> fin_cases j <;>
+      simp [hp.isIdempotentElem.eq]
+  · ext i j
+    change star (if j = i then p else 0) = if i = j then p else 0
+    fin_cases i <;> fin_cases j <;> simp [hp.isSelfAdjoint.star_eq]
+
+omit [PartialOrder E] [StarOrderedRing E] in
+lemma cuntzPairRow_relative_support (a b p : E) (ha : a * p = a) (hb : b * p = b) :
+    cuntzPairRow a b * relativePairProjection p = cuntzPairRow a b := by
+  ext i j
+  change (∑ k : Fin 2, ![a, b] k * (if k = j then p else 0)) = ![a, b] j
+  fin_cases j <;> simp [ha, hb]
+
+lemma cuntzPairRow_relative_gram_bound (a b p : E) :
+    ‖(cuntzPairRow a b).conjTranspose * cuntzPairRow a b - relativePairProjection p‖ ≤
+      ‖star a * a - p‖ + ‖star b * b - p‖ + 2 * ‖star a * b‖ := by
+  have h := rectangular_norm_le_sum_entries
+    ((cuntzPairRow a b).conjTranspose * cuntzPairRow a b - relativePairProjection p)
+  have hnorm : ‖star b * a‖ = ‖star a * b‖ := by
+    rw [← norm_star (star a * b), star_mul, star_star]
+  simp only [Fin.sum_univ_two, CStarMatrix.sub_apply, cuntzPairRow_initial_entry,
+    Matrix.cons_val_zero, Matrix.cons_val_one, relativePairProjection_apply,
+    ite_true, show ¬ (0 : Fin 2) = 1 by decide, show ¬ (1 : Fin 2) = 0 by decide,
+    ite_false, sub_zero, hnorm] at h
+  linarith
+
+/-- Two approximately orthogonal supported columns can be corrected without
+filling the removed projection. -/
+lemma exists_relative_cuntzPair_near (ε : ℝ) (hε : 0 < ε) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ a b p : E,
+      IsStarProjection p → a * p = a → b * p = b → ‖a‖ ≤ 1 → ‖b‖ ≤ 1 →
+      ‖star a * a - p‖ < δ → ‖star b * b - p‖ < δ → ‖star a * b‖ < δ →
+      ∃ r t : E, r * p = r ∧ t * p = t ∧
+        star r * r = p ∧ star t * t = p ∧ star r * t = 0 ∧
+        ‖r - a‖ < ε ∧ ‖t - b‖ < ε := by
+  obtain ⟨δ, hδ, hcorr⟩ := exists_relative_rectangular_isometry_near (E := E)
+    (m := Fin 1) (n := Fin 2) 2 ε (by norm_num) hε
+  refine ⟨δ / 4, by positivity, ?_⟩
+  intro a b p hp ha hb han hbn haa hbb hab
+  have hu : ‖cuntzPairRow a b‖ ≤ 2 :=
+    (norm_cuntzPairRow_le a b).trans (by linarith)
+  have hg : ‖(cuntzPairRow a b).conjTranspose * cuntzPairRow a b -
+      relativePairProjection p‖ < δ := by
+    have hh := cuntzPairRow_relative_gram_bound a b p
+    linarith
+  obtain ⟨v, hvp, hvg, hvn⟩ := hcorr (cuntzPairRow a b) (relativePairProjection p)
+    (relativePairProjection_isStarProjection p hp) (cuntzPairRow_relative_support a b p ha hb) hu hg
+  have hsup (j : Fin 2) : v 0 j * p = v 0 j := by
+    have hh := congrArg (fun w : CStarMatrix (Fin 1) (Fin 2) E => w 0 j) hvp
+    change (∑ k : Fin 2, v 0 k * (if k = j then p else 0)) = v 0 j at hh
+    fin_cases j <;> simpa [Fin.sum_univ_two] using hh
+  have hgr (i j : Fin 2) : star (v 0 i) * v 0 j = if i = j then p else 0 := by
+    have hh := congrArg (fun w : CStarMatrix (Fin 2) (Fin 2) E => w i j) hvg
+    change (∑ _k : Fin 1, star (v 0 i) * v 0 j) = (if i = j then p else 0) at hh
+    simpa only [Fin.sum_univ_one] using hh
+  refine ⟨v 0 0, v 0 1, hsup 0, hsup 1, ?_, ?_, ?_, ?_, ?_⟩
+  · simpa using hgr 0 0
+  · simpa using hgr 1 1
+  · simpa using hgr 0 1
+  · exact (CStarMatrix.norm_entry_le_norm (M := v - cuntzPairRow a b) (i := 0) (j := 0)).trans_lt hvn
+  · exact (CStarMatrix.norm_entry_le_norm (M := v - cuntzPairRow a b) (i := 0) (j := 1)).trans_lt hvn
+
+omit [PartialOrder E] [StarOrderedRing E] in
+private lemma relativeGram_word_isometry (s : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0) :
+    star (s 0 * s 0) * (s 0 * s 0) = 1 := by
+  rw [star_mul]
+  calc
+    _ = star (s 0) * (star (s 0) * s 0) * s 0 := by noncomm_ring
+    _ = 1 := by simp only [hs, ite_true, mul_one]
+
+omit [PartialOrder E] [StarOrderedRing E] in
+private lemma relativeGram_iterate_isometry (s : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (hsum : (∑ i, s i * star (s i)) = 1) (x : E) (hx : star x * x = 1) (n : ℕ) :
+    star (finiteRowShiftIterate s n x) * finiteRowShiftIterate s n x = 1 := by
+  have h1 : finiteRowShiftIterate s n 1 = 1 := by
+    induction n with
+    | zero => rfl
+    | succ n ih => simpa only [finiteRowShiftIterate, ih, finiteRowShift, mul_one] using hsum
+  rw [finiteRowShiftIterate_star, ← binaryRowIterate_mul s hs, hx, h1]
+
+omit [PartialOrder E] [StarOrderedRing E] in
+private lemma relativeGram_isometry_norm (x : E) (hx : star x * x = 1) : ‖x‖ ≤ 1 := by
+  have h := congrArg norm hx
+  rw [CStarRing.norm_star_mul_self] at h
+  have h1 : ‖(1 : E)‖ ≤ 1 := (IsStarProjection.one E).norm_le
+  nlinarith [norm_nonneg x]
+
+/-- The actual iterated two-letter and one-letter bands admit exact relative
+orthogonalization, with arbitrarily small correction. The cell zero stays
+removed from both initial projections. -/
+lemma exists_corrected_masked_binary_rows {N : ℕ} [NeZero N] (hN : 1 < N)
+    (ε : ℝ) (hε : 0 < ε) :
+    ∃ η : ℝ, 0 < η ∧ ∀ (s : Fin 2 → E),
+      (∀ i j, star (s i) * s j = if i = j then 1 else 0) →
+      (∑ i, s i * star (s i)) = 1 →
+      ∀ e : ZMod N → E, (∀ j, IsStarProjection (e j)) →
+      (∀ j k, j ≠ k → e j * e k = 0) → (∑ j, e j) = 1 →
+      (∀ j, ‖finiteRowShift s (e j) - e (j + 1)‖ ≤ η) →
+      let a := maskedTowerBand e (Equiv.addRight 2)
+        (fun j => finiteRowShiftIterate s j.val (s 0 * s 0)) 0
+      let b := maskedTowerBand e (Equiv.addRight 1)
+        (fun j => finiteRowShiftIterate s j.val (s 1)) 0
+      ∃ r t : E, r * (1 - e 0) = r ∧ t * (1 - e 0) = t ∧
+        star r * r = 1 - e 0 ∧ star t * t = 1 - e 0 ∧ star r * t = 0 ∧
+        ‖r - a‖ < ε ∧ ‖t - b‖ < ε := by
+  obtain ⟨δ, hδ, hcorr⟩ := exists_relative_cuntzPair_near (E := E) ε hε
+  let η := δ / (2 * (N : ℝ) + 3)
+  have hη : 0 < η := by dsimp [η]; positivity
+  refine ⟨η, hη, ?_⟩
+  intro s hs hsum e he ho hesum hshift
+  dsimp only
+  have hword := relativeGram_word_isometry s hs
+  have hsingle : star (s 1) * s 1 = 1 := by simpa only [ite_true] using hs 1 1
+  have hbound (x : E) (hx : star x * x = 1) (d : ZMod N) :
+      ‖maskedTowerBand e (Equiv.addRight d)
+        (fun j => finiteRowShiftIterate s j.val x) 0‖ ≤ 1 := by
+    apply towerBand_norm_le e (Equiv.addRight d) _ he ho 1 zero_le_one
+    intro j
+    by_cases hj : j = 0
+    · simp only [maskedBandCoefficients, ite_eq_left hj, norm_zero, zero_le_one]
+    · simp only [maskedBandCoefficients, ite_eq_right hj]
+      exact relativeGram_isometry_norm _ (relativeGram_iterate_isometry s hs hsum x hx j.val)
+  have hless : (2 * (N : ℝ) + 2) * η < δ := by
+    have heq : (2 * (N : ℝ) + 3) * η = δ := by
+      dsimp only [η]
+      exact mul_div_cancel₀ _ (by positivity)
+    nlinarith
+  apply hcorr _ _ _ (he 0).one_sub
+    (maskedTowerBand_right_support e _ _ 0 ho)
+    (maskedTowerBand_right_support e _ _ 0 ho)
+    (hbound _ hword _) (hbound _ hsingle _)
+  · exact (maskedIteratedWord_gram_bound s hs hsum e he ho hesum η hη.le hshift
+      (s 0 * s 0) hword 2 (cyclic_row_two_letter_transport s hs e η hshift 0 0)).trans_lt hless
+  · apply (maskedIteratedWord_gram_bound s hs hsum e he ho hesum η hη.le hshift
+      (s 1) hsingle 1 ?_).trans_lt hless
+    intro j
+    exact (cyclic_row_generator_transport s hs e η hshift 1 j).trans (by linarith)
+  · apply (maskedIteratedRows_cross_bound hN s hs e he ho η hη.le hshift 0 0 1 (by decide)).trans_lt
+    exact lt_of_le_of_lt (by nlinarith) hless
+
+/-- An actual cyclic partition supplies the small Gram errors; no tower
+or exact orthogonal-row premise is retained in this conclusion. -/
+lemma exists_masked_binary_rotation_rows (s : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (hsum : (∑ i, s i * star (s i)) = 1)
+    (m : ℕ) (hm : 1 < 2 ^ m) (ε : ℝ) (hε : 0 < ε) :
+    ∃ (e : ZMod (2 ^ m) → E) (r t : E),
+      (∀ j, IsStarProjection (e j)) ∧
+      (∀ j k, j ≠ k → e j * e k = 0) ∧ (∑ j, e j) = 1 ∧
+      r * (1 - e 0) = r ∧ t * (1 - e 0) = t ∧
+      star r * r = 1 - e 0 ∧ star t * t = 1 - e 0 ∧ star r * t = 0 ∧
+      ‖r - maskedTowerBand e (Equiv.addRight 2)
+        (fun j => finiteRowShiftIterate s j.val (s 0 * s 0)) 0‖ < ε ∧
+      ‖t - maskedTowerBand e (Equiv.addRight 1)
+        (fun j => finiteRowShiftIterate s j.val (s 1)) 0‖ < ε := by
+  have : IsClosed ((⊤ : StarSubalgebra ℂ E) : Set E) := isClosed_univ
+  obtain ⟨η, hη, hcorr⟩ := exists_corrected_masked_binary_rows (E := E) hm ε hε
+  obtain ⟨e, _hem, he, hesum, ho, hshift⟩ :=
+    exists_binary_cyclic_partition_in (⊤ : StarSubalgebra ℂ E) s hs hsum
+      (fun _ => by simp) m η hη
+  obtain ⟨r, t, hr, ht, hrr, htt, hrt, hra, htb⟩ :=
+    hcorr s hs hsum e he ho hesum (fun j => (hshift j).le)
+  exact ⟨e, r, t, he, ho, hesum, hr, ht, hrr, htt, hrt, hra, htb⟩
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RelativeUnitaryPath.lean

@@ -0,0 +1,140 @@
+import OAI.Analysis.OInfinity.CornerShortPath
+
+namespace OAI
+
+/-! # Uniform paths for relative unitaries
+
+In a fixed corner carrying a coisometric pair, a relative unitary that almost
+commutes with that pair admits an explicit uniform path bound. The endpoint
+is extended by the identity on the ambient complement. The existence of such
+a pair in a prescribed corner is an input, not a consequence asserted here.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+/-- Extend a relative unitary by the identity on the complementary corner. -/
+def relativeUnitaryExtension (q z : E) : E := z + (1 - q)
+
+lemma relativeUnitaryExtension_mem (q z : E) (hqstar : star q = q)
+    (hqq : q * q = q) (hqz : q * z = z) (hzq : z * q = z)
+    (hzz : star z * z = q) (hzz' : z * star z = q) :
+    relativeUnitaryExtension q z ∈ unitary E := by
+  have hsq : star z * q = star z := by
+    simpa only [star_mul, hqstar] using congrArg star hqz
+  have hqs : q * star z = star z := by
+    simpa only [star_mul, hqstar] using congrArg star hzq
+  constructor
+  · simp only [relativeUnitaryExtension, star_add, star_sub, star_one, hqstar]
+    noncomm_ring [hqq, hqz, hsq, hzz]
+  · simp only [relativeUnitaryExtension, star_add, star_sub, star_one, hqstar]
+    noncomm_ring [hqq, hzq, hqs, hzz']
+
+lemma relativeUnitaryExtension_decomposition_error (q a b z : E)
+    (hsum : a * star a + b * star b = q) (hzq : z * q = z)
+    (hab : star a * b = 0) (ha : ‖a‖ ≤ 1) (hb : ‖b‖ ≤ 1)
+    (δ : ℝ) (hδ : 0 ≤ δ)
+    (haz : ‖z * a - a * z‖ ≤ δ) (hbz : ‖z * b - b * z‖ ≤ δ) :
+    ‖relativeUnitaryExtension q z - cornerCompression a z * cornerCompression b z‖ ≤ 2 * δ := by
+  have he : relativeUnitaryExtension q z - cornerCompression a z * cornerCompression b z =
+      (z * a - a * z) * star a + (z * b - b * z) * star b := by
+    rw [cornerCompression_pair_product a b z z hab]
+    unfold relativeUnitaryExtension
+    calc
+      _ = z - (a * z * star a + b * z * star b) := by rw [← hsum]; abel
+      _ = z * (a * star a + b * star b) - (a * z * star a + b * z * star b) := by
+        rw [hsum, hzq]
+      _ = _ := by noncomm_ring
+  rw [he]
+  calc
+    _ ≤ ‖(z * a - a * z) * star a‖ + ‖(z * b - b * z) * star b‖ := norm_add_le _ _
+    _ ≤ ‖z * a - a * z‖ * ‖a‖ + ‖z * b - b * z‖ * ‖b‖ := by
+      simpa only [norm_star] using add_le_add
+        (norm_mul_le (z * a - a * z) (star a))
+        (norm_mul_le (z * b - b * z) (star b))
+    _ ≤ δ * 1 + δ * 1 := by gcongr
+    _ = 2 * δ := by ring
+
+lemma unitaryPath_mul_sub_norm_le {a b c d : unitary E}
+    (p : Path a b) (q : Path c d) (L K : ℝ)
+    (hp : ∀ t s, ‖(p t : E) - p s‖ ≤ L * |(t : ℝ) - s|)
+    (hq : ∀ t s, ‖(q t : E) - q s‖ ≤ K * |(t : ℝ) - s|) :
+    ∀ t s, ‖((p.mul q) t : E) - (p.mul q) s‖ ≤ (L + K) * |(t : ℝ) - s| := by
+  intro t s
+  have he : ((p.mul q) t : E) - (p.mul q) s =
+      (p t : E) * ((q t : E) - q s) + ((p t : E) - p s) * (q s : E) := by
+    change (p t : E) * (q t : E) - (p s : E) * (q s : E) = _
+    noncomm_ring
+  rw [he]
+  calc
+    _ ≤ ‖(p t : E) * ((q t : E) - q s)‖ + ‖((p t : E) - p s) * (q s : E)‖ := norm_add_le _ _
+    _ = ‖(q t : E) - q s‖ + ‖(p t : E) - p s‖ := by
+      rw [CStarRing.norm_coe_unitary_mul, CStarRing.norm_mul_coe_unitary]
+    _ ≤ K * |(t : ℝ) - s| + L * |(t : ℝ) - s| := add_le_add (hq t s) (hp t s)
+    _ = _ := by ring
+
+/-- The fixed-pair hypotheses give a numerical bound independent of the
+relative unitary. The ambient complement is present in the initial point. -/
+lemma exists_uniform_relativeUnitary_path (q a b z : E)
+    (hqstar : star q = q) (hqq : q * q = q)
+    (haa : star a * a = q) (hbb : star b * b = q) (hab : star a * b = 0)
+    (hsum : a * star a + b * star b = q)
+    (hqz : q * z = z) (hzq : z * q = z)
+    (hzz : star z * z = q) (hzz' : z * star z = q)
+    (δ : ℝ) (hδ : 0 ≤ δ) (hsmall : 4 * δ < 2)
+    (haz : ‖z * a - a * z‖ ≤ δ) (hbz : ‖z * b - b * z‖ ≤ δ) :
+    ∃ u : unitary E, (u : E) = relativeUnitaryExtension q z ∧
+      ∃ p : Path u 1, ∀ t s, ‖(p t : E) - p s‖ ≤ (32 * Real.pi) * |(t : ℝ) - s| := by
+  obtain ⟨u, hu, p, hp⟩ := exists_uniform_compressed_unitary_path q a b z hqstar hqq
+    haa hbb hab hsum hqz hzq hzz hzz' δ hδ hsmall haz hbz
+  have hba : star b * a = 0 := by
+    simpa only [star_mul, star_star, star_zero] using congrArg star hab
+  have hsum' : b * star b + a * star a = q := by rw [add_comm]; exact hsum
+  obtain ⟨v, hv, r, hr⟩ := exists_uniform_compressed_unitary_path q b a z hqstar hqq
+    hbb haa hba hsum' hqz hzq hzz hzz' δ hδ hsmall hbz haz
+  let w : unitary E := ⟨relativeUnitaryExtension q z,
+    relativeUnitaryExtension_mem q z hqstar hqq hqz hzq hzz hzz'⟩
+  have hnq : ‖q‖ ≤ 1 := by
+    have h := congrArg norm hqq
+    have hs : IsSelfAdjoint q := hqstar
+    rw [hs.norm_mul_self] at h
+    nlinarith [norm_nonneg q]
+  have hna : ‖a‖ ≤ 1 := by
+    have h := congrArg norm haa
+    rw [CStarRing.norm_star_mul_self] at h
+    nlinarith [norm_nonneg a]
+  have hnb : ‖b‖ ≤ 1 := by
+    have h := congrArg norm hbb
+    rw [CStarRing.norm_star_mul_self] at h
+    nlinarith [norm_nonneg b]
+  have hclose : ‖((u * v : unitary E) : E) - w‖ < 2 := by
+    change ‖(u : E) * (v : E) - relativeUnitaryExtension q z‖ < 2
+    rw [hu, hv, norm_sub_rev]
+    exact (relativeUnitaryExtension_decomposition_error q a b z hsum hzq hab
+      hna hnb δ hδ haz hbz).trans_lt (by linarith)
+  let middle := Unitary.path w (u * v) hclose
+  let productPath : Path (u * v) 1 := (p.mul r).cast rfl (by simp)
+  have hm : ∀ t s, ‖(middle t : E) - middle s‖ ≤ (16 * Real.pi) * |(t : ℝ) - s| := by
+    intro t s
+    exact (unitary_shortPath_sub_norm_le w (u * v) hclose t s).trans (by
+      nlinarith [Real.pi_pos, abs_nonneg ((t : ℝ) - s)])
+  have hpr : ∀ t s, ‖(productPath t : E) - productPath s‖ ≤
+      (16 * Real.pi) * |(t : ℝ) - s| := by
+    intro t s
+    change ‖((p.mul r) t : E) - (p.mul r) s‖ ≤ _
+    simpa only [show 8 * Real.pi + 8 * Real.pi = 16 * Real.pi by ring] using
+      unitaryPath_mul_sub_norm_le p r (8 * Real.pi) (8 * Real.pi) hp hr t s
+  refine ⟨w, rfl, middle.trans productPath, ?_⟩
+  intro t s
+  simpa only [show 2 * (16 * Real.pi) = 32 * Real.pi by ring] using
+    unitaryPath_trans_sub_norm_le middle productPath (16 * Real.pi) hm hpr t s
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RohlinGluing.lean

@@ -0,0 +1,166 @@
+import OAI.Analysis.OInfinity.CocycleCentrality
+
+namespace OAI
+
+/-! # Weighted finite Rohlin sums
+
+Orthogonal projection domains give a square-sum norm bound. Hence N
+coefficient errors of size L/N contribute at most L/√N, even before
+commutation with the projections is imposed. The shift and unitarity
+errors are tracked separately.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E I : Type*} [CStarAlgebra E] [Fintype I] [DecidableEq I]
+
+lemma weightedProjection_norm_le_one (e : E) (he : star e = e) (hee : e * e = e) :
+    ‖e‖ ≤ 1 := by
+  have h := CStarRing.norm_star_mul_self (x := e)
+  rw [he, hee] at h
+  nlinarith [norm_nonneg e]
+
+lemma orthogonalWeighted_square (e x : I → E)
+    (he : ∀ i, star (e i) = e i) (hee : ∀ i, e i * e i = e i)
+    (horth : ∀ i j, i ≠ j → e i * e j = 0) :
+    (∑ i, x i * e i) * star (∑ i, x i * e i) =
+      ∑ i, x i * e i * star (x i) := by
+  have hterm (i j : I) : (x i * e i) * star (x j * e j) =
+      if i = j then x i * e i * star (x i) else 0 := by
+    rw [star_mul, he]
+    calc
+      _ = x i * (e i * e j) * star (x j) := by noncomm_ring
+      _ = _ := by
+        split_ifs with hij
+        · subst j
+          rw [hee]
+        · rw [horth i j hij, mul_zero, zero_mul]
+  rw [star_sum, Finset.sum_mul]
+  simp only [Finset.mul_sum, hterm, Finset.sum_ite_eq, Finset.mem_univ, ite_true]
+
+lemma orthogonalWeighted_norm_sq_le (e x : I → E)
+    (he : ∀ i, star (e i) = e i) (hee : ∀ i, e i * e i = e i)
+    (horth : ∀ i j, i ≠ j → e i * e j = 0) :
+    ‖∑ i, x i * e i‖ ^ 2 ≤ ∑ i, ‖x i‖ ^ 2 := by
+  calc
+    _ = ‖(∑ i, x i * e i) * star (∑ i, x i * e i)‖ := by
+      rw [CStarRing.norm_self_mul_star, pow_two]
+    _ = ‖∑ i, x i * e i * star (x i)‖ := by rw [orthogonalWeighted_square e x he hee horth]
+    _ ≤ ∑ i, ‖x i * e i * star (x i)‖ := norm_sum_le _ _
+    _ ≤ _ := by
+      apply Finset.sum_le_sum
+      intro i hi
+      calc
+        _ ≤ ‖x i‖ * ‖e i‖ * ‖x i‖ := by
+          simpa only [norm_star] using
+            (norm_mul_le (x i * e i) (star (x i))).trans
+              (mul_le_mul_of_nonneg_right (norm_mul_le _ _) (norm_nonneg _))
+        _ ≤ ‖x i‖ * 1 * ‖x i‖ := by
+          gcongr
+          exact weightedProjection_norm_le_one (e i) (he i) (hee i)
+        _ = ‖x i‖ ^ 2 := by ring
+
+lemma orthogonalWeighted_norm_le (e x : I → E)
+    (he : ∀ i, star (e i) = e i) (hee : ∀ i, e i * e i = e i)
+    (horth : ∀ i j, i ≠ j → e i * e j = 0)
+    (δ : ℝ) (hδ : 0 ≤ δ) (hx : ∀ i, ‖x i‖ ≤ δ) :
+    ‖∑ i, x i * e i‖ ≤ Real.sqrt (Fintype.card I) * δ := by
+  have h := orthogonalWeighted_norm_sq_le e x he hee horth
+  have hb : (∑ i, ‖x i‖ ^ 2) ≤ (Fintype.card I : ℝ) * δ ^ 2 := by
+    calc
+      _ ≤ ∑ _ : I, δ ^ 2 := Finset.sum_le_sum fun i _ => by
+        nlinarith [norm_nonneg (x i), hx i]
+      _ = _ := by simp
+  have hs := Real.sq_sqrt (show (0 : ℝ) ≤ Fintype.card I by positivity)
+  have hn := Real.sqrt_nonneg (Fintype.card I : ℝ)
+  have hp : 0 ≤ Real.sqrt (Fintype.card I : ℝ) * δ := mul_nonneg hn hδ
+  nlinarith [norm_nonneg (∑ i, x i * e i)]
+
+def finiteRohlinSum (v : I → unitary E) (e : I → E) : E := ∑ i, (v i : E) * e i
+
+omit [DecidableEq I] in
+lemma finiteRohlinSum_defect_identity (φ : E →⋆ₙₐ[ℂ] E) (w : unitary E)
+    (σ : Equiv.Perm I) (v : I → unitary E) (e : I → E) :
+    (w : E) * φ (finiteRohlinSum v e) - finiteRohlinSum v e =
+      (∑ i, ((w : E) * φ (v i) - (v (σ i) : E)) * e (σ i)) +
+        ∑ i, ((w : E) * φ (v i)) * (φ (e i) - e (σ i)) := by
+  have hreindex : (∑ i, (v (σ i) : E) * e (σ i)) = finiteRohlinSum v e := by
+    apply Fintype.sum_equiv σ
+    intro i
+    rfl
+  symm
+  rw [← Finset.sum_add_distrib]
+  calc
+    _ = (∑ i, (w : E) * φ ((v i : E) * e i)) -
+        ∑ i, (v (σ i) : E) * e (σ i) := by
+      rw [← Finset.sum_sub_distrib]
+      apply Finset.sum_congr rfl
+      intro i hi
+      rw [map_mul]
+      noncomm_ring
+    _ = _ := by rw [hreindex, ← Finset.mul_sum, ← map_sum]; rfl
+
+lemma finiteRohlinSum_defect_le [Nontrivial E] (φ : E →⋆ₙₐ[ℂ] E) (w : unitary E)
+    (σ : Equiv.Perm I) (v : I → unitary E) (e : I → E)
+    (he : ∀ i, star (e i) = e i) (hee : ∀ i, e i * e i = e i)
+    (horth : ∀ i j, i ≠ j → e i * e j = 0)
+    (δ η : ℝ) (hδ : 0 ≤ δ)
+    (hv : ∀ i, ‖(w : E) * φ (v i) - (v (σ i) : E)‖ ≤ δ)
+    (hshift : ∀ i, ‖φ (e i) - e (σ i)‖ ≤ η) :
+    ‖(w : E) * φ (finiteRohlinSum v e) - finiteRohlinSum v e‖ ≤
+      Real.sqrt (Fintype.card I) * δ + (Fintype.card I : ℝ) * η := by
+  rw [finiteRohlinSum_defect_identity φ w σ v e]
+  apply (norm_add_le _ _).trans
+  apply add_le_add
+  · exact orthogonalWeighted_norm_le (fun i => e (σ i))
+      (fun i => (w : E) * φ (v i) - (v (σ i) : E)) (fun i => he (σ i))
+      (fun i => hee (σ i)) (fun i j hij => horth (σ i) (σ j) (σ.injective.ne hij)) δ hδ hv
+  · calc
+      _ ≤ ∑ i, ‖((w : E) * φ (v i)) * (φ (e i) - e (σ i))‖ := norm_sum_le _ _
+      _ ≤ ∑ _ : I, η := by
+        apply Finset.sum_le_sum
+        intro i hi
+        rw [mul_assoc, CStarRing.norm_coe_unitary_mul]
+        calc
+          _ ≤ ‖φ (v i)‖ * ‖φ (e i) - e (σ i)‖ := norm_mul_le _ _
+          _ ≤ 1 * η := by
+            apply mul_le_mul
+            · exact (NonUnitalStarAlgHom.norm_apply_le φ _).trans (CStarRing.norm_coe_unitary (v i)).le
+            · exact hshift i
+            · exact norm_nonneg _
+            · norm_num
+          _ = η := one_mul η
+      _ = _ := by simp
+
+/-- One of the two unitary defects only needs the diagonal commutators. -/
+lemma finiteRohlinSum_coisometry_defect_le (v : I → unitary E) (e : I → E)
+    (he : ∀ i, star (e i) = e i) (hee : ∀ i, e i * e i = e i)
+    (horth : ∀ i j, i ≠ j → e i * e j = 0)
+    (hsum : (∑ i, e i) = 1) (δ : ℝ)
+    (hc : ∀ i, ‖(v i : E) * e i - e i * (v i : E)‖ ≤ δ) :
+    ‖finiteRohlinSum v e * star (finiteRohlinSum v e) - 1‖ ≤ (Fintype.card I : ℝ) * δ := by
+  change ‖(∑ i, (v i : E) * e i) * star (∑ i, (v i : E) * e i) - 1‖ ≤ _
+  rw [orthogonalWeighted_square e (fun i => (v i : E)) he hee horth, ← hsum,
+    ← Finset.sum_sub_distrib]
+  calc
+    _ ≤ ∑ i, ‖(v i : E) * e i * star (v i : E) - e i‖ := norm_sum_le _ _
+    _ ≤ ∑ _ : I, δ := by
+      apply Finset.sum_le_sum
+      intro i hi
+      have hid : (v i : E) * e i * star (v i : E) - e i =
+          ((v i : E) * e i - e i * (v i : E)) * star (v i : E) := by
+        rw [sub_mul, mul_assoc (e i), (v i).property.2, mul_one]
+      rw [hid]
+      change ‖((v i : E) * e i - e i * (v i : E)) * (star (v i) : unitary E)‖ ≤ δ
+      rw [CStarRing.norm_mul_coe_unitary]
+      exact hc i
+    _ = _ := by simp
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RohlinPartitions.lean

@@ -0,0 +1,101 @@
+import OAI.Analysis.OInfinity.DyadicProjections
+
+namespace OAI
+
+/-! # Concrete dyadic partitions for an even Cuntz row
+
+The phases are explicit roots of unity. The finite partitions below use the
+actual geometric CAR modes of the supplied even row, followed by the proved
+Jordan–Wigner construction. Quantitative cyclic shift control is separate
+from the exact partition identities.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+/-- The phase with half-period `2^i`. -/
+def carDyadicPhase (i : ℕ) : ℂ := Complex.exp (((Real.pi / (2 : ℝ) ^ i : ℝ) : ℂ) * Complex.I)
+
+lemma carDyadicPhase_norm (i : ℕ) : ‖carDyadicPhase i‖ = 1 :=
+  Complex.norm_exp_ofReal_mul_I _
+
+lemma carDyadicPhase_half (i : ℕ) : carDyadicPhase i ^ (2 ^ i) = -1 := by
+  rw [carDyadicPhase, ← Complex.exp_nat_mul]
+  have hp : (2 : ℂ) ^ i ≠ 0 := pow_ne_zero _ (by norm_num)
+  have he : ((2 ^ i : ℕ) : ℂ) * (((Real.pi / (2 : ℝ) ^ i : ℝ) : ℂ) * Complex.I) =
+      (Real.pi : ℂ) * Complex.I := by
+    push_cast
+    field_simp
+  rw [he, Complex.exp_pi_mul_I]
+
+variable {E : Type*} [CStarAlgebra E] {n : ℕ}
+
+/-- Commuting two-level coordinates of the actual even row. -/
+def evenRohlinCoordinate (q : E) (r : Fin 2 × Fin n → E) (L i : ℕ) : E :=
+  carJordanWigner q (evenBlockFamily r L carDyadicPhase) i
+
+/-- The `k`th cell at dyadic level `m`. -/
+def evenRohlinProjection (q : E) (r : Fin 2 × Fin n → E) (L m k : ℕ) : E :=
+  dyadicSpinProjection q (evenRohlinCoordinate q r L) carDyadicPhase m k
+
+variable (q : E) (r : Fin 2 × Fin n → E)
+  (hqstar : star q = q) (hqq : q * q = q)
+  (hrow : ∀ i j, star (r i) * r j = if i = j then q else 0)
+  (hsum : (∑ i, r i * star (r i)) = q)
+
+include hqstar hqq hrow hsum in
+lemma evenRohlinCoordinate_properties (L : ℕ) (hL : 0 < L) :
+    (∀ i, q * evenRohlinCoordinate q r L i = evenRohlinCoordinate q r L i) ∧
+    (∀ i, evenRohlinCoordinate q r L i * q = evenRohlinCoordinate q r L i) ∧
+    (∀ i, evenRohlinCoordinate q r L i * evenRohlinCoordinate q r L i = 0) ∧
+    (∀ i, star (evenRohlinCoordinate q r L i) * evenRohlinCoordinate q r L i +
+      evenRohlinCoordinate q r L i * star (evenRohlinCoordinate q r L i) = q) ∧
+    (∀ i j, Commute (evenRohlinCoordinate q r L i) (evenRohlinCoordinate q r L j)) ∧
+    (∀ i j, i ≠ j → Commute (star (evenRohlinCoordinate q r L i))
+      (evenRohlinCoordinate q r L j)) := by
+  obtain ⟨hl, hr, ha, hg⟩ := evenBlockFamily_CAR q r hqstar hqq hrow hsum L hL
+    carDyadicPhase carDyadicPhase_norm
+  refine ⟨?_, ?_, ?_, ?_, ?_, ?_⟩
+  · intro i
+    exact (carJordanWigner_support q _ hqstar hqq hl hr ha hg i).1
+  · intro i
+    exact (carJordanWigner_support q _ hqstar hqq hl hr ha hg i).2
+  · exact carJordanWigner_square_zero q _ hqstar hqq hl hr ha hg
+  · exact carJordanWigner_gram q _ hqstar hqq hl hr ha hg
+  · exact carJordanWigner_commute q _ hqstar hqq hl hr ha hg
+  · exact carJordanWigner_star_commute q _ hqstar hqq hl hr ha hg
+
+include hqstar hqq hrow hsum in
+lemma evenRohlinProjection_partition (L : ℕ) (hL : 0 < L) (m : ℕ) :
+    (∀ k, IsStarProjection (evenRohlinProjection q r L m k)) ∧
+    (∑ k ∈ Finset.range (2 ^ m), evenRohlinProjection q r L m k) = q ∧
+    (∀ k l, k < 2 ^ m → l < 2 ^ m → k ≠ l →
+      evenRohlinProjection q r L m k * evenRohlinProjection q r L m l = 0) := by
+  obtain ⟨hl, hr, hz, hg, hc, hsc⟩ := evenRohlinCoordinate_properties q r hqstar hqq hrow hsum L hL
+  refine ⟨?_, ?_, ?_⟩
+  · exact dyadicSpinProjection_isStarProjection q _ _ hqstar hqq hl hr hz hg hc hsc
+      carDyadicPhase_norm m
+  · exact dyadicSpinProjection_sum q _ _ hqstar hqq hl hr carDyadicPhase_half m
+  · exact dyadicSpinProjection_orthogonal q _ _ hqstar hqq hl hr hz hg hc hsc
+      carDyadicPhase_norm carDyadicPhase_half m
+
+include hqstar hqq hrow hsum in
+lemma evenRohlinProjection_support (L : ℕ) (hL : 0 < L) (m k : ℕ) :
+    q * evenRohlinProjection q r L m k = evenRohlinProjection q r L m k ∧
+      evenRohlinProjection q r L m k * q = evenRohlinProjection q r L m k := by
+  obtain ⟨hl, hr, _, _, _, _⟩ := evenRohlinCoordinate_properties q r hqstar hqq hrow hsum L hL
+  exact dyadicSpinProjection_support q _ _ hqstar hqq hl hr m k
+
+include hqstar hqq hrow hsum in
+lemma evenRohlinBlock_shift_error (L : ℕ) (hL : 0 < L) (i : ℕ) :
+    ‖evenRowShift r (evenBlockFamily r L carDyadicPhase i) -
+      carDyadicPhase i • evenBlockFamily r L carDyadicPhase i‖ ^ 2 ≤ 18 / (L : ℝ) :=
+  evenEigenMode_shift_error q r hqstar hqq hrow hsum _ _ L hL _ (carDyadicPhase_norm i)
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RohlinPolar.lean

@@ -0,0 +1,109 @@
+import OAI.Analysis.OInfinity.RohlinUnitarity
+
+namespace OAI
+
+/-! # Polar correction of the finite Rohlin sum
+
+Both Gram defects are used. An element with small initial and final Gram
+defects is invertible; continuous functional calculus then corrects it to a
+nearby unitary. This step does not supply the tower commutator estimates.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+lemma isUnit_of_two_gram_units (x : E)
+    (hi : IsUnit (star x * x)) (hf : IsUnit (x * star x)) : IsUnit x := by
+  obtain ⟨a, ha⟩ := hi
+  obtain ⟨b, hb⟩ := hf
+  apply isUnit_iff_exists_and_exists.mpr
+  constructor
+  · refine ⟨star x * (↑b⁻¹ : E), ?_⟩
+    calc
+      x * (star x * (↑b⁻¹ : E)) = (x * star x) * (↑b⁻¹ : E) := by rw [mul_assoc]
+      _ = (b : E) * (↑b⁻¹ : E) := by rw [hb]
+      _ = 1 := b.val_inv
+  · refine ⟨(↑a⁻¹ : E) * star x, ?_⟩
+    calc
+      ((↑a⁻¹ : E) * star x) * x = (↑a⁻¹ : E) * (star x * x) := by rw [mul_assoc]
+      _ = (↑a⁻¹ : E) * (a : E) := by rw [ha]
+      _ = 1 := a.inv_val
+
+lemma isUnit_of_norm_sub_one_lt (a : E) (ha : ‖a - 1‖ < 1) : IsUnit a := by
+  have h : ‖1 - a‖ < 1 := by rwa [norm_sub_rev]
+  convert isUnit_one_sub_of_norm_lt_one h using 1
+  noncomm_ring
+
+local instance rohlinPolarOrder : PartialOrder E := CStarAlgebra.spectralOrder E
+local instance rohlinPolarStarOrder : StarOrderedRing E := CStarAlgebra.spectralOrderedRing E
+
+lemma exists_polar_unitary_of_two_gram_units (x : E)
+    (hi : IsUnit (star x * x)) (hf : IsUnit (x * star x)) :
+    ∃ u : unitary E, (u : E) = x * CFC.rpow (star x * x) (-1 / 2 : ℝ) := by
+  let a := star x * x
+  let b := CFC.rpow a (-1 / 2 : ℝ)
+  have ha : 0 ≤ a := star_mul_self_nonneg x
+  have hai : IsUnit a := hi
+  have hb : IsSelfAdjoint b := (CFC.rpow_nonneg (a := a) (y := (-1 / 2 : ℝ))).isSelfAdjoint
+  have hbi : IsUnit b := hi.cfcRpow (-1 / 2 : ℝ) ha
+  have hx : IsUnit x := isUnit_of_two_gram_units x hi hf
+  have hpow : (b * a) * b = 1 := by
+    change (CFC.rpow a (-1 / 2 : ℝ) * a) * CFC.rpow a (-1 / 2 : ℝ) = 1
+    conv_lhs => lhs; rhs; rw [← CFC.rpow_one a ha]
+    simp only [CFC.rpow_eq_pow]
+    rw [← CFC.rpow_add hai, ← CFC.rpow_add hai]
+    norm_num [CFC.rpow_zero a ha]
+  have hp : star (x * b) * (x * b) = 1 := by
+    rw [star_mul, hb.star_eq]
+    calc
+      _ = (b * a) * b := by dsimp [a]; noncomm_ring
+      _ = 1 := hpow
+  exact ⟨⟨x * b, (hx.mul hbi).mem_unitary_of_star_mul_self hp⟩, rfl⟩
+
+/-- An arbitrarily small polar correction follows from a sufficiently small
+initial Gram defect and a final Gram defect less than one. -/
+lemma exists_near_unitary_of_two_gram_errors [Nontrivial E] (ε : ℝ) (hε : 0 < ε) :
+    ∃ δ : ℝ, 0 < δ ∧ ∀ x : E,
+      ‖star x * x - 1‖ < δ → ‖x * star x - 1‖ < 1 →
+      ∃ u : unitary E, ‖(u : E) - x‖ < ε := by
+  have hcont : ContinuousWithinAt (fun a : E => CFC.rpow a (-1 / 2 : ℝ))
+      {a | IsStrictlyPositive a} 1 :=
+    CFC.continuousOn_rpow (-1 / 2 : ℝ) 1 (by exact isStrictlyPositive_one)
+  obtain ⟨δ, hδ, hb⟩ := Metric.continuousWithinAt_iff.mp hcont (ε / 2) (half_pos hε)
+  refine ⟨min δ 1, lt_min hδ zero_lt_one, ?_⟩
+  intro x hix hfx
+  have hi1 : ‖star x * x - 1‖ < 1 := hix.trans_le (min_le_right _ _)
+  have hi : IsUnit (star x * x) := isUnit_of_norm_sub_one_lt _ hi1
+  have hf : IsUnit (x * star x) := isUnit_of_norm_sub_one_lt _ hfx
+  have ha : IsStrictlyPositive (star x * x) := hi.isStrictlyPositive (star_mul_self_nonneg x)
+  have hbsmall : ‖CFC.rpow (star x * x) (-1 / 2 : ℝ) - 1‖ < ε / 2 := by
+    simpa only [dist_eq_norm, CFC.rpow_eq_pow, CFC.one_rpow] using hb ha (show dist (star x * x) 1 < δ from
+      by rw [dist_eq_norm]; exact hix.trans_le (min_le_left _ _))
+  have hxnorm : ‖x‖ < 2 := by
+    have hh : ‖star x * x‖ < 2 := by
+      calc
+        _ ≤ ‖star x * x - 1‖ + ‖(1 : E)‖ := norm_le_norm_sub_add _ _
+        _ = ‖star x * x - 1‖ + 1 := by rw [norm_one]
+        _ < 2 := by linarith
+    rw [CStarRing.norm_star_mul_self] at hh
+    nlinarith [norm_nonneg x]
+  obtain ⟨u, hu⟩ := exists_polar_unitary_of_two_gram_units x hi hf
+  refine ⟨u, ?_⟩
+  rw [hu]
+  calc
+    _ = ‖x * (CFC.rpow (star x * x) (-1 / 2 : ℝ) - 1)‖ := by rw [mul_sub, mul_one]
+    _ ≤ ‖x‖ * ‖CFC.rpow (star x * x) (-1 / 2 : ℝ) - 1‖ := norm_mul_le _ _
+    _ ≤ 2 * ‖CFC.rpow (star x * x) (-1 / 2 : ℝ) - 1‖ :=
+      mul_le_mul_of_nonneg_right hxnorm.le (norm_nonneg _)
+    _ < 2 * (ε / 2) := mul_lt_mul_of_pos_left hbsmall (by norm_num)
+    _ = ε := by ring
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RohlinShift.lean

@@ -0,0 +1,180 @@
+import OAI.Analysis.OInfinity.JordanWignerEstimates
+
+namespace OAI
+
+/-! # Quantitative cyclic partitions for the finite even-row shift
+
+The exact dyadic projection partition is approximately cycled by the actual
+row endomorphism, with an explicit error tending to zero as the geometric
+blocks lengthen. No centrality for additional elements or cocycle unitary is
+asserted here.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E] {n : ℕ}
+
+lemma carSpinProjection_sub_norm_le (q a b : E) (ζ : ℂ) (hζ : ‖ζ‖ = 1) :
+    ‖carSpinProjection q a ζ - carSpinProjection q b ζ‖ ≤ ‖a - b‖ := by
+  have he : carSpinProjection q a ζ - carSpinProjection q b ζ =
+      (2 : ℂ)⁻¹ • (ζ • (a - b) + star ζ • star (a - b)) := by
+    simp only [carSpinProjection, carSpinAxis, smul_sub, smul_add, star_sub]
+    abel
+  rw [he, norm_smul]
+  have hhalf : ‖(2 : ℂ)⁻¹‖ = (1 / 2 : ℝ) := by norm_num
+  rw [hhalf]
+  calc
+    _ ≤ (1 / 2 : ℝ) * (‖ζ • (a - b)‖ + ‖star ζ • star (a - b)‖) := by
+      gcongr
+      exact norm_add_le _ _
+    _ = ‖a - b‖ := by rw [norm_smul, norm_smul, norm_star, norm_star, hζ]; ring
+
+lemma carSpinProjection_smul (q a : E) (μ ζ : ℂ) :
+    carSpinProjection q (μ • a) ζ = carSpinProjection q a (ζ * μ) := by
+  simp only [carSpinProjection, carSpinAxis, star_smul, smul_smul, star_mul]
+  rw [mul_comm (star μ) (star ζ)]
+
+lemma evenRowShift_carSpinProjection (q : E) (r : Fin 2 × Fin n → E)
+    (hqstar : star q = q) (hqq : q * q = q)
+    (hrow : ∀ i j, star (r i) * r j = if i = j then q else 0)
+    (hsum : (∑ i, r i * star (r i)) = q) (a : E) (ζ : ℂ) :
+    evenRowShift r (carSpinProjection q a ζ) = carSpinProjection q (evenRowShift r a) ζ := by
+  simp only [carSpinProjection, carSpinAxis, evenRowShift_smul, evenRowShift_add,
+    evenRowShift_unit q r hqstar hqq hrow hsum, ← evenRowShift_star]
+
+lemma evenRowShift_isStarProjection (q : E) (r : Fin 2 × Fin n → E)
+    (hrow : ∀ i j, star (r i) * r j = if i = j then q else 0)
+    (p : E) (hp : IsStarProjection p) (hqp : q * p = p) :
+    IsStarProjection (evenRowShift r p) := by
+  refine ⟨?_, ?_⟩
+  · change evenRowShift r p * evenRowShift r p = evenRowShift r p
+    rw [evenRowShift_mul q r hrow p p hqp, hp.isIdempotentElem.eq]
+  · change star (evenRowShift r p) = evenRowShift r p
+    rw [evenRowShift_star, hp.isSelfAdjoint.star_eq]
+
+variable (q : E) (r : Fin 2 × Fin n → E)
+  (hqstar : star q = q) (hqq : q * q = q)
+  (hrow : ∀ i j, star (r i) * r j = if i = j then q else 0)
+  (hsum : (∑ i, r i * star (r i)) = q)
+
+include hqstar hqq hrow hsum in
+lemma evenRohlin_factor_shift_error (L : ℕ) (hL : 0 < L) (i k : ℕ) :
+    ‖evenRowShift r (carSpinProjection q (evenRohlinCoordinate q r L i) (carDyadicPhase i ^ k)) -
+      carSpinProjection q (evenRohlinCoordinate q r L i) (carDyadicPhase i ^ (k + 1))‖ ≤
+        (4 * (i : ℝ) + 1) * Real.sqrt (18 / (L : ℝ)) := by
+  rw [evenRowShift_carSpinProjection q r hqstar hqq hrow hsum, pow_succ,
+    ← carSpinProjection_smul]
+  exact (carSpinProjection_sub_norm_le q _ _ _
+    (by rw [norm_pow, carDyadicPhase_norm, one_pow])).trans
+      (evenRohlinCoordinate_shift_error q r hqstar hqq hrow hsum L hL i)
+
+include hqstar hqq hrow hsum in
+lemma evenRohlin_factor_properties (L : ℕ) (hL : 0 < L) (i k : ℕ) :
+    IsStarProjection (carSpinProjection q (evenRohlinCoordinate q r L i) (carDyadicPhase i ^ k)) ∧
+      q * carSpinProjection q (evenRohlinCoordinate q r L i) (carDyadicPhase i ^ k) =
+        carSpinProjection q (evenRohlinCoordinate q r L i) (carDyadicPhase i ^ k) := by
+  obtain ⟨hl, hr, hz, hg, _, _⟩ := evenRohlinCoordinate_properties q r hqstar hqq hrow hsum L hL
+  exact ⟨carSpinProjection_isStarProjection q _ hqstar hqq (hl i) (hr i) (hz i) (hg i) _
+    (by rw [norm_pow, carDyadicPhase_norm, one_pow]),
+    (carSpinProjection_support q _ hqstar hqq (hl i) (hr i) _).1⟩
+
+include hqstar hqq hrow hsum in
+lemma evenRohlinProjection_shift_error (L : ℕ) (hL : 0 < L) (m k : ℕ) :
+    ‖evenRowShift r (evenRohlinProjection q r L m k) -
+      evenRohlinProjection q r L m (k + 1)‖ ≤
+        (m : ℝ) * (4 * (m : ℝ) + 1) * Real.sqrt (18 / (L : ℝ)) := by
+  induction m with
+  | zero =>
+    change ‖evenRowShift r q - q‖ ≤ _
+    rw [evenRowShift_unit q r hqstar hqq hrow hsum, sub_self, norm_zero]
+    simp
+  | succ m ih =>
+    let P := evenRohlinProjection q r L m k
+    let P' := evenRohlinProjection q r L m (k + 1)
+    let e := carSpinProjection q (evenRohlinCoordinate q r L m) (carDyadicPhase m ^ k)
+    let e' := carSpinProjection q (evenRohlinCoordinate q r L m) (carDyadicPhase m ^ (k + 1))
+    let δ := Real.sqrt (18 / (L : ℝ))
+    have heprops := evenRohlin_factor_properties q r hqstar hqq hrow hsum L hL m k
+    have henorm : ‖evenRowShift r e‖ ≤ 1 := IsStarProjection.norm_le _
+      (evenRowShift_isStarProjection q r hrow e heprops.1 heprops.2)
+    have hPnorm : ‖P'‖ ≤ 1 := IsStarProjection.norm_le _
+      ((evenRohlinProjection_partition q r hqstar hqq hrow hsum L hL m).1 (k + 1))
+    have herr : ‖evenRowShift r e - e'‖ ≤ (4 * (m : ℝ) + 1) * δ :=
+      evenRohlin_factor_shift_error q r hqstar hqq hrow hsum L hL m k
+    have hdecomp : evenRowShift r (evenRohlinProjection q r L (m + 1) k) -
+        evenRohlinProjection q r L (m + 1) (k + 1) =
+          (evenRowShift r P - P') * evenRowShift r e + P' * (evenRowShift r e - e') := by
+      change evenRowShift r (P * e) - P' * e' = _
+      rw [← evenRowShift_mul q r hrow P e heprops.2]
+      noncomm_ring
+    rw [hdecomp]
+    calc
+      _ ≤ ‖(evenRowShift r P - P') * evenRowShift r e‖ +
+          ‖P' * (evenRowShift r e - e')‖ := norm_add_le _ _
+      _ ≤ ‖evenRowShift r P - P'‖ * ‖evenRowShift r e‖ + ‖P'‖ * ‖evenRowShift r e - e'‖ :=
+        add_le_add (norm_mul_le _ _) (norm_mul_le _ _)
+      _ ≤ ((m : ℝ) * (4 * (m : ℝ) + 1) * δ) * 1 + 1 * ((4 * (m : ℝ) + 1) * δ) := by
+        gcongr
+      _ ≤ (↑(m + 1) : ℝ) * (4 * (↑(m + 1) : ℝ) + 1) * δ := by
+        push_cast
+        nlinarith [Real.sqrt_nonneg (18 / (L : ℝ))]
+
+lemma evenRohlinProjection_period (L : ℕ) (m k : ℕ) :
+    evenRohlinProjection q r L m (k + 2 ^ m) = evenRohlinProjection q r L m k :=
+  dyadicSpinProjection_period q _ carDyadicPhase carDyadicPhase_half m k
+
+include hqstar hqq hrow hsum in
+lemma evenRohlinProjection_cyclic_error (L : ℕ) (hL : 0 < L) (m k : ℕ) (hk : k < 2 ^ m) :
+    ‖evenRowShift r (evenRohlinProjection q r L m k) -
+      evenRohlinProjection q r L m ((k + 1) % (2 ^ m))‖ ≤
+        (m : ℝ) * (4 * (m : ℝ) + 1) * Real.sqrt (18 / (L : ℝ)) := by
+  have he : evenRohlinProjection q r L m ((k + 1) % (2 ^ m)) =
+      evenRohlinProjection q r L m (k + 1) := by
+    by_cases hlt : k + 1 < 2 ^ m
+    · rw [Nat.mod_eq_of_lt hlt]
+    · have heq : k + 1 = 2 ^ m := by omega
+      rw [heq, Nat.mod_self]
+      simpa only [zero_add] using (evenRohlinProjection_period q r L m 0).symm
+  rw [he]
+  exact evenRohlinProjection_shift_error q r hqstar hqq hrow hsum L hL m k
+
+include hqstar hqq hrow hsum in
+lemma exists_evenRohlin_cyclic_partition (m : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ L : ℕ, 0 < L ∧
+      (∀ k, IsStarProjection (evenRohlinProjection q r L m k)) ∧
+      (∑ k ∈ Finset.range (2 ^ m), evenRohlinProjection q r L m k) = q ∧
+      (∀ k l, k < 2 ^ m → l < 2 ^ m → k ≠ l →
+        evenRohlinProjection q r L m k * evenRohlinProjection q r L m l = 0) ∧
+      (∀ k, k < 2 ^ m → ‖evenRowShift r (evenRohlinProjection q r L m k) -
+        evenRohlinProjection q r L m ((k + 1) % (2 ^ m))‖ < ε) := by
+  let C : ℝ := (m : ℝ) * (4 * (m : ℝ) + 1)
+  have hC : 0 ≤ C := by dsimp [C]; positivity
+  have hεsq : 0 < ε ^ 2 := sq_pos_of_pos hε
+  obtain ⟨L, hL⟩ := exists_nat_gt (18 * C ^ 2 / ε ^ 2 + 1)
+  have hLpos : 0 < L := by
+    have hnonneg : 0 ≤ 18 * C ^ 2 / ε ^ 2 := by positivity
+    exact_mod_cast (show (0 : ℝ) < (L : ℝ) by linarith)
+  have hLreal : (0 : ℝ) < (L : ℝ) := by exact_mod_cast hLpos
+  have hbound : 18 * C ^ 2 < (L : ℝ) * ε ^ 2 := by
+    apply (div_lt_iff₀ hεsq).mp
+    linarith
+  have hbound' : 18 * C ^ 2 / (L : ℝ) < ε ^ 2 := (div_lt_iff₀ hLreal).mpr (by nlinarith)
+  have hsqrt := Real.sq_sqrt (show 0 ≤ 18 / (L : ℝ) by positivity)
+  have hnorm : C * Real.sqrt (18 / (L : ℝ)) < ε := by
+    have he : (C * Real.sqrt (18 / (L : ℝ))) ^ 2 = 18 * C ^ 2 / (L : ℝ) := by
+      rw [mul_pow, hsqrt]
+      ring
+    nlinarith [mul_nonneg hC (Real.sqrt_nonneg (18 / (L : ℝ)))]
+  obtain ⟨hp, hsum', horth⟩ := evenRohlinProjection_partition q r hqstar hqq hrow hsum L hLpos m
+  refine ⟨L, hLpos, hp, hsum', horth, ?_⟩
+  intro k hk
+  exact (evenRohlinProjection_cyclic_error q r hqstar hqq hrow hsum L hLpos m k hk).trans_lt hnorm
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RohlinUnitarity.lean

@@ -0,0 +1,115 @@
+import OAI.Analysis.OInfinity.RohlinGluing
+
+namespace OAI
+
+/-! # Both unitary defects of a weighted Rohlin sum
+
+The diagonal coefficient/projection commutators control both defects. The
+second estimate compares the adjoint weighted sum with the weighted adjoints;
+it does not require pairwise commutation of all coefficients and projections.
+The hypotheses still have to be supplied by the actual tower construction.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E I : Type*} [CStarAlgebra E] [Fintype I] [DecidableEq I]
+
+lemma adjoint_unitary_commutator_norm (u : unitary E) (e : E)
+    (he : star e = e) :
+    ‖(star u : unitary E) * e - e * (star u : unitary E)‖ =
+      ‖(u : E) * e - e * (u : E)‖ := by
+  calc
+    _ = ‖star ((star u : unitary E) * e - e * (star u : unitary E))‖ :=
+      (norm_star _).symm
+    _ = ‖e * (u : E) - (u : E) * e‖ := by
+      simp only [star_sub, star_mul, he, Unitary.coe_star, star_star]
+    _ = _ := norm_sub_rev _ _
+
+lemma star_mul_self_sub_norm_le (x y : E) :
+    ‖star x * x - star y * y‖ ≤ (‖x‖ + ‖y‖) * ‖x - y‖ := by
+  have hid : star x * x - star y * y =
+      star x * (x - y) + star (x - y) * y := by
+    rw [star_sub]
+    noncomm_ring
+  rw [hid]
+  calc
+    _ ≤ ‖star x * (x - y)‖ + ‖star (x - y) * y‖ := norm_add_le _ _
+    _ ≤ ‖x‖ * ‖x - y‖ + ‖x - y‖ * ‖y‖ := by
+      simpa only [norm_star] using add_le_add
+        (norm_mul_le (star x) (x - y)) (norm_mul_le (star (x - y)) y)
+    _ = _ := by ring
+
+lemma finiteRohlinSum_norm_le [Nontrivial E] (v : I → unitary E) (e : I → E)
+    (he : ∀ i, star (e i) = e i) (hee : ∀ i, e i * e i = e i)
+    (horth : ∀ i j, i ≠ j → e i * e j = 0) :
+    ‖finiteRohlinSum v e‖ ≤ Real.sqrt (Fintype.card I) := by
+  change ‖∑ i, (v i : E) * e i‖ ≤ _
+  simpa only [mul_one] using orthogonalWeighted_norm_le e (fun i => (v i : E))
+    he hee horth 1 (by norm_num) (fun i => (CStarRing.norm_coe_unitary (v i)).le)
+
+omit [DecidableEq I] in
+lemma finiteRohlinSum_star_commutator_le (v : I → unitary E) (e : I → E)
+    (he : ∀ i, star (e i) = e i) (δ : ℝ)
+    (hc : ∀ i, ‖(v i : E) * e i - e i * (v i : E)‖ ≤ δ) :
+    ‖star (finiteRohlinSum v e) - finiteRohlinSum (fun i => star (v i)) e‖ ≤
+      (Fintype.card I : ℝ) * δ := by
+  change ‖star (∑ i, (v i : E) * e i) - ∑ i, (star (v i) : unitary E) * e i‖ ≤ _
+  rw [star_sum, ← Finset.sum_sub_distrib]
+  calc
+    _ ≤ ∑ i, ‖star ((v i : E) * e i) - (star (v i) : unitary E) * e i‖ :=
+      norm_sum_le _ _
+    _ ≤ ∑ _ : I, δ := by
+      apply Finset.sum_le_sum
+      intro i hi
+      rw [star_mul, he i, Unitary.coe_star, norm_sub_rev]
+      exact (adjoint_unitary_commutator_norm (v i) (e i) (he i)).le.trans (hc i)
+    _ = _ := by simp
+
+/-- The second defect has a dimension-dependent bound, sufficient when the
+commutator accuracy is chosen after the finite tower size. -/
+lemma finiteRohlinSum_isometry_defect_le [Nontrivial E] (v : I → unitary E) (e : I → E)
+    (he : ∀ i, star (e i) = e i) (hee : ∀ i, e i * e i = e i)
+    (horth : ∀ i j, i ≠ j → e i * e j = 0)
+    (hsum : (∑ i, e i) = 1) (δ : ℝ)
+    (hc : ∀ i, ‖(v i : E) * e i - e i * (v i : E)‖ ≤ δ) :
+    ‖star (finiteRohlinSum v e) * finiteRohlinSum v e - 1‖ ≤
+      (Fintype.card I : ℝ) * (2 * Real.sqrt (Fintype.card I) + 1) * δ := by
+  let z := finiteRohlinSum v e
+  let y := finiteRohlinSum (fun i => star (v i)) e
+  have hz : ‖z‖ ≤ Real.sqrt (Fintype.card I) := finiteRohlinSum_norm_le v e he hee horth
+  have hy : ‖y‖ ≤ Real.sqrt (Fintype.card I) :=
+    finiteRohlinSum_norm_le (fun i => star (v i)) e he hee horth
+  have hc' (i : I) : ‖(star (v i) : unitary E) * e i -
+      e i * (star (v i) : unitary E)‖ ≤ δ :=
+    (adjoint_unitary_commutator_norm (v i) (e i) (he i)).le.trans (hc i)
+  have hydef : ‖y * star y - 1‖ ≤ (Fintype.card I : ℝ) * δ :=
+    finiteRohlinSum_coisometry_defect_le (fun i => star (v i)) e he hee horth hsum δ hc'
+  have hdist : ‖z - star y‖ ≤ (Fintype.card I : ℝ) * δ := by
+    calc
+      _ = ‖star z - y‖ := by rw [← norm_star (star z - y), star_sub, star_star]
+      _ ≤ _ := finiteRohlinSum_star_commutator_le v e he δ hc
+  have hdiff : ‖star z * z - y * star y‖ ≤
+      (2 * Real.sqrt (Fintype.card I)) * ((Fintype.card I : ℝ) * δ) := by
+    calc
+      _ = ‖star z * z - star (star y) * star y‖ := by rw [star_star]
+      _ ≤ (‖z‖ + ‖star y‖) * ‖z - star y‖ := star_mul_self_sub_norm_le z (star y)
+      _ ≤ (2 * Real.sqrt (Fintype.card I)) * ((Fintype.card I : ℝ) * δ) := by
+        rw [norm_star]
+        exact mul_le_mul (by linarith) hdist (norm_nonneg _)
+          (by positivity)
+  change ‖star z * z - 1‖ ≤ _
+  calc
+    _ ≤ ‖star z * z - y * star y‖ + ‖y * star y - 1‖ :=
+      norm_sub_le_norm_sub_add_norm_sub _ _ _
+    _ ≤ (2 * Real.sqrt (Fintype.card I)) * ((Fintype.card I : ℝ) * δ) +
+        (Fintype.card I : ℝ) * δ := add_le_add hdiff hydef
+    _ = _ := by ring
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RowCocycleDefect.lean

@@ -0,0 +1,223 @@
+import OAI.Analysis.OInfinity.BinaryFragmentation
+
+namespace OAI
+
+/-! # The actual row cocycle and its finite splitting defect
+
+The product cocycle `V_n = W φ(W) ... φ^[n-1](W)` is not a finite
+permutation. Its splitting defect is: `V_n φ(V_n*) = ψ^[n](W*) W`,
+where `ψ = Ad(W) φ`. For commuting binary Cuntz rows the right side is
+the adjoint of the joint-word cycle already constructed.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+section Group
+
+variable {G : Type*} [Group G]
+
+def finiteGroupCocycle (φ : G →* G) (u : G) : ℕ → G
+  | 0 => 1
+  | n + 1 => u * φ (finiteGroupCocycle φ u n)
+
+lemma finiteGroupCocycle_splitting_defect (φ ψ : G →* G) (u : G)
+    (hψ : ∀ x, ψ x = u * φ x * u⁻¹) (n : ℕ) :
+    finiteGroupCocycle φ u n * φ ((finiteGroupCocycle φ u n)⁻¹) =
+      (ψ^[n]) (u⁻¹) * u := by
+  induction n with
+  | zero => simp [finiteGroupCocycle]
+  | succ n ih =>
+      change (u * φ (finiteGroupCocycle φ u n)) *
+        φ ((u * φ (finiteGroupCocycle φ u n))⁻¹) = _
+      calc
+        _ = u * φ (finiteGroupCocycle φ u n *
+            φ ((finiteGroupCocycle φ u n)⁻¹)) * φ (u⁻¹) := by
+          simp only [map_mul, map_inv, mul_inv_rev]
+          group
+        _ = u * (φ ((ψ^[n]) (u⁻¹)) * φ u) * φ (u⁻¹) := by rw [ih, map_mul]
+        _ = ψ ((ψ^[n]) (u⁻¹)) * u := by
+          rw [hψ]
+          simp only [map_inv]
+          group
+        _ = _ := by rw [Function.iterate_succ_apply']
+
+end Group
+
+variable {E : Type*} [CStarAlgebra E]
+
+def binarySplitHom (a b : E) (ha : star a * a = 1) (hb : star b * b = 1)
+    (hab : star a * b = 0) : unitary E →* unitary E where
+  toFun u := binaryCornerUnitary a ha u * binaryCornerUnitary b hb u
+  map_one' := by rw [binaryCornerUnitary_one, binaryCornerUnitary_one, one_mul]
+  map_mul' u v := by
+    change binaryCornerUnitary a ha (u * v) * binaryCornerUnitary b hb (u * v) = _
+    rw [binaryCornerUnitary_mul, binaryCornerUnitary_mul]
+    calc
+      _ = binaryCornerUnitary a ha u *
+          (binaryCornerUnitary a ha v * binaryCornerUnitary b hb u) *
+          binaryCornerUnitary b hb v := by simp only [mul_assoc]
+      _ = binaryCornerUnitary a ha u *
+          (binaryCornerUnitary b hb u * binaryCornerUnitary a ha v) *
+          binaryCornerUnitary b hb v := by
+        rw [(binaryCornerUnitary_commute a b ha hb hab v u).eq]
+      _ = _ := by simp only [mul_assoc]
+
+lemma binarySplitHom_coe (s : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (hsum : (∑ i, s i * star (s i)) = 1) (u : unitary E) :
+    (binarySplitHom (s 0) (s 1) (by simpa using hs 0 0)
+      (by simpa using hs 1 1) (by simpa using hs 0 1) u : E) = finiteRowShift s u := by
+  change cornerCompression (s 0) u * cornerCompression (s 1) u = _
+  have hsum' : s 0 * star (s 0) + s 1 * star (s 1) = 1 := by
+    simpa only [Fin.sum_univ_two] using hsum
+  rw [cornerCompression_pair_product _ _ _ _ (by simpa using hs 0 1)]
+  simp only [finiteRowShift, Fin.sum_univ_two]
+  rw [← hsum']
+  noncomm_ring
+
+def binaryRowUnitary (s t : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then 1 else 0)
+    (hsum : (∑ i, s i * star (s i)) = 1)
+    (htsum : (∑ i, t i * star (t i)) = 1) : unitary E :=
+  ⟨finiteRowCocycle s t,
+    finiteRowCocycle_gram 1 s t (by simp) (by simp) hs ht hsum htsum⟩
+
+lemma finiteRowCocycle_conjugate_shift (s t : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then 1 else 0) (x : E) :
+    finiteRowCocycle s t * finiteRowShift s x * star (finiteRowCocycle s t) =
+      finiteRowShift t x := by
+  simp only [finiteRowShift, Finset.mul_sum, Finset.sum_mul]
+  apply Finset.sum_congr rfl
+  intro i hi
+  have he : star (s i) * star (finiteRowCocycle s t) = star (t i) := by
+    simpa only [star_mul] using congrArg star
+      (finiteRowCocycle_mul_row 1 s t (by simp) (by simp) hs ht i)
+  calc
+    _ = (finiteRowCocycle s t * s i) * x *
+        (star (s i) * star (finiteRowCocycle s t)) := by noncomm_ring
+    _ = _ := by rw [finiteRowCocycle_mul_row 1 s t (by simp) (by simp) hs ht, he]
+
+lemma binarySplitHom_conjugacy (s t : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then 1 else 0)
+    (hsum : (∑ i, s i * star (s i)) = 1)
+    (htsum : (∑ i, t i * star (t i)) = 1) (x : unitary E) :
+    binarySplitHom (t 0) (t 1) (by simpa using ht 0 0)
+        (by simpa using ht 1 1) (by simpa using ht 0 1) x =
+      binaryRowUnitary s t hs ht hsum htsum *
+        binarySplitHom (s 0) (s 1) (by simpa using hs 0 0)
+          (by simpa using hs 1 1) (by simpa using hs 0 1) x *
+        (binaryRowUnitary s t hs ht hsum htsum)⁻¹ := by
+  apply Subtype.ext
+  rw [binarySplitHom_coe t ht htsum]
+  change finiteRowShift t x = finiteRowCocycle s t *
+    (binarySplitHom (s 0) (s 1) _ _ _ x : E) * star (finiteRowCocycle s t)
+  rw [binarySplitHom_coe s hs hsum]
+  exact (finiteRowCocycle_conjugate_shift s t hs ht x).symm
+
+lemma binarySplitHom_iterate_coe (s : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (hsum : (∑ i, s i * star (s i)) = 1) (x : unitary E) (n : ℕ) :
+    (((binarySplitHom (s 0) (s 1) (by simpa using hs 0 0)
+      (by simpa using hs 1 1) (by simpa using hs 0 1))^[n]) x : E) =
+        finiteRowShiftIterate s n x := by
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+      rw [Function.iterate_succ_apply', binarySplitHom_coe s hs hsum, finiteRowShiftIterate, ih]
+
+lemma finiteRowShift_star (s : Fin 2 → E) (x : E) :
+    star (finiteRowShift s x) = finiteRowShift s (star x) := by
+  simp only [finiteRowShift, star_sum, star_mul, star_star, mul_assoc]
+
+lemma finiteRowShiftIterate_star (s : Fin 2 → E) (n : ℕ) (x : E) :
+    star (finiteRowShiftIterate s n x) = finiteRowShiftIterate s n (star x) := by
+  induction n with
+  | zero => rfl
+  | succ n ih => rw [finiteRowShiftIterate, finiteRowShift_star, ih]; rfl
+
+def binaryRowCocycleUnitary (s t : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then 1 else 0)
+    (hsum : (∑ i, s i * star (s i)) = 1)
+    (htsum : (∑ i, t i * star (t i)) = 1) (n : ℕ) : unitary E :=
+  finiteGroupCocycle (binarySplitHom (s 0) (s 1) (by simpa using hs 0 0)
+    (by simpa using hs 1 1) (by simpa using hs 0 1))
+    (binaryRowUnitary s t hs ht hsum htsum) n
+
+/-- The splitting defect of the actual product cocycle, not the product
+itself, is the adjoint joint-word permutation. -/
+lemma binaryRowCocycleUnitary_defect (s t : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then 1 else 0)
+    (hsum : (∑ i, s i * star (s i)) = 1)
+    (htsum : (∑ i, t i * star (t i)) = 1) (n : ℕ) :
+    ((binaryRowCocycleUnitary s t hs ht hsum htsum n : E) *
+      star (binarySplitHom (s 0) (s 1) (by simpa using hs 0 0)
+        (by simpa using hs 1 1) (by simpa using hs 0 1)
+        (binaryRowCocycleUnitary s t hs ht hsum htsum n) : E)) =
+      star (finiteJointCycleCoboundary t s n) := by
+  let α := binarySplitHom (s 0) (s 1) (by simpa using hs 0 0)
+    (by simpa using hs 1 1) (by simpa using hs 0 1)
+  let β := binarySplitHom (t 0) (t 1) (by simpa using ht 0 0)
+    (by simpa using ht 1 1) (by simpa using ht 0 1)
+  let w := binaryRowUnitary s t hs ht hsum htsum
+  have h := finiteGroupCocycle_splitting_defect α β w
+    (binarySplitHom_conjugacy s t hs ht hsum htsum) n
+  rw [map_inv] at h
+  have he := congrArg (fun v : unitary E => (v : E)) h
+  change (↑(finiteGroupCocycle α w n) : E) * star (↑(α (finiteGroupCocycle α w n)) : E) =
+    ((β^[n]) (w⁻¹) : E) * (w : E) at he
+  rw [binarySplitHom_iterate_coe t ht htsum] at he
+  change (binaryRowCocycleUnitary s t hs ht hsum htsum n : E) *
+    star (α (binaryRowCocycleUnitary s t hs ht hsum htsum n) : E) =
+      finiteRowShiftIterate t n (star (finiteRowCocycle s t)) * finiteRowCocycle s t at he
+  simpa only [finiteJointCycleCoboundary, star_mul, finiteRowShiftIterate_star,
+    star_star, finiteRowCocycle_star] using he
+
+/-- Uniform paths for the genuine binary product cocycles. The bound is
+independent of the number of factors. These are coisometric rows in the
+ambient unit; applying this in a proper corner requires corner transport. -/
+lemma exists_uniform_binaryRowCocycle_path [Nontrivial E] (s t : Fin 2 → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then 1 else 0)
+    (hsum : (∑ i, s i * star (s i)) = 1)
+    (htsum : (∑ i, t i * star (t i)) = 1)
+    (hc : ∀ i j, Commute (s i) (t j)) (n : ℕ) :
+    ∃ p : Path (binaryRowCocycleUnitary s t hs ht hsum htsum n) 1,
+      ∀ a b, ‖(p a : E) - p b‖ ≤ (192 * Real.pi) * |(a : ℝ) - b| := by
+  let v := binaryRowCocycleUnitary s t hs ht hsum htsum n
+  let α := binarySplitHom (s 0) (s 1) (by simpa using hs 0 0)
+    (by simpa using hs 1 1) (by simpa using hs 0 1)
+  obtain ⟨c, hcoe, p, hp⟩ := exists_controlled_jointCycleCoboundary_path
+    1 t s (by simp) (by simp) ht hs htsum hsum (fun i j => (hc j i).symm) n
+  simp only [sub_self, add_zero] at hcoe
+  have hd : v * star (α v) = star c := by
+    apply Subtype.ext
+    change (v : E) * star (α v : E) = star (c : E)
+    rw [hcoe]
+    exact binaryRowCocycleUnitary_defect s t hs ht hsum htsum n
+  let q : Path (1 : unitary E) (v * star (α v)) :=
+    (p.map (continuous_star : Continuous (star : unitary E → unitary E))).cast (by simp) hd
+  have hq : ∀ a b, ‖(q a : E) - q b‖ ≤ (4 * Real.pi) * |(a : ℝ) - b| := by
+    intro a b
+    change ‖star (p a : E) - star (p b : E)‖ ≤ _
+    rw [← star_sub, norm_star]
+    exact hp a b
+  obtain ⟨r, hr⟩ := exists_binaryFragmentation_of_defect_path (s 0) (s 1)
+    (by simpa using hs 0 0) (by simpa using hs 1 1) (by simpa using hs 0 1)
+    v (4 * Real.pi) (by positivity) q hq
+  refine ⟨r, ?_⟩
+  intro a b
+  simpa only [show 32 * (4 * Real.pi + 2 * Real.pi) = 192 * Real.pi by ring] using hr a b
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RowCompletionBase.lean

@@ -0,0 +1,145 @@
+import OAI.Analysis.OInfinity.ConnectedRowCompletion
+
+namespace OAI
+
+/-! # The actual base path of the common-corner shrink
+
+Binary completions chosen with connected left cocycles have a connected
+base comparison. The proof identifies that base with compression of the
+literal cocycle product by one fixed isometry. No general claim about a
+corner stabilizer or about the ambient unitary group is used.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+/-- The cross product of two fillers with the same initial projection is
+the standard compression of their middle unitary product. -/
+lemma coisometry_filler_cross (A y : E) (hA : A * star A = 1)
+    (hy : star y * y = 1) (hpy : (star A * A) * y = y) (u v : unitary E) :
+    star (1 - star A * A + y * (star (v : E) * A)) *
+        (1 - star A * A + y * (star (u : E) * A)) =
+      (binaryCornerUnitary (star A) (by simpa only [star_star] using hA) (v * star u) : E) := by
+  let p := star A * A
+  let e := 1 - p
+  have hp : star p = p := by simp only [p, star_mul, star_star]
+  have hpp : p * p = p := by
+    change (star A * A) * (star A * A) = star A * A
+    calc
+      _ = star A * (A * star A) * A := by noncomm_ring
+      _ = _ := by rw [hA, mul_one]
+  have he : star e = e := by simp only [e, star_sub, star_one, hp]
+  have hee : e * e = e := by dsimp only [e]; noncomm_ring [hpp]
+  have hey : e * y = 0 := by
+    change (1 - star A * A) * y = 0
+    rw [sub_mul, one_mul, hpy, sub_self]
+  have hleft (w : unitary E) : e * (y * (star (w : E) * A)) = 0 := by
+    rw [← mul_assoc, hey, zero_mul]
+  have hright : star (y * (star (v : E) * A)) * e = 0 := by
+    simpa only [star_mul, he, star_zero] using congrArg star (hleft v)
+  have hmiddle : star (y * (star (v : E) * A)) * (y * (star (u : E) * A)) =
+      star A * ((v : E) * star (u : E)) * A := by
+    simp only [star_mul, star_star]
+    calc
+      _ = star A * (v : E) * (star y * y) * star (u : E) * A := by noncomm_ring
+      _ = _ := by rw [hy, mul_one]; noncomm_ring
+  change _ = cornerCompression (star A) ((v * star u : unitary E) : E)
+  unfold cornerCompression
+  rw [star_star]
+  change star (e + y * (star (v : E) * A)) * (e + y * (star (u : E) * A)) =
+    star A * ((v : E) * star (u : E)) * A + e
+  rw [star_add, he, add_mul, mul_add, mul_add, hee, hleft, hright, hmiddle]
+  abel
+
+/-- Factoring the reference row out of the finite transfer keeps the
+initial projection independent of the chosen completion cocycle. -/
+lemma binaryShrinkValue_reference (r b : Fin 2 → E) (u : unitary E) :
+    binaryShrinkValue r (fun i => star (u : E) * b i) 1 =
+      1 - star (finiteCuntzTransfer r b 1) * finiteCuntzTransfer r b 1 +
+        r 1 * (star (u : E) * finiteCuntzTransfer r b 1) := by
+  let A := finiteCuntzTransfer r b 1
+  have htransfer : finiteCuntzTransfer r (fun i => star (u : E) * b i) 1 =
+      star (u : E) * A := by
+    simp only [A, finiteCuntzTransfer, Finset.mul_sum, mul_one, mul_assoc]
+  rw [binaryShrinkValue_one, htransfer]
+  change 1 - star (star (u : E) * A) * (star (u : E) * A) +
+    r 1 * (star (u : E) * A) = _
+  have hg : star (star (u : E) * A) * (star (u : E) * A) = star A * A := by
+    rw [star_mul, star_star]
+    calc
+      _ = star A * ((u : E) * star (u : E)) * A := by noncomm_ring
+      _ = _ := by rw [u.property.2, mul_one]
+  rw [hg]
+
+/-- The fixed isometry and the full reference row give the exact base
+identity used in the two common-corner comparisons. -/
+lemma finiteCuntzTransfer_reference_coisometry (r b : Fin 2 → E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (hbs : (∑ i, b i * star (b i)) = 1) :
+    finiteCuntzTransfer r b 1 * star (finiteCuntzTransfer r b 1) = 1 := by
+  have hs : star (finiteCuntzTransfer r b 1) = finiteCuntzTransfer b r 1 := by
+    simpa only [star_one] using finiteCuntzTransfer_star r b 1
+  have hh := finiteCuntzTransfer_star_mul b r hr 1
+  rw [← hs, star_star] at hh
+  simpa only [star_one, one_mul, mul_one, hbs] using hh
+
+lemma binaryShrinkValue_reference_cross (r b : Fin 2 → E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (hb : ∀ i j, star (b i) * b j = if i = j then 1 else 0)
+    (hbs : (∑ i, b i * star (b i)) = 1) (u v : unitary E) :
+    ∃ K : unitary E,
+      (K : E) = star (binaryShrinkValue r (fun i => star (v : E) * b i) 1) *
+        binaryShrinkValue r (fun i => star (u : E) * b i) 1 ∧
+      K = binaryCornerUnitary (star (finiteCuntzTransfer r b 1))
+        (by simpa only [star_star] using
+          finiteCuntzTransfer_reference_coisometry r b hr hbs) (v * star u) := by
+  let A := finiteCuntzTransfer r b 1
+  have hAst : star A = finiteCuntzTransfer b r 1 := by
+    simpa only [A, star_one] using finiteCuntzTransfer_star r b 1
+  have hAA : A * star A = 1 := by
+    have hh := finiteCuntzTransfer_star_mul b r hr 1
+    rw [← hAst, star_star] at hh
+    simpa only [star_one, one_mul, mul_one, hbs] using hh
+  have hAp : star A * A = ∑ i, r i * star (r i) := by
+    simpa only [A, star_one, one_mul, mul_one] using finiteCuntzTransfer_star_mul r b hb 1
+  have hr1 : star (r 1) * r 1 = 1 := by simpa only [ite_true] using hr 1 1
+  have hpy : (star A * A) * r 1 = r 1 := by
+    rw [hAp]
+    simpa only [finiteRowPermutation, Equiv.Perm.one_apply] using
+      finiteRowPermutation_mul_row 1 r (by simp) (by simp) hr 1 1
+  let K := binaryCornerUnitary (star A) (by simpa only [star_star] using hAA) (v * star u)
+  refine ⟨K, ?_, rfl⟩
+  rw [binaryShrinkValue_reference, binaryShrinkValue_reference]
+  exact (coisometry_filler_cross A (r 1) hAA hr1 hpy u v).symm
+
+/-- The base product is connected because its two prescribed cocycles
+are connected. This is the concrete path, rather than an ambient K1 claim. -/
+lemma binaryShrinkValue_reference_cross_joined (r b : Fin 2 → E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (hb : ∀ i j, star (b i) * b j = if i = j then 1 else 0)
+    (hbs : (∑ i, b i * star (b i)) = 1)
+    (u v : unitary E) (hu : Joined (1 : unitary E) u) (hv : Joined (1 : unitary E) v) :
+    ∃ K : unitary E, Joined (1 : unitary E) K ∧
+      (K : E) = star (binaryShrinkValue r (fun i => star (v : E) * b i) 1) *
+        binaryShrinkValue r (fun i => star (u : E) * b i) 1 := by
+  obtain ⟨K, hK, hKe⟩ := binaryShrinkValue_reference_cross r b hr hb hbs u v
+  have hu' : Joined (1 : unitary E) (star u) := by
+    simpa only [star_one] using hu.map (continuous_star : Continuous (star : unitary E → unitary E))
+  have huv : Joined (1 : unitary E) (v * star u) := by
+    simpa only [one_mul] using hv.mul hu'
+  refine ⟨K, ?_, hK⟩
+  rw [hKe]
+  have hA : star (star (finiteCuntzTransfer r b 1)) * star (finiteCuntzTransfer r b 1) = 1 := by
+    simpa only [star_star] using finiteCuntzTransfer_reference_coisometry r b hr hbs
+  simpa only [binaryCornerUnitary_one] using
+    huv.map (binaryCornerUnitary_continuous (star (finiteCuntzTransfer r b 1)) hA)
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/RowCompletionBuffer.lean

@@ -0,0 +1,314 @@
+import OAI.Analysis.OInfinity.RowCompletionBase
+
+namespace OAI
+
+/-! # Completions in the first buffer commutant
+
+The relative path data records the fixed complement at every time. The
+second buffer is constructed by the explicit central-row theorem inside
+the norm ultrapower; its target family consists of elements of the first
+buffer commutant. No commuting-row existence is assumed.
+-/
+
+noncomputable section
+open Filter Topology
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+local instance rowCompletionCentralizerClosed (R : ℕ → E) :
+    IsClosed (StarSubalgebra.centralizer ℂ (Set.range R) : Set E) :=
+  Set.isClosed_centralizer _
+
+structure RelativeBinaryCompletion {n : ℕ} (q : E) (b : Fin 2 → E)
+    (x : Fin (n + 1) → E) where
+  row : Fin 2 → E
+  implementer : unitary E
+  deformation : Path (1 : unitary E) implementer
+  fixes_complement : ∀ t, (deformation t : E) * (1 - q) = 1 - q ∧
+    (1 - q) * (deformation t : E) = 1 - q
+  support : ∀ i, q * row i = row i ∧ row i * q = row i
+  gram : ∀ i j, star (row i) * row j = if i = j then q else 0
+  range_sum : (∑ i, row i * star (row i)) = q
+  encoded_prefix : ∀ i : Fin (n + 1), row 0 ^ (i : ℕ) * row 1 = x i
+  cocycle : ∀ j, (implementer : E) * row j = b j
+
+/-- A relative completion whose whole connecting path fixes the external
+complement, obtained by doing the three connected moves in the corner. -/
+lemma exists_relative_connected_binary_completion {n : ℕ}
+    (q : E) (hq : star q = q) (hqq : q * q = q) (hq0 : q ≠ 0)
+    (x : Fin (n + 2) → E)
+    (hxs : ∀ i, q * x i = x i ∧ x i * q = x i)
+    (hx : ∀ i j, star (x i) * x j = if i = j then q else 0)
+    (b : Fin 2 → E)
+    (hb : ∀ i j, star (b i) * b j = if i = j then q else 0)
+    (hbs : (∑ i, b i * star (b i)) = q)
+    (r : Fin 3 → E)
+    (hrs : ∀ i, q * r i = r i ∧ r i * q = r i)
+    (hr : ∀ i j, star (r i) * r j = if i = j then q else 0)
+    (her : Commute (star (r 0)) (x (Fin.last (n + 1))))
+    (hfr : Commute (star (r 1)) (b 0 * x (Fin.last (n + 1)))) :
+    Nonempty (RelativeBinaryCompletion q b (fun i : Fin (n + 1) => x i.castSucc)) := by
+  let : NeZero q := ⟨hq0⟩
+  let H := ProjectionCorner q hq hqq
+  let f := projectionCornerInclusion q hq hqq
+  have hf1 : f 1 = q := rfl
+  have hfa (a : H) : f a = (a : E) := rfl
+  have hbsup (i : Fin 2) : q * b i = b i ∧ b i * q = b i :=
+    ⟨finiteRow_left_support q b hq hqq hb hbs i,
+      finiteRow_right_support q b hq hqq hb i⟩
+  let X : Fin (n + 2) → H := fun i => projectionCornerElement q hq hqq (x i) (hxs i)
+  let B : Fin 2 → H := fun i => projectionCornerElement q hq hqq (b i) (hbsup i)
+  let R : Fin 3 → H := fun i => projectionCornerElement q hq hqq (r i) (hrs i)
+  have hX := projectionCornerElement_gram q hq hqq x hxs hx
+  have hB := projectionCornerElement_gram q hq hqq b hbsup hb
+  have hBs := projectionCornerElement_range_sum q hq hqq b hbsup hbs
+  have hR := projectionCornerElement_gram q hq hqq r hrs hr
+  have he : star (X (Fin.last (n + 1))) * X (Fin.last (n + 1)) = 1 := by
+    simpa only [ite_true] using hX (Fin.last (n + 1)) (Fin.last (n + 1))
+  have hxe (i : Fin (n + 1)) : star (X i.castSucc) * X (Fin.last (n + 1)) = 0 := by
+    have hne : i.castSucc ≠ Fin.last (n + 1) := by
+      intro h
+      have hh := congrArg Fin.val h
+      change (i : ℕ) = n + 1 at hh
+      omega
+    simpa only [hne, ite_false] using hX i.castSucc (Fin.last (n + 1))
+  obtain ⟨a, u, hu, hag, has, ha, huc⟩ := exists_connected_binary_row_completion
+    (fun i : Fin (n + 1) => X i.castSucc)
+    (fun i j => by simpa only [Fin.castSucc_inj] using hX i.castSucc j.castSucc)
+    (X (Fin.last (n + 1))) he hxe B hB hBs R hR
+    (show Commute (star (R 0)) (X (Fin.last (n + 1))) from Subtype.ext her.eq)
+    (show Commute (star (R 1)) (B 0 * X (Fin.last (n + 1))) from Subtype.ext hfr.eq)
+  let p := hu.somePath
+  let U := projectionCornerUnitary q hq hqq u
+  let P : Path (1 : unitary E) U :=
+    { toFun := fun t => projectionCornerUnitary q hq hqq (p t)
+      continuous_toFun := (projectionCornerUnitary_continuous q hq hqq).comp p.continuous
+      source' := by rw [p.source, projectionCornerUnitary_one]
+      target' := by rw [p.target] }
+  refine ⟨{
+    row := fun i => f (a i)
+    implementer := U
+    deformation := P
+    fixes_complement := fun t => projectionCornerUnitary_complement q hq hqq (p t)
+    support := fun i => (a i).property
+    gram := ?_
+    range_sum := ?_
+    encoded_prefix := ?_
+    cocycle := ?_ }⟩
+  · intro i j
+    have h := congrArg f (hag i j)
+    by_cases hij : i = j
+    · simpa only [hij, ite_true, map_mul, map_star, hf1] using h
+    · simpa only [hij, ite_false, map_mul, map_star, map_zero] using h
+  · have h := congrArg f has
+    simpa only [map_sum, map_mul, map_star, hf1] using h
+  · intro i
+    have h := congrArg f (ha i)
+    rw [nonunital_map_pow_mul] at h
+    exact h
+  · intro j
+    change ((((u : H) : E) + (1 - q)) * f (a j)) = b j
+    rw [add_mul, sub_mul, one_mul, hfa, (a j).property.1, sub_self, add_zero]
+    exact congrArg f (huc j)
+
+/-- Diagonalizing an element of the first row commutant preserves that
+membership in the next norm ultrapower. -/
+def rowCentralizerDiagonalHom (U : Ultrafilter ℕ) (R : ℕ → E) :
+    StarSubalgebra.centralizer ℂ (Set.range R) →⋆ₐ[ℂ]
+      StarSubalgebra.centralizer ℂ
+        (Set.range (fun i => NormUltra.QuotientAlgebra.diagonalHom U (R i))) := by
+  let C := StarSubalgebra.centralizer ℂ (Set.range R)
+  let D := StarSubalgebra.centralizer ℂ
+    (Set.range (fun i => NormUltra.QuotientAlgebra.diagonalHom U (R i)))
+  let d := NormUltra.QuotientAlgebra.diagonalHom (A := E) U
+  refine (d.comp C.subtype).codRestrict D ?_
+  intro x
+  apply (StarSubalgebra.mem_centralizer_iff ℂ).mpr
+  rintro _ ⟨i, rfl⟩
+  obtain ⟨h₁, h₂⟩ := (StarSubalgebra.mem_centralizer_iff ℂ).mp x.property (R i) ⟨i, rfl⟩
+  constructor
+  · change d (R i) * d (x : E) = d (x : E) * d (R i)
+    simpa only [map_mul] using congrArg d h₁
+  · change star (d (R i)) * d (x : E) = d (x : E) * star (d (R i))
+    simpa only [map_mul, map_star] using congrArg d h₂
+
+/-- The second proper row is actually built. Its entries remain in the
+first row's commutant and commute with every member of the chosen target
+family and its adjoint. -/
+lemma exists_normUltrapower_row_in_commutant [Nontrivial E]
+    (U : Ultrafilter ℕ) [Fact ((U : Filter ℕ) ≤ atTop)] (R : ℕ → E)
+    (hR : ∀ i j, star (R i) * R j = if i = j then 1 else 0)
+    (t : ℕ → StarSubalgebra.centralizer ℂ (Set.range R)) :
+    ∃ z : ℕ → StarSubalgebra.centralizer ℂ
+        (Set.range (fun i => NormUltra.QuotientAlgebra.diagonalHom U (R i))),
+      (∀ i j, star (z i) * z j = if i = j then 1 else 0) ∧
+      ∀ i j, Commute (z i) (rowCentralizerDiagonalHom U R (t j)) ∧
+        Commute (z i) (star (rowCentralizerDiagonalHom U R (t j))) := by
+  let T : ℕ → E := fun i => t i
+  have hRT : bergRowsCommute R T := by
+    intro i j
+    obtain ⟨h₁, h₂⟩ := (StarSubalgebra.mem_centralizer_iff ℂ).mp (t j).property (R i) ⟨i, rfl⟩
+    refine ⟨h₁, ?_⟩
+    change R i * star (t j : E) = star (t j : E) * R i
+    simpa only [star_mul, star_star] using (congrArg star h₂).symm
+  obtain ⟨Z, hZ, hZR, hZT⟩ := exists_normUltrapower_central_cuntz_row U R T hR hRT
+  have hmem (i : ℕ) : Z i ∈ StarSubalgebra.centralizer ℂ
+      (Set.range (fun j => NormUltra.QuotientAlgebra.diagonalHom U (R j))) := by
+    apply (StarSubalgebra.mem_centralizer_iff ℂ).mpr
+    rintro _ ⟨j, rfl⟩
+    exact ⟨(hZR i j).1.symm, (hZR i j).2.symm⟩
+  let z i := (⟨Z i, hmem i⟩ : StarSubalgebra.centralizer ℂ
+    (Set.range (fun j => NormUltra.QuotientAlgebra.diagonalHom U (R j))))
+  refine ⟨z, ?_, fun i j => ?_⟩
+  · intro i j
+    apply Subtype.ext
+    change star (Z i) * Z j = ↑(if i = j then (1 : StarSubalgebra.centralizer ℂ
+      (Set.range (fun j => NormUltra.QuotientAlgebra.diagonalHom U (R j)))) else 0)
+    split_ifs with hij
+    · change star (Z i) * Z j = 1
+      simpa only [hij, ite_true] using hZ i j
+    · change star (Z i) * Z j = 0
+      simpa only [hij, ite_false] using hZ i j
+  · constructor
+    · exact Subtype.ext (hZT i j).1.eq
+    · exact Subtype.ext (hZT i j).2.eq
+
+private lemma rowCentralizerDiagonal_norm (U : Ultrafilter ℕ) (R : ℕ → E)
+    (x : StarSubalgebra.centralizer ℂ (Set.range R)) :
+    ‖rowCentralizerDiagonalHom U R x‖ = ‖x‖ := by
+  change ‖NormUltra.QuotientAlgebra.mk U (DirectComparison.boundedDiagonal (x : E))‖ = ‖(x : E)‖
+  rw [NormUltra.QuotientAlgebra.norm_mk_eq_limsup]
+  change Filter.limsup (fun _ : ℕ => ‖(x : E)‖) (U : Filter ℕ) = ‖(x : E)‖
+  rw [Filter.limsup_const]
+
+/-- The same reference completion is available for both proper finite
+rows after the second, explicitly constructed buffer. All resulting data
+belong to the first buffer commutant. -/
+lemma exists_buffer_preserving_pair_completions [Nontrivial E]
+    (U : Ultrafilter ℕ) [Fact ((U : Filter ℕ) ≤ atTop)]
+    (R : ℕ → E) (hR : ∀ i j, star (R i) * R j = if i = j then 1 else 0)
+    (q : StarSubalgebra.centralizer ℂ (Set.range R))
+    (hq : star q = q) (hqq : q * q = q) (hq0 : q ≠ 0)
+    (n : ℕ) (x y : Fin (n + 2) → StarSubalgebra.centralizer ℂ (Set.range R))
+    (hxs : ∀ i, q * x i = x i ∧ x i * q = x i)
+    (hys : ∀ i, q * y i = y i ∧ y i * q = y i)
+    (hx : ∀ i j, star (x i) * x j = if i = j then q else 0)
+    (hy : ∀ i j, star (y i) * y j = if i = j then q else 0)
+    (b : Fin 2 → StarSubalgebra.centralizer ℂ (Set.range R))
+    (hb : ∀ i j, star (b i) * b j = if i = j then q else 0)
+    (hbs : (∑ i, b i * star (b i)) = q) :
+    let θ := rowCentralizerDiagonalHom U R
+    Nonempty (RelativeBinaryCompletion (θ q) (fun j => θ (b j))
+      (fun i : Fin (n + 1) => θ (x i.castSucc))) ∧
+    Nonempty (RelativeBinaryCompletion (θ q) (fun j => θ (b j))
+      (fun i : Fin (n + 1) => θ (y i.castSucc))) := by
+  intro θ
+  let C := StarSubalgebra.centralizer ℂ (Set.range R)
+  let D := StarSubalgebra.centralizer ℂ
+    (Set.range (fun i => NormUltra.QuotientAlgebra.diagonalHom U (R i)))
+  let ex := x (Fin.last (n + 1))
+  let ey := y (Fin.last (n + 1))
+  let t : ℕ → C := fun i => if i = 0 then q else if i = 1 then ex else
+    if i = 2 then b 0 * ex else if i = 3 then ey else b 0 * ey
+  obtain ⟨z, hz, hzt⟩ := exists_normUltrapower_row_in_commutant U R hR t
+  have hzq (j : ℕ) : Commute (z j) (θ q) := by
+    simpa only [t, ite_true] using (hzt j 0).1
+  have hzex (j : ℕ) : Commute (star (z j)) (θ ex) := by
+    have h := (hzt j 1).2.star_star
+    simpa only [t, show (1 : ℕ) ≠ 0 by decide, ite_false, ite_true, star_star] using h
+  have hzfx (j : ℕ) : Commute (star (z j)) (θ (b 0 * ex)) := by
+    have h := (hzt j 2).2.star_star
+    simpa only [t, show (2 : ℕ) ≠ 0 by decide, show (2 : ℕ) ≠ 1 by decide,
+      ite_false, ite_true, star_star] using h
+  have hzey (j : ℕ) : Commute (star (z j)) (θ ey) := by
+    have h := (hzt j 3).2.star_star
+    simpa only [t, show (3 : ℕ) ≠ 0 by decide, show (3 : ℕ) ≠ 1 by decide,
+      show (3 : ℕ) ≠ 2 by decide, ite_false, ite_true, star_star] using h
+  have hzfy (j : ℕ) : Commute (star (z j)) (θ (b 0 * ey)) := by
+    have h := (hzt j 4).2.star_star
+    simpa only [t, show (4 : ℕ) ≠ 0 by decide, show (4 : ℕ) ≠ 1 by decide,
+      show (4 : ℕ) ≠ 2 by decide, show (4 : ℕ) ≠ 3 by decide, ite_false, star_star] using h
+  have hqD : star (θ q) = θ q := by rw [← map_star, hq]
+  have hqqD : θ q * θ q = θ q := by rw [← map_mul, hqq]
+  have hqD0 : θ q ≠ 0 := by
+    intro hzero
+    have hn := rowCentralizerDiagonal_norm U R q
+    change ‖θ q‖ = ‖q‖ at hn
+    rw [hzero, norm_zero] at hn
+    exact hq0 (norm_eq_zero.mp hn.symm)
+  have map_support (a : Fin (n + 2) → C) (hs : ∀ i, q * a i = a i ∧ a i * q = a i) :
+      ∀ i, θ q * θ (a i) = θ (a i) ∧ θ (a i) * θ q = θ (a i) := by
+    intro i
+    constructor
+    · simpa only [map_mul] using congrArg θ (hs i).1
+    · simpa only [map_mul] using congrArg θ (hs i).2
+  have map_gram {I : Type} [DecidableEq I] (a : I → C)
+      (h : ∀ i j, star (a i) * a j = if i = j then q else 0) :
+      ∀ i j, star (θ (a i)) * θ (a j) = if i = j then θ q else 0 := by
+    intro i j
+    rw [← map_star, ← map_mul, h]
+    split_ifs <;> simp only [map_zero]
+  have hbsD : (∑ i, θ (b i) * star (θ (b i))) = θ q := by
+    simpa only [map_sum, map_mul, map_star] using congrArg θ hbs
+  let r : Fin 3 → D := fun i => z i * θ q
+  have hrs (i : Fin 3) : θ q * r i = r i ∧ r i * θ q = r i := by
+    constructor
+    · change θ q * (z i * θ q) = z i * θ q
+      rw [← mul_assoc, ← (hzq i).eq, mul_assoc, hqqD]
+    · change (z i * θ q) * θ q = z i * θ q
+      rw [mul_assoc, hqqD]
+  have hrg (i j : Fin 3) : star (r i) * r j = if i = j then θ q else 0 := by
+    change star (z i * θ q) * (z j * θ q) = _
+    rw [star_mul, hqD]
+    calc
+      _ = θ q * (star (z i) * z j) * θ q := by noncomm_ring
+      _ = _ := by
+        rw [hz]
+        by_cases hij : i = j
+        · simpa only [hij, ite_true, mul_one] using hqqD
+        · have hne : (i : ℕ) ≠ (j : ℕ) := fun h => hij (Fin.ext h)
+          simp only [hne, hij, ite_false, mul_zero, zero_mul]
+  have q_commutes (a : C) (ha : q * a = a ∧ a * q = a) : Commute (θ q) (θ a) := by
+    change θ q * θ a = θ a * θ q
+    rw [← map_mul, ← map_mul, ha.1, ha.2]
+  have q_bex : q * (b 0 * ex) = b 0 * ex ∧ (b 0 * ex) * q = b 0 * ex := by
+    constructor
+    · rw [← mul_assoc, finiteRow_left_support q b hq hqq hb hbs 0]
+    · rw [mul_assoc, (hxs (Fin.last (n + 1))).2]
+  have q_bey : q * (b 0 * ey) = b 0 * ey ∧ (b 0 * ey) * q = b 0 * ey := by
+    constructor
+    · rw [← mul_assoc, finiteRow_left_support q b hq hqq hb hbs 0]
+    · rw [mul_assoc, (hys (Fin.last (n + 1))).2]
+  have hrex : Commute (star (r 0)) (θ ex) := by
+    change Commute (star (z 0 * θ q)) (θ ex)
+    rw [star_mul, hqD]
+    exact (q_commutes ex (hxs _)).mul_left (hzex 0)
+  have hrfx : Commute (star (r 1)) (θ (b 0) * θ ex) := by
+    rw [← map_mul]
+    change Commute (star (z 1 * θ q)) (θ (b 0 * ex))
+    rw [star_mul, hqD]
+    exact (q_commutes (b 0 * ex) q_bex).mul_left (hzfx 1)
+  have hrey : Commute (star (r 0)) (θ ey) := by
+    change Commute (star (z 0 * θ q)) (θ ey)
+    rw [star_mul, hqD]
+    exact (q_commutes ey (hys _)).mul_left (hzey 0)
+  have hrfy : Commute (star (r 1)) (θ (b 0) * θ ey) := by
+    rw [← map_mul]
+    change Commute (star (z 1 * θ q)) (θ (b 0 * ey))
+    rw [star_mul, hqD]
+    exact (q_commutes (b 0 * ey) q_bey).mul_left (hzfy 1)
+  exact ⟨exists_relative_connected_binary_completion (θ q) hqD hqqD hqD0
+      (fun i => θ (x i)) (map_support x hxs) (map_gram (I := Fin (n + 2)) x hx)
+      (fun j => θ (b j)) (map_gram (I := Fin 2) b hb) hbsD r hrs hrg hrex hrfx,
+    exists_relative_connected_binary_completion (θ q) hqD hqqD hqD0
+      (fun i => θ (y i)) (map_support y hys) (map_gram (I := Fin (n + 2)) y hy)
+      (fun j => θ (b j)) (map_gram (I := Fin 2) b hb) hbsD r hrs hrg hrey hrfy⟩
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/ShrinkPaths.lean

@@ -0,0 +1,174 @@
+import OAI.Analysis.OInfinity.MixedComplement
+
+namespace OAI
+
+/-! # Paths of the actual inserted-unitary shrinks
+
+The inverse canonical-shift implementer can be chosen in the identity
+component. Varying that implementer to one preserves both support
+projections of the shrink. This supplies a path to the literal base
+formula; the base fixed-complement extension is not asserted connected.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+/-- Retain the connectedness supplied by the canonical-shift construction
+when passing to inverse conjugation and a finite encoded prefix. -/
+lemma exists_connected_canonicalShift_prefix_inverse [Nontrivial E]
+    (a : Fin 2 → E)
+    (ha : ∀ i j, star (a i) * a j = if i = j then 1 else 0)
+    (has : (∑ i, a i * star (a i)) = 1) (m : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ u : unitary E, Joined 1 u ∧ ∀ i ≤ m,
+      ‖(u : E) * finiteRowShift a (a 0 ^ i * a 1) * star (u : E) -
+        (a 0 ^ i * a 1)‖ < ε := by
+  let δ := ε / ((m : ℝ) + 2)
+  have hδ : 0 < δ := by dsimp only [δ]; positivity
+  obtain ⟨u, hu, huclose⟩ := exists_connected_canonicalShift_conjugacy a ha has δ hδ
+  let φ := finiteCuntzDiagonalHom a ha
+  have han (j : Fin 2) : ‖a j‖ ≤ 1 := by
+    have h := congrArg norm (show star (a j) * a j = 1 by simpa only [ite_true] using ha j j)
+    rw [CStarRing.norm_star_mul_self, norm_one] at h
+    nlinarith [norm_nonneg (a j)]
+  have hun (j : Fin 2) : ‖(u : E) * a j * star (u : E)‖ ≤ 1 := by
+    rw [mul_assoc, CStarRing.norm_coe_unitary_mul]
+    change ‖a j * (star u : unitary E)‖ ≤ 1
+    rw [CStarRing.norm_mul_coe_unitary]
+    exact han j
+  have hφn (j : Fin 2) : ‖φ (a j)‖ ≤ 1 :=
+    (NonUnitalStarAlgHom.norm_apply_le φ _).trans (han j)
+  have hclose (i : ℕ) (hi : i ≤ m) :
+      ‖(u : E) * (a 0 ^ i * a 1) * star (u : E) - φ (a 0 ^ i * a 1)‖ < ε := by
+    let j : Fin (m + 1) := ⟨i, by omega⟩
+    have hp := zeroCornerRow_perturbation 1
+      ((u : E) * a 0 * star (u : E)) ((u : E) * a 1 * star (u : E))
+      (φ (a 0)) (φ (a 1)) δ hδ.le (by simp) (hun 0) (hun 1) (hφn 0)
+      (huclose 0).le (huclose 1).le (m + 1) j.castSucc
+    rw [← zeroCornerRow_conjugate] at hp
+    simp only [zeroCornerRow_castSucc] at hp
+    rw [← nonunital_map_pow_mul] at hp
+    apply hp.trans_lt
+    have he : ((m : ℝ) + 2) * δ = ε := by dsimp only [δ]; field_simp
+    push_cast
+    nlinarith
+  refine ⟨star u, ?_, fun i hi => ?_⟩
+  · simpa only [star_one] using hu.map (continuous_star : Continuous (star : unitary E → unitary E))
+  · let x := a 0 ^ i * a 1
+    have hid : (star (u : E)) * φ x * (u : E) - x =
+        star (u : E) * (φ x - (u : E) * x * star (u : E)) * (u : E) := by
+      rw [mul_sub, sub_mul]
+      have hcan : star (u : E) * ((u : E) * x * star (u : E)) * (u : E) = x := by
+        calc
+          _ = (star (u : E) * (u : E)) * x * (star (u : E) * (u : E)) := by noncomm_ring
+          _ = x := by rw [u.property.1, one_mul, mul_one]
+      rw [hcan]
+    change ‖star (u : E) * φ x * star (star (u : E)) - x‖ < ε
+    rw [star_star, hid, CStarRing.norm_mul_coe_unitary]
+    change ‖(star u : unitary E) * (φ x - (u : E) * x * star (u : E))‖ < ε
+    rw [CStarRing.norm_coe_unitary_mul, norm_sub_rev]
+    exact hclose i hi
+
+def binaryShrinkValue (r a : Fin 2 → E) (u : unitary E) : E :=
+  let v := (u : E) * finiteCuntzTransfer r a 1
+  1 - star v * v + r 1 * v
+
+lemma binaryShrinkValue_continuous (r a : Fin 2 → E) : Continuous (binaryShrinkValue r a) := by
+  unfold binaryShrinkValue
+  fun_prop
+
+lemma binaryShrinkValue_one (r a : Fin 2 → E) :
+    binaryShrinkValue r a 1 = 1 - star (finiteCuntzTransfer r a 1) *
+      finiteCuntzTransfer r a 1 + r 1 * finiteCuntzTransfer r a 1 := by
+  simp only [binaryShrinkValue, OneMemClass.coe_one, one_mul]
+
+/-- The actual shrink follows a continuous path with constant initial and
+final projections from its explicit base formula to the required estimate. -/
+lemma exists_binary_shrink_path [Nontrivial E]
+    (r a : Fin 2 → E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (ha : ∀ i j, star (a i) * a j = if i = j then 1 else 0)
+    (has : (∑ i, a i * star (a i)) = 1)
+    (hc : bergRowsCommute a r) (m : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ C : unitInterval → E, Continuous C ∧
+      C 0 = binaryShrinkValue r a 1 ∧
+      (∀ t, star (C t) * C t = 1 ∧ C t * star (C t) = 1 - r 0 * star (r 0)) ∧
+      ∀ i ≤ m, ‖C 1 * (a 0 ^ i * a 1) * star (C 1) -
+        (a 0 ^ i * a 1) * (1 - r 0 * star (r 0))‖ < ε := by
+  obtain ⟨u, hu, he⟩ := exists_connected_canonicalShift_prefix_inverse a ha has m ε hε
+  let p : Path (1 : unitary E) u := hu.somePath
+  let C : unitInterval → E := fun t => binaryShrinkValue r a (p t)
+  refine ⟨C, (binaryShrinkValue_continuous r a).comp p.continuous, ?_, ?_, ?_⟩
+  · change binaryShrinkValue r a (p 0) = _
+    rw [p.source]
+  · intro t
+    exact binary_shift_shrink_products r a hr ha has (p t)
+  · intro i hi
+    have hx (j : Fin 2) : Commute (a 0 ^ i * a 1) (r j) ∧
+        Commute (a 0 ^ i * a 1) (star (r j)) :=
+      ⟨((hc 0 j).1.pow_left i).mul_left (hc 1 j).1,
+        ((hc 0 j).2.pow_left i).mul_left (hc 1 j).2⟩
+    change ‖binaryShrinkValue r a (p 1) * _ * star (binaryShrinkValue r a (p 1)) - _‖ < ε
+    rw [p.target]
+    exact (binary_shift_shrink_error r a hr ha has u _ hx).trans_lt (he i hi)
+
+/-- The same actual deformation inside a projection corner, including both
+support equations at every time. -/
+lemma exists_relative_binary_shrink_path
+    (q : E) (hq : star q = q) (hqq : q * q = q) (hq0 : q ≠ 0)
+    (r a : Fin 2 → E)
+    (hrs : ∀ i, q * r i = r i ∧ r i * q = r i)
+    (hasp : ∀ i, q * a i = a i ∧ a i * q = a i)
+    (hr : ∀ i j, star (r i) * r j = if i = j then q else 0)
+    (ha : ∀ i j, star (a i) * a j = if i = j then q else 0)
+    (has : (∑ i, a i * star (a i)) = q)
+    (hc : bergRowsCommute a r) (m : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ C : unitInterval → E, Continuous C ∧
+      C 0 = q - star (finiteCuntzTransfer r a q) * finiteCuntzTransfer r a q +
+        r 1 * finiteCuntzTransfer r a q ∧
+      (∀ t, q * C t = C t ∧ C t * q = C t ∧ star (C t) * C t = q ∧
+        C t * star (C t) = q - r 0 * star (r 0)) ∧
+      ∀ i ≤ m, ‖C 1 * (a 0 ^ i * a 1) * star (C 1) -
+        (a 0 ^ i * a 1) * (q - r 0 * star (r 0))‖ < ε := by
+  let : NeZero q := ⟨hq0⟩
+  let H := ProjectionCorner q hq hqq
+  let R : Fin 2 → H := fun i => projectionCornerElement q hq hqq (r i) (hrs i)
+  let A : Fin 2 → H := fun i => projectionCornerElement q hq hqq (a i) (hasp i)
+  have hR := projectionCornerElement_gram q hq hqq r hrs hr
+  have hA := projectionCornerElement_gram q hq hqq a hasp ha
+  have hAs := projectionCornerElement_range_sum q hq hqq a hasp has
+  have hAR : bergRowsCommute A R := by
+    intro i j
+    exact ⟨Subtype.ext (hc i j).1.eq, Subtype.ext (hc i j).2.eq⟩
+  obtain ⟨C, hC, hC0, hgram, he⟩ := exists_binary_shrink_path R A hR hA hAs hAR m ε hε
+  let f := projectionCornerInclusion q hq hqq
+  have hf1 : f 1 = q := rfl
+  have hfR (i : Fin 2) : f (R i) = r i := rfl
+  have htransfer : f (finiteCuntzTransfer R A 1) = finiteCuntzTransfer r a q := by
+    simp only [finiteCuntzTransfer, map_sum, map_mul, map_star]
+    rfl
+  have hfc : Continuous (fun x : H => f x) := continuous_subtype_val
+  refine ⟨fun t => f (C t), hfc.comp hC, ?_, ?_, fun i hi => ?_⟩
+  · change f (C 0) = _
+    rw [hC0, binaryShrinkValue_one, map_add, map_sub, map_mul, map_star, map_mul,
+      hf1, htransfer]
+    rfl
+  · intro t
+    exact ⟨(C t).property.1, (C t).property.2,
+      congrArg f (hgram t).1, congrArg f (hgram t).2⟩
+  · have hpow : f (A 0 ^ i * A 1) = a 0 ^ i * a 1 := by
+      rw [nonunital_map_pow_mul]
+      rfl
+    have hh := he i hi
+    change ‖f (C 1 * (A 0 ^ i * A 1) * star (C 1) -
+      (A 0 ^ i * A 1) * (1 - R 0 * star (R 0)))‖ < ε at hh
+    simpa only [map_sub, map_mul, map_star, hpow, hf1, hfR] using hh
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/Simple.lean

@@ -0,0 +1,192 @@
+import OAI.Analysis.OInfinity.TensorApproximation
+import OAI.Analysis.OInfinity.VacuumCorner
+
+namespace OAI
+
+/-! # Simplicity of O∞ from finite vacuum corners
+
+A nonzero Fock coefficient becomes a nonzero vacuum coefficient after a word
+sandwich.  Compressing a polynomial by an unused generator gives exactly that
+vacuum coefficient times the unit.  Polynomial approximation therefore puts an
+invertible element in every nonzero two-sided ideal.
+-/
+
+noncomputable section
+open scoped CStarAlgebra InnerProductSpace
+open Filter Topology
+
+namespace WeakPureInfiniteness
+
+local instance : SMulWithZero ℂ OInfinity :=
+  @MulActionWithZero.toSMulWithZero ℂ OInfinity _ _
+    (@Module.toMulActionWithZero ℂ OInfinity _ _ inferInstance)
+local instance : DistribSMul ℂ OInfinity :=
+  @DistribMulAction.toDistribSMul ℂ OInfinity _ _
+    (@Module.toDistribMulAction ℂ OInfinity _ _ inferInstance)
+
+private lemma norm_complex_smul_one {A : Type*} [CStarAlgebra A] [Nontrivial A]
+    (c : ℂ) : ‖c • (1 : A)‖ = ‖c‖ := by
+  rw [norm_smul, norm_one, mul_one]
+
+private lemma norm_contraction_sandwich {A : Type*} [NonUnitalCStarAlgebra A]
+    (s a : A) (hs : ‖s‖ ≤ 1) : ‖star s * a * s‖ ≤ ‖a‖ := by
+  have hleft : ‖star s * a‖ ≤ ‖s‖ * ‖a‖ := by
+    simpa only [norm_star] using norm_mul_le (star s) a
+  calc
+    _ ≤ (‖s‖ * ‖a‖) * ‖s‖ :=
+      (norm_mul_le _ _).trans (mul_le_mul_of_nonneg_right hleft (norm_nonneg _))
+    _ ≤ (1 * ‖a‖) * 1 := mul_le_mul
+      (mul_le_mul_of_nonneg_right hs (norm_nonneg _)) hs
+      (norm_nonneg _) (by positivity)
+    _ = ‖a‖ := by rw [one_mul, mul_one]
+
+def fockVacuumCoefficient (a : OInfinity) : ℂ :=
+  inner ℂ fockVacuum (fockOperatorRepresentation a fockVacuum)
+
+lemma fockVacuumCoefficient_sub (a b : OInfinity) :
+    fockVacuumCoefficient (a - b) = fockVacuumCoefficient a - fockVacuumCoefficient b := by
+  simp only [fockVacuumCoefficient, map_sub, sub_apply, inner_sub_right]
+
+lemma fockVacuumCoefficient_norm_le (a : OInfinity) : ‖fockVacuumCoefficient a‖ ≤ ‖a‖ := by
+  calc
+    _ ≤ ‖fockVacuum‖ * ‖fockOperatorRepresentation a fockVacuum‖ := norm_inner_le_norm _ _
+    _ ≤ ‖fockVacuum‖ * (‖fockOperatorRepresentation a‖ * ‖fockVacuum‖) :=
+      mul_le_mul_of_nonneg_left ((fockOperatorRepresentation a).le_opNorm _) (norm_nonneg _)
+    _ ≤ ‖fockVacuum‖ * (‖a‖ * ‖fockVacuum‖) := by
+      gcongr
+      exact NonUnitalStarAlgHom.norm_apply_le fockOperatorRepresentation.toNonUnitalStarAlgHom a
+    _ = ‖a‖ := by rw [fockVacuum_norm, one_mul, mul_one]
+
+lemma finiteFockAlgebraWord_fock {N m : ℕ} (i : FiniteFockIndex N m) :
+    fockOperatorRepresentation (finiteFockAlgebraWord i) fockVacuum = finiteFockVector i :=
+  oInfinityPositiveWord_fock N i.1.val i.2
+
+lemma fockVacuumCoefficient_word_sandwich {N m : ℕ} (a : OInfinity)
+    (i j : FiniteFockIndex N m) :
+    fockVacuumCoefficient (star (finiteFockAlgebraWord i) * a * finiteFockAlgebraWord j) =
+      oInfinityFockCompression N m a i j := by
+  unfold fockVacuumCoefficient
+  rw [map_mul, map_mul, map_star]
+  change inner ℂ fockVacuum
+    ((fockOperatorRepresentation (finiteFockAlgebraWord i)).adjoint
+      (fockOperatorRepresentation a
+        (fockOperatorRepresentation (finiteFockAlgebraWord j) fockVacuum))) = _
+  rw [ContinuousLinearMap.adjoint_inner_right, finiteFockAlgebraWord_fock,
+    finiteFockAlgebraWord_fock, oInfinityFockCompression_apply]
+
+lemma exists_fock_coefficient_ne_zero {a : OInfinity} (ha : a ≠ 0) :
+    ∃ n : ℕ, ∃ i j : FiniteFockIndex n (n + 1),
+      oInfinityFockCompression n (n + 1) a i j ≠ 0 := by
+  by_contra! h
+  have hc (n : ℕ) : oInfinityFockCompression n (n + 1) a = 0 := by
+    ext i j
+    exact h n i j
+  have happ (n : ℕ) : oInfinityApproximationSequence n a = 0 := by
+    change oInfinityFockReturn n (n + 1) (oInfinityFockCompression n (n + 1) a) = 0
+    rw [hc, map_zero]
+  have ht := tendsto_iff_norm_sub_tendsto_zero.mp (oInfinityApproximationSequence_tendsto a)
+  simp only [happ, zero_sub, norm_neg] at ht
+  have hn : ‖a‖ = 0 := tendsto_nhds_unique tendsto_const_nhds ht
+  exact ha (norm_eq_zero.mp hn)
+
+lemma unusedGenerator_polynomial (c : List (ℕ × Bool) →₀ ℂ) {N : ℕ}
+    (hc : ∀ w ∈ c.support, ∀ p ∈ w, p.1 < N) :
+    star (oInfinityIsometry N) * cuntzPolynomial oInfinityIsometry c * oInfinityIsometry N =
+      fockVacuumCoefficient (cuntzPolynomial oInfinityIsometry c) • 1 := by
+  let i : FiniteFockIndex N 0 := ⟨0, fun j => Fin.elim0 j⟩
+  have hw : finiteVacuumCorner N 0 i = oInfinityIsometry N := by
+    change oInfinityPositiveWord N (fun j : Fin 0 => Fin.elim0 j) * oInfinityIsometry N = _
+    rw [oInfinityPositiveWord_zero, one_mul]
+  have hv : finiteFockVector i = fockVacuum := rfl
+  have h := finiteVacuumCorner_polynomial c hc i i
+  rw [hw, oInfinityFockCompression_apply, hv] at h
+  exact h
+
+lemma oInfinityIsometry_norm_le_one (N : ℕ) : ‖oInfinityIsometry N‖ ≤ 1 := by
+  have h := congrArg norm (oInfinityIsometry_relations N N)
+  simp only [ite_true, CStarRing.norm_star_mul_self] at h
+  nlinarith [norm_nonneg (oInfinityIsometry N), cstar_norm_one_le_one (A := OInfinity)]
+
+lemma unusedGenerator_error (a : OInfinity) (c : List (ℕ × Bool) →₀ ℂ) {N : ℕ}
+    (hc : ∀ w ∈ c.support, ∀ p ∈ w, p.1 < N) :
+    ‖star (oInfinityIsometry N) * a * oInfinityIsometry N - fockVacuumCoefficient a • 1‖ ≤
+      2 * ‖a - cuntzPolynomial oInfinityIsometry c‖ := by
+  let p := cuntzPolynomial oInfinityIsometry c
+  let s := oInfinityIsometry N
+  have hs : ‖s‖ ≤ 1 := oInfinityIsometry_norm_le_one N
+  have he : star s * a * s - fockVacuumCoefficient a • 1 =
+      star s * (a - p) * s + (fockVacuumCoefficient p - fockVacuumCoefficient a) • 1 := by
+    dsimp [s, p]
+    rw [mul_sub, sub_mul, unusedGenerator_polynomial c hc, sub_smul]
+    abel
+  have hfirst : ‖star s * (a - p) * s‖ ≤ ‖a - p‖ :=
+    norm_contraction_sandwich s (a - p) hs
+  have hsecond : ‖(fockVacuumCoefficient p - fockVacuumCoefficient a) • (1 : OInfinity)‖ ≤
+      ‖a - p‖ := by
+    calc
+      _ = ‖fockVacuumCoefficient p - fockVacuumCoefficient a‖ := norm_complex_smul_one _
+      _ = ‖fockVacuumCoefficient (p - a)‖ :=
+        congrArg norm (fockVacuumCoefficient_sub p a).symm
+      _ ≤ ‖p - a‖ := fockVacuumCoefficient_norm_le _
+      _ = ‖a - p‖ := norm_sub_rev _ _
+  exact (congrArg norm he).trans_le
+    ((norm_add_le _ _).trans ((add_le_add hfirst hsecond).trans_eq (by ring)))
+
+lemma twoSidedIdeal_eq_top_of_vacuumCoefficient_ne_zero (I : TwoSidedIdeal OInfinity)
+    {a : OInfinity} (ha : a ∈ I) (hv : fockVacuumCoefficient a ≠ 0) : I = ⊤ := by
+  let coeff := fockVacuumCoefficient a
+  have hcoeff : 0 < ‖coeff‖ := norm_pos_iff.mpr hv
+  obtain ⟨c, hc⟩ := Metric.denseRange_iff.mp oInfinityPolynomial_denseRange a
+    (‖coeff‖ / 4) (by positivity)
+  have hac : ‖a - cuntzPolynomial oInfinityIsometry c‖ < ‖coeff‖ / 4 := by
+    simpa only [dist_eq_norm, norm_sub_rev] using hc
+  obtain ⟨N, hN⟩ := exists_polynomial_alphabet_bound c
+  let z := star (oInfinityIsometry N) * a * oInfinityIsometry N
+  have hz : z ∈ I := I.mul_mem_right _ _ (I.mul_mem_left _ _ ha)
+  have he : ‖z - coeff • 1‖ < ‖coeff‖ := by
+    exact (unusedGenerator_error a c hN).trans_lt (by dsimp [coeff] at *; linarith)
+  let y := coeff⁻¹ • z
+  have hy : y ∈ I := by
+    change coeff⁻¹ • z ∈ I
+    rw [Algebra.smul_def]
+    exact I.mul_mem_left _ _ hz
+  have hsmall : ‖1 - y‖ < 1 := by
+    have hid : (1 : OInfinity) - y = coeff⁻¹ • (coeff • 1 - z) := by
+      dsimp [y]
+      rw [smul_sub, smul_smul, inv_mul_cancel₀ hv, one_smul]
+    rw [hid, norm_smul, norm_inv, norm_sub_rev]
+    exact (inv_mul_lt_one₀ hcoeff).mpr he
+  have hu : IsUnit y := by
+    simpa only [Units.val_oneSub, sub_sub_cancel] using (Units.oneSub (1 - y) hsmall).isUnit
+  obtain ⟨u, hu⟩ := hu
+  have hone := I.mul_mem_left (↑u⁻¹) y hy
+  rw [← hu, Units.inv_mul] at hone
+  exact I.eq_top hone
+
+/-- Every nonzero two-sided ideal of O∞ contains a unit. -/
+theorem oInfinity_twoSidedIdeal_trivial (I : TwoSidedIdeal OInfinity) : I = ⊥ ∨ I = ⊤ := by
+  by_cases hI : I = ⊥
+  · exact Or.inl hI
+  right
+  have hex : ∃ a : OInfinity, a ∈ I ∧ a ≠ 0 := by
+    by_contra! h
+    apply hI
+    ext a
+    change (a ∈ I ↔ a = 0)
+    exact ⟨h a, fun he => by subst a; exact I.zero_mem⟩
+  obtain ⟨a, ha, ha0⟩ := hex
+  obtain ⟨n, i, j, hij⟩ := exists_fock_coefficient_ne_zero ha0
+  let b := star (finiteFockAlgebraWord i) * a * finiteFockAlgebraWord j
+  have hb : b ∈ I := I.mul_mem_right _ _ (I.mul_mem_left _ _ ha)
+  apply twoSidedIdeal_eq_top_of_vacuumCoefficient_ne_zero I hb
+  simpa only [b, fockVacuumCoefficient_word_sandwich] using hij
+
+theorem oInfinity_topologicallySimple : Pureness.TopologicallySimple OInfinity := by
+  intro I _
+  exact oInfinity_twoSidedIdeal_trivial I
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/TailCancellationWitness.lean

@@ -0,0 +1,240 @@
+import OAI.Analysis.OInfinity.BufferedRelativeWitness
+import OAI.Analysis.OInfinity.CanonicalBufferAbsorption
+import OAI.Analysis.PureInfiniteness.TailCancellationRows
+
+namespace OAI
+
+/-! # The zero corner containing the entire remaining source copy
+
+The internal isometry `z` has range inside the absorption corner. Its
+complement contains both the full residual source copy and a negative
+part of the target copy. All data below are constructed in the first
+buffer's commutant before applying the second-buffer comparison.
+-/
+
+noncomputable section
+open Filter Topology
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+def BufferAbsorptionCorner.map {F : Type*} [CStarAlgebra F]
+    (D : BufferAbsorptionCorner E) (φ : E →⋆ₐ[ℂ] F) : BufferAbsorptionCorner F where
+  q := φ D.q
+  w := φ D.w
+  a := φ D.a
+  b := φ D.b
+  projection := D.projection.map φ
+  w_gram := by simpa only [map_mul, map_star, map_one] using congrArg φ D.w_gram
+  w_range := by simpa only [map_mul, map_star, map_sub, map_one] using congrArg φ D.w_range
+  w_orthogonal := by simpa only [map_mul, map_zero] using congrArg φ D.w_orthogonal
+  a_gram := by simpa only [map_mul, map_star] using congrArg φ D.a_gram
+  b_gram := by simpa only [map_mul, map_star] using congrArg φ D.b_gram
+  orthogonal := by simpa only [map_mul, map_star, map_zero] using congrArg φ D.orthogonal
+  ranges := by simpa only [map_add, map_mul, map_star] using congrArg φ D.ranges
+
+local instance tailWitnessCentralizerClosed (R : ℕ → E) :
+    IsClosed (StarSubalgebra.centralizer ℂ (Set.range R) : Set E) :=
+  Set.isClosed_centralizer _
+
+/-- The new comparison corner is genuinely a zero corner: its full
+binary row comes from the internal isometry and two orthogonal copies
+inside the original residual range. -/
+lemma exists_tail_cancellation_reference [Nontrivial E]
+    (D : BufferAbsorptionCorner E) (s : ℕ → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (z : E) (hz : star z * z = 1) (hqz : D.q * z = z) :
+    (1 - z * star z) ≠ 0 ∧ ∃ b : Fin 2 → E,
+      (∀ i j, star (b i) * b j = if i = j then 1 - z * star z else 0) ∧
+      (∑ i, b i * star (b i)) = 1 - z * star z := by
+  let r : Fin 3 → E := ![z, D.w * s 0, D.w * s 1]
+  have hzw : star z * D.w = 0 := by
+    have hsq : star z * D.q = star z := by
+      simpa only [star_mul, D.projection.isSelfAdjoint.star_eq] using congrArg star hqz
+    calc
+      _ = (star z * D.q) * D.w := by rw [hsq]
+      _ = 0 := by rw [mul_assoc, D.w_orthogonal, mul_zero]
+  have hwz : star D.w * z = 0 := by
+    simpa only [star_mul, star_star, star_zero] using congrArg star hzw
+  have hsg (i j : ℕ) : star (D.w * s i) * (D.w * s j) = if i = j then 1 else 0 := by
+    rw [star_mul]
+    calc
+      _ = star (s i) * (star D.w * D.w) * s j := by noncomm_ring
+      _ = _ := by rw [D.w_gram, mul_one, hs]
+  have hzws (j : ℕ) : star z * (D.w * s j) = 0 := by rw [← mul_assoc, hzw, zero_mul]
+  have hwsz (j : ℕ) : star (D.w * s j) * z = 0 := by
+    rw [star_mul, mul_assoc, hwz, mul_zero]
+  have hr (i j : Fin 3) : star (r i) * r j = if i = j then 1 else 0 := by
+    fin_cases i <;> fin_cases j
+    · exact hz
+    · exact hzws 0
+    · exact hzws 1
+    · exact hwsz 0
+    · exact hsg 0 0
+    · exact hsg 0 1
+    · exact hwsz 1
+    · exact hsg 1 0
+    · exact hsg 1 1
+  obtain ⟨hq0, b, hb, hbs, _⟩ := exists_buffer_shrink_range_pair r hr
+  exact ⟨hq0, b, hb, hbs⟩
+
+/-- The second buffer compares the entire residual source representation
+with the complementary target corner, while fixing the retained full
+subcorner pointwise. -/
+lemma exists_buffered_tail_cancellation [Nontrivial E]
+    (U : Ultrafilter ℕ) [Fact ((U : Filter ℕ) ≤ atTop)]
+    (R : ℕ → E) (hR : ∀ i j, star (R i) * R j = if i = j then 1 else 0)
+    (D : BufferAbsorptionCorner (StarSubalgebra.centralizer ℂ (Set.range R)))
+    (s t : ℕ → StarSubalgebra.centralizer ℂ (Set.range R))
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then 1 else 0)
+    (z : StarSubalgebra.centralizer ℂ (Set.range R))
+    (hz : star z * z = 1) (hqz : D.q * z = z)
+    (hqt : ∀ i, Commute D.q (t i))
+    (hzt : ∀ i, Commute z (t i) ∧ Commute (star z) (t i))
+    (n : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    let d := NormUltra.QuotientAlgebra.diagonalHom (A := E) U
+    ∃ v : unitary (NormUltra.QuotientAlgebra (fun _ : ℕ => E) U), Joined 1 v ∧
+      ∀ i : Fin (n + 1),
+        ‖(v : NormUltra.QuotientAlgebra (fun _ : ℕ => E) U) *
+          d (t i * D.q + D.w * s i * star D.w) *
+          star (v : NormUltra.QuotientAlgebra (fun _ : ℕ => E) U) - d (t i)‖ < ε := by
+  intro d
+  let C := StarSubalgebra.centralizer ℂ (Set.range R)
+  let F := NormUltra.QuotientAlgebra (fun _ : ℕ => E) U
+  let φ : C →⋆ₐ[ℂ] F := d.comp C.subtype
+  let G := TailCancellation.geometry D z hz hqz
+  have hpt (i : ℕ) : Commute (TailCancellation.full z) (t i) :=
+    (hzt i).1.mul_left (hzt i).2
+  let x : Fin (n + 2) → C := fun i => TailCancellation.sourceRow D z s t i
+  let y : Fin (n + 2) → C := fun i => TailCancellation.targetRow z t i
+  have hx (i j : Fin (n + 2)) : star (x i) * x j =
+      if i = j then TailCancellation.support z else 0 := by
+    simpa only [x, Fin.ext_iff] using TailCancellation.source_gram D z G s t hs ht hqt hpt i j
+  have hy (i j : Fin (n + 2)) : star (y i) * y j =
+      if i = j then TailCancellation.support z else 0 := by
+    simpa only [y, Fin.ext_iff] using TailCancellation.target_gram z G.Q_proj t ht i j
+  obtain ⟨hQ0, b, hb, hbs⟩ := exists_tail_cancellation_reference D s hs z hz hqz
+  obtain ⟨v, hv, hvp, _, hvi⟩ := exists_buffered_relative_witness U R hR
+    (TailCancellation.support z) G.Q_proj.isSelfAdjoint.star_eq G.Q_proj.isIdempotentElem.eq
+    hQ0 n x y (fun i => TailCancellation.source_support D z G s t hpt i)
+    (fun i => TailCancellation.target_support z G.Q_proj t hpt i) hx hy b hb hbs ε hε
+  let D' := D.map φ
+  have hz' : star (φ z) * φ z = 1 := by
+    simpa only [map_mul, map_star, map_one] using congrArg φ hz
+  have hqz' : D'.q * φ z = φ z := by
+    simpa only [D', BufferAbsorptionCorner.map, map_mul] using congrArg φ hqz
+  let G' := TailCancellation.geometry D' (φ z) hz' hqz'
+  have hvp' : (v : F) * TailCancellation.full (φ z) = TailCancellation.full (φ z) := by
+    change (v : F) * (1 - φ (TailCancellation.support z)) =
+      1 - φ (TailCancellation.support z) at hvp
+    simpa only [TailCancellation.support, TailCancellation.full, map_sub, map_mul,
+      map_star, map_one, sub_sub_cancel] using hvp
+  have hpt' (i : ℕ) : Commute (TailCancellation.full (φ z)) (φ (t i)) := by
+    have h := congrArg φ (hpt i).eq
+    change TailCancellation.full (φ z) * φ (t i) = φ (t i) * TailCancellation.full (φ z)
+    simpa only [TailCancellation.full, map_mul, map_star] using h
+  refine ⟨v, hv, fun i => ?_⟩
+  have hi := hvi i
+  have he := TailCancellation.recombination_norm D' (φ z) G'
+    (fun j => φ (s j)) (fun j => φ (t j)) v hvp' hpt' i
+  have hsource : TailCancellation.sourceRow D' (φ z) (fun j => φ (s j))
+      (fun j => φ (t j)) i = φ (x i.castSucc) := by
+    simp only [TailCancellation.sourceRow, TailCancellation.rest, TailCancellation.full,
+      D', BufferAbsorptionCorner.map, x, map_add, map_mul, map_sub, map_star, Fin.val_castSucc]
+  have htarget : TailCancellation.targetRow (φ z) (fun j => φ (t j)) i = φ (y i.castSucc) := by
+    simp only [TailCancellation.targetRow, TailCancellation.support, TailCancellation.full,
+      y, map_mul, map_sub, map_one, map_star, Fin.val_castSucc]
+  rw [hsource, htarget] at he
+  change ‖(v : F) * φ (t i * D.q + D.w * s i * star D.w) * star (v : F) - φ (t i)‖ < ε
+  rw [show φ (t i * D.q + D.w * s i * star D.w) =
+      φ (t i) * D'.q + D'.w * φ (s i) * star D'.w by
+    simp only [map_add, map_mul, map_star, D', BufferAbsorptionCorner.map]]
+  rw [he]
+  exact hi
+
+/-- Two commuting proper rows in the first buffer's commutant admit
+actual connected finite conjugacy in the next norm ultrapower. -/
+lemma exists_buffered_commuting_rows_conjugacy [Nontrivial E]
+    (U : Ultrafilter ℕ) [Fact ((U : Filter ℕ) ≤ atTop)]
+    (R : ℕ → E) (hR : ∀ i j, star (R i) * R j = if i = j then 1 else 0)
+    (s t : ℕ → StarSubalgebra.centralizer ℂ (Set.range R))
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (ht : ∀ i j, star (t i) * t j = if i = j then 1 else 0)
+    (hst : bergRowsCommute s t) (n : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    let d := NormUltra.QuotientAlgebra.diagonalHom (A := E) U
+    ∃ v : unitary (NormUltra.QuotientAlgebra (fun _ : ℕ => E) U), Joined 1 v ∧
+      ∀ i : Fin (n + 1),
+        ‖(v : NormUltra.QuotientAlgebra (fun _ : ℕ => E) U) * d (s i) *
+          star (v : NormUltra.QuotientAlgebra (fun _ : ℕ => E) U) - d (t i)‖ < ε := by
+  intro d
+  let C := StarSubalgebra.centralizer ℂ (Set.range R)
+  let F := NormUltra.QuotientAlgebra (fun _ : ℕ => E) U
+  let φ : C →⋆ₐ[ℂ] F := d.comp C.subtype
+  obtain ⟨D, hanchor, _, hspare, _, _, ⟨z, hz, hqz, hzcomm⟩, hcomm⟩ :=
+    exists_canonical_connected_absorption_corner_with_commuting_isometry s hs (n + 1) 1
+      (by norm_num)
+  have htc (i : ℕ) : ∀ j, Commute (s j) (t i) ∧ Commute (star (s j)) (t i) := by
+    intro j
+    exact ⟨(hst j i).1, by simpa only [star_star] using (hst j i).2.star_star⟩
+  have htcs (i : ℕ) : ∀ j, Commute (s j) (star (t i)) ∧
+      Commute (star (s j)) (star (t i)) := by
+    intro j
+    exact ⟨(hst j i).2, (hst j i).1.star_star⟩
+  have hqt (i : ℕ) := (hcomm (t i) (htc i)).1
+  have hat (i : ℕ) : Commute (star D.a) (t i) := by
+    simpa only [star_star] using (hcomm (star (t i)) (htcs i)).2.2.1.star_star
+  have hbt (i : ℕ) : Commute (star D.b) (t i) := by
+    simpa only [star_star] using (hcomm (star (t i)) (htcs i)).2.2.2.star_star
+  have hzt (i : ℕ) : Commute z (t i) ∧ Commute (star z) (t i) := by
+    exact ⟨hzcomm (t i) (htc i), by
+      simpa only [star_star] using (hzcomm (star (t i)) (htcs i)).star_star⟩
+  have heps : 0 < ε / 2 := by positivity
+  obtain ⟨a, ha, hai⟩ := D.exists_proper_vacuum_absorption s t hs ht (n + 1)
+    hspare hqt hat hbt (ε / 2) heps
+  obtain ⟨v, hv, hvi⟩ := exists_buffered_tail_cancellation U R hR D s t hs ht
+    z hz hqz hqt hzt n (ε / 2) heps
+  let A : unitary F := Unitary.map (CStarConnectedLift.starMonoidHom φ) a
+  have hA : Joined (1 : unitary F) A := by
+    have h := (hanchor.trans ha).map (CStarAbsorption.continuous_unitaryMap φ)
+    simpa only [map_one] using h
+  refine ⟨v * A, by simpa only [one_mul] using hv.mul hA, fun i => ?_⟩
+  let c := φ (t i * D.q + D.w * s i * star D.w)
+  have hfirst : ‖(A : F) * φ (s i) * star (A : F) - c‖ < ε / 2 := by
+    have hn := NonUnitalStarAlgHom.norm_apply_le φ.toNonUnitalStarAlgHom
+      ((a : C) * s i * star (a : C) - (t i * D.q + D.w * s i * star D.w))
+    have he : φ ((a : C) * s i * star (a : C) -
+        (t i * D.q + D.w * s i * star D.w)) =
+        (A : F) * φ (s i) * star (A : F) - c := by
+      change φ ((a : C) * s i * star (a : C) - _) =
+        φ (a : C) * φ (s i) * star (φ (a : C)) - φ _
+      simp only [map_sub, map_mul, map_star]
+    change ‖φ ((a : C) * s i * star (a : C) -
+      (t i * D.q + D.w * s i * star D.w))‖ ≤ _ at hn
+    rw [he] at hn
+    exact hn.trans_lt (hai i)
+  have hsecond : ‖(v : F) * c * star (v : F) - φ (t i)‖ < ε / 2 := hvi i
+  have hnorm : ‖(v : F) * ((A : F) * φ (s i) * star (A : F) - c) *
+      star (v : F)‖ = ‖(A : F) * φ (s i) * star (A : F) - c‖ := by
+    rw [mul_assoc, CStarRing.norm_coe_unitary_mul]
+    exact CStarRing.norm_mul_mem_unitary _ (Unitary.star_mem v.property)
+  have hsum := norm_add_le
+    ((v : F) * ((A : F) * φ (s i) * star (A : F) - c) * star (v : F))
+    ((v : F) * c * star (v : F) - φ (t i))
+  rw [hnorm] at hsum
+  have hid : ((v * A : unitary F) : F) * φ (s i) * star ((v * A : unitary F) : F) - φ (t i) =
+      (v : F) * ((A : F) * φ (s i) * star (A : F) - c) * star (v : F) +
+      ((v : F) * c * star (v : F) - φ (t i)) := by
+    simp only [Submonoid.coe_mul, star_mul]
+    noncomm_ring
+  change ‖((v * A : unitary F) : F) * φ (s i) * star ((v * A : unitary F) : F) - φ (t i)‖ < ε
+  rw [hid]
+  exact hsum.trans_lt (by linarith)
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/TensorApproximation.lean

@@ -0,0 +1,142 @@
+import OAI.Analysis.OInfinity.CPAP
+import OAI.Analysis.OInfinity.TensorGram
+import OAI.Analysis.JiangSu.TensorProducts.FaithfulTensorCrossNorm
+
+namespace OAI
+
+/-! # The finite Fock approximations in arbitrary tensor completions
+
+Pointwise convergence is independent of the C*-norm on the algebraic tensor
+product.  The uniform compression bound is a separate step in proving
+uniqueness of that norm.
+-/
+
+noncomputable section
+open scoped CStarAlgebra TensorProduct
+open Filter Topology
+
+namespace WeakPureInfiniteness
+
+private lemma linearMap_error_add {V : Type*} [AddCommGroup V] [Module ℂ V]
+    (T : V →ₗ[ℂ] V) (x y : V) :
+    T (x + y) - (x + y) = (T x - x) + (T y - y) := by
+  rw [T.map_add, add_sub_add_comm]
+
+local instance : PartialOrder OInfinity := CStarAlgebra.spectralOrder _
+local instance : StarOrderedRing OInfinity := CStarAlgebra.spectralOrderedRing _
+
+lemma finiteFockCoefficient_norm_le (N m : ℕ) :
+    ‖∑ i : FiniteFockIndex N m,
+      star (finiteFockUnweightedCoefficient i) * finiteFockUnweightedCoefficient i‖ ≤ (m : ℝ) + 1 ∧
+    ‖∑ i : FiniteFockIndex N m,
+      star (finiteFockWeightedCoefficient i) * finiteFockWeightedCoefficient i‖ ≤ (m : ℝ) + 1 := by
+  let x : OInfinity := ∑ i : FiniteFockIndex N m,
+    star (finiteFockUnweightedCoefficient i) * finiteFockUnweightedCoefficient i
+  let y : OInfinity := ∑ i : FiniteFockIndex N m,
+    star (finiteFockWeightedCoefficient i) * finiteFockWeightedCoefficient i
+  have hx : 0 ≤ x := Finset.sum_nonneg (fun _ _ => star_mul_self_nonneg _)
+  have hy : 0 ≤ y := Finset.sum_nonneg (fun _ _ => star_mul_self_nonneg _)
+  have he : x + y = ((m : ℝ) + 1) • (1 : OInfinity) := finiteFockCoefficient_normalization N m
+  have hn : ‖x + y‖ = (m : ℝ) + 1 := by
+    rw [he]
+    change ‖(((((m : ℝ) + 1) : ℝ) : ℂ)) • (1 : OInfinity)‖ = _
+    rw [norm_smul, norm_one, mul_one, Complex.norm_real, Real.norm_of_nonneg (by positivity)]
+  constructor
+  · exact (CStarAlgebra.norm_le_norm_of_le_of_nonneg (le_add_of_nonneg_right hy) hx).trans_eq hn
+  · exact (CStarAlgebra.norm_le_norm_of_le_of_nonneg (le_add_of_nonneg_left hx) hy).trans_eq hn
+
+lemma oInfinityFockReturn_mem_adjoin (N m : ℕ)
+    (M : CStarMatrix (FiniteFockIndex N m) (FiniteFockIndex N m) ℂ) :
+    oInfinityFockReturn N m M ∈ StarAlgebra.adjoin ℂ (Set.range oInfinityIsometry) := by
+  let S := StarAlgebra.adjoin ℂ (Set.range oInfinityIsometry)
+  have hgen (i : ℕ) : oInfinityIsometry i ∈ S := StarAlgebra.subset_adjoin ℂ _ ⟨i, rfl⟩
+  have hword (k : ℕ) (w : Fin k → Fin N) : oInfinityPositiveWord N w ∈ S := by
+    induction k with
+    | zero => exact S.one_mem
+    | succ k ih => exact S.mul_mem (hgen _) (ih (Fin.tail w))
+  have hlevel (k : ℕ) : oInfinityLevel N k ∈ S := by
+    induction k with
+    | zero => exact S.one_mem
+    | succ k ih =>
+      change (∑ i : Fin N, oInfinityIsometry i * oInfinityLevel N k *
+        star (oInfinityIsometry i)) ∈ S
+      exact S.sum_mem (fun i _ => S.mul_mem (S.mul_mem (hgen _) ih) (S.star_mem' (hgen _)))
+  have hvac : oInfinityFiniteVacuum N ∈ S := S.sub_mem S.one_mem (hlevel 1)
+  have hu (i : FiniteFockIndex N m) : finiteFockUnweightedCoefficient i ∈ S :=
+    S.star_mem' (hword _ i.2)
+  have hw (i : FiniteFockIndex N m) : finiteFockWeightedCoefficient i ∈ S :=
+    S.smul_mem (S.mul_mem hvac (S.star_mem' (hword _ i.2))) _
+  have hgram (c : FiniteFockIndex N m → OInfinity) (hc : ∀ i, c i ∈ S) :
+      cuntzGramMap (finiteFockCuntzFamily N m) (finiteFockCuntzFamily_relations N m) c M ∈ S := by
+    rw [cuntzGramMap_apply]
+    exact S.sum_mem (fun i _ => S.sum_mem (fun j _ =>
+      S.smul_mem (S.mul_mem (S.star_mem' (hc i)) (hc j)) _))
+  change (((((m : ℝ) + 1)⁻¹ : ℝ) : ℂ) •
+    (cuntzGramMap (finiteFockCuntzFamily N m) (finiteFockCuntzFamily_relations N m)
+      finiteFockUnweightedCoefficient M +
+     cuntzGramMap (finiteFockCuntzFamily N m) (finiteFockCuntzFamily_relations N m)
+      finiteFockWeightedCoefficient M)) ∈ S
+  exact S.smul_mem (S.add_mem (hgram _ hu) (hgram _ hw)) _
+
+lemma exists_oInfinityApproximation_polynomial (n : ℕ) (a : OInfinity) :
+    ∃ c : List (ℕ × Bool) →₀ ℂ,
+      cuntzPolynomial oInfinityIsometry c = oInfinityApproximationSequence n a := by
+  apply exists_cuntzPolynomial_of_mem_adjoin
+  exact oInfinityFockReturn_mem_adjoin n (n + 1) (oInfinityFockCompression n (n + 1) a)
+
+theorem fockOperatorRepresentation_injective : Function.Injective fockOperatorRepresentation := by
+  apply (injective_iff_map_eq_zero _).mpr
+  intro a ha
+  have hcompression (N m : ℕ) : oInfinityFockCompression N m a = 0 := by
+    ext i j
+    rw [oInfinityFockCompression_apply, ha]
+    simp
+  have happ (n : ℕ) : oInfinityApproximationSequence n a = 0 := by
+    change oInfinityFockReturn n (n + 1) (oInfinityFockCompression n (n + 1) a) = 0
+    rw [hcompression, map_zero]
+  have ht := tendsto_iff_norm_sub_tendsto_zero.mp (oInfinityApproximationSequence_tendsto a)
+  simp only [happ, zero_sub, norm_neg] at ht
+  apply norm_eq_zero.mp
+  exact tendsto_nhds_unique tendsto_const_nhds ht
+
+variable {B : Type*} [CStarAlgebra B]
+
+def oInfinityTensorApproximation (n : ℕ) :
+    OInfinity ⊗[ℂ] B →ₗ[ℂ] OInfinity ⊗[ℂ] B :=
+  TensorProduct.map (oInfinityApproximationSequence n).toLinearMap LinearMap.id
+
+@[simp] lemma oInfinityTensorApproximation_tmul (n : ℕ) (a : OInfinity) (b : B) :
+    oInfinityTensorApproximation n (a ⊗ₜ[ℂ] b) =
+      oInfinityApproximationSequence n a ⊗ₜ[ℂ] b :=
+  TensorProduct.map_tmul _ _ _ _
+
+lemma oInfinityTensorApproximation_tmul_error
+    (p : Pureness.CStarAlgebraNorm (OInfinity ⊗[ℂ] B)) (n : ℕ) (a : OInfinity) (b : B) :
+    p.toAlgebraNorm (oInfinityTensorApproximation n (a ⊗ₜ[ℂ] b) - a ⊗ₜ[ℂ] b) =
+      ‖oInfinityApproximationSequence n a - a‖ * ‖b‖ := by
+  rw [oInfinityTensorApproximation_tmul, ← TensorProduct.sub_tmul,
+    NuclearUnitization.cstar_norm_tmul]
+
+theorem oInfinityTensorApproximation_error_tendsto
+    (p : Pureness.CStarAlgebraNorm (OInfinity ⊗[ℂ] B)) (x : OInfinity ⊗[ℂ] B) :
+    Tendsto (fun n => p.toAlgebraNorm (oInfinityTensorApproximation n x - x)) atTop
+      (𝓝 0) := by
+  induction x using TensorProduct.inductionOn with
+  | tmul a b =>
+    simpa only [oInfinityTensorApproximation_tmul_error, zero_mul] using
+      (tendsto_iff_norm_sub_tendsto_zero.mp (oInfinityApproximationSequence_tendsto a)).mul_const ‖b‖
+  | add x y hx hy =>
+    refine squeeze_zero
+      (g := fun n => p.toAlgebraNorm (oInfinityTensorApproximation n x - x) +
+        p.toAlgebraNorm (oInfinityTensorApproximation n y - y))
+      (fun n => apply_nonneg p.toAlgebraNorm _) ?_ ?_
+    · intro n
+      have he := linearMap_error_add (oInfinityTensorApproximation n) x y
+      exact (congrArg p.toAlgebraNorm he).trans_le (map_add_le_add p.toAlgebraNorm _ _)
+    · simpa only [zero_add] using hx.add hy
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/TensorGram.lean

@@ -0,0 +1,223 @@
+import OAI.Analysis.PureInfiniteness.CuntzGramMap
+
+namespace OAI
+
+/-! # Matrix-valued Gram return maps for the O∞ tensor approximation
+
+The corner formulation also works in a nonunital tensor completion: the common
+initial projection need only act identically on the matrix coefficients.
+-/
+
+noncomputable section
+open scoped CStarAlgebra ComplexOrder
+
+namespace WeakPureInfiniteness
+
+variable {B E I : Type*} [NonUnitalCStarAlgebra B] [NonUnitalCStarAlgebra E]
+  [Fintype I] [DecidableEq I]
+
+local instance oInfinityTensorGramLocal1 : PartialOrder B := CStarAlgebra.spectralOrder _
+local instance oInfinityTensorGramLocal2 : StarOrderedRing B := CStarAlgebra.spectralOrderedRing _
+
+def supportedCuntzMatrixLinear (r : I → E) (σ : B →⋆ₙₐ[ℂ] E) :
+    CStarMatrix I I B →ₗ[ℂ] E where
+  toFun M := ∑ i, ∑ j, r i * σ (M i j) * star (r j)
+  map_add' M N := by
+    simp only [CStarMatrix.add_apply, map_add, mul_add, add_mul, Finset.sum_add_distrib]
+  map_smul' c M := by
+    simp only [CStarMatrix.smul_apply, map_smul, mul_smul_comm, smul_mul_assoc,
+      Finset.smul_sum, RingHom.id_apply]
+
+omit [Fintype I] in
+lemma supportedCuntzMatrix_term_mul (r : I → E) (e : E) (σ : B →⋆ₙₐ[ℂ] E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then e else 0)
+    (he : ∀ b, e * σ b = σ b) (M N : CStarMatrix I I B) (i j k l : I) :
+    (r i * σ (M i j) * star (r j)) * (r k * σ (N k l) * star (r l)) =
+      if j = k then r i * σ (M i j * N k l) * star (r l) else 0 := by
+  calc
+    _ = r i * σ (M i j) * (star (r j) * r k) * σ (N k l) * star (r l) := by
+      noncomm_ring
+    _ = _ := by
+      rw [hr]
+      split_ifs with h
+      · rw [mul_assoc (r i * σ (M i j)) e, he, map_mul]
+        simp only [mul_assoc]
+      · simp
+
+def supportedCuntzMatrixHom (r : I → E) (e : E) (σ : B →⋆ₙₐ[ℂ] E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then e else 0)
+    (he : ∀ b, e * σ b = σ b) : CStarMatrix I I B →⋆ₙₐ[ℂ] E where
+  toFun := supportedCuntzMatrixLinear r σ
+  map_zero' := by simp [supportedCuntzMatrixLinear]
+  map_add' := map_add _
+  map_smul' := map_smul _
+  map_mul' M N := by
+    change (∑ i, ∑ j, r i * σ ((M * N) i j) * star (r j)) =
+      (∑ i, ∑ j, r i * σ (M i j) * star (r j)) *
+        (∑ i, ∑ j, r i * σ (N i j) * star (r j))
+    simp only [CStarMatrix.mul_apply, map_sum, Finset.mul_sum, Finset.sum_mul]
+    simp only [supportedCuntzMatrix_term_mul r e σ hr he, Finset.sum_ite_eq',
+      Finset.mem_univ, ite_true]
+    calc
+      _ = ∑ i, ∑ k, ∑ j, r i * σ (M i k * N k j) * star (r j) := by
+        apply Finset.sum_congr rfl
+        intro i _
+        exact Finset.sum_comm
+      _ = ∑ k, ∑ i, ∑ j, r i * σ (M i k * N k j) * star (r j) := Finset.sum_comm
+      _ = _ := by
+        apply Finset.sum_congr rfl
+        intro k _
+        exact Finset.sum_comm
+  map_star' M := by
+    change (∑ i, ∑ j, r i * σ ((star M) i j) * star (r j)) =
+      star (∑ i, ∑ j, r i * σ (M i j) * star (r j))
+    simp only [CStarMatrix.star_apply, map_star, star_sum, star_mul, star_star, mul_assoc]
+    exact Finset.sum_comm
+
+lemma supportedCuntzMatrixHom_apply (r : I → E) (e : E) (σ : B →⋆ₙₐ[ℂ] E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then e else 0)
+    (he : ∀ b, e * σ b = σ b) (M : CStarMatrix I I B) :
+    supportedCuntzMatrixHom r e σ hr he M =
+      ∑ i, ∑ j, r i * σ (M i j) * star (r j) := rfl
+
+lemma supportedCuntzMatrixHom_entry (r : I → E) (e : E) (σ : B →⋆ₙₐ[ℂ] E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then e else 0)
+    (he : ∀ b, e * σ b = σ b) (heStar : star e = e)
+    (M : CStarMatrix I I B) (i j : I) :
+    star (r i) * supportedCuntzMatrixHom r e σ hr he M * r j = σ (M i j) := by
+  have he' (b : B) : σ b * e = σ b := by
+    simpa only [star_mul, map_star, star_star, heStar] using congrArg star (he (star b))
+  have hterm (k l : I) :
+      star (r i) * (r k * σ (M k l) * star (r l)) * r j =
+        if i = k then (if l = j then σ (M k l) else 0) else 0 := by
+    calc
+      _ = (star (r i) * r k) * σ (M k l) * (star (r l) * r j) := by noncomm_ring
+      _ = _ := by
+        rw [hr, hr]
+        split_ifs <;> simp [he, he']
+  rw [supportedCuntzMatrixHom_apply]
+  simp only [Finset.mul_sum, Finset.sum_mul, hterm, Finset.sum_ite_irrel,
+    Finset.sum_const_zero, Finset.sum_ite_eq', Finset.sum_ite_eq, Finset.mem_univ, ite_true]
+
+lemma supportedCuntzMatrixHom_injective (r : I → E) (e : E) (σ : B →⋆ₙₐ[ℂ] E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then e else 0)
+    (he : ∀ b, e * σ b = σ b) (heStar : star e = e)
+    (hσ : Function.Injective σ) :
+    Function.Injective (supportedCuntzMatrixHom r e σ hr he) := by
+  apply (injective_iff_map_eq_zero _).mpr
+  intro M hM
+  ext i j
+  apply hσ
+  have h := supportedCuntzMatrixHom_entry r e σ hr he heStar M i j
+  rw [hM, mul_zero, zero_mul] at h
+  simpa only [CStarMatrix.zero_apply, map_zero] using h.symm
+
+lemma supportedCuntz_rangeProjection (r : I → E) (e : E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then e else 0)
+    (hre : ∀ i, r i * e = r i) : IsStarProjection (∑ i, r i * star (r i)) := by
+  apply isStarProjection_iff'.mpr
+  constructor
+  · have hterm (i j : I) : (r i * star (r i)) * (r j * star (r j)) =
+        if i = j then r i * star (r i) else 0 := by
+      calc
+        _ = r i * (star (r i) * r j) * star (r j) := by noncomm_ring
+        _ = _ := by
+          rw [hr]
+          split_ifs with hij
+          · subst j; rw [hre]
+          · simp
+    simp only [Finset.sum_mul, Finset.mul_sum, hterm, Finset.sum_ite_eq',
+      Finset.mem_univ, ite_true]
+  · simp only [star_sum, star_mul, star_star]
+
+lemma supportedCuntzMatrixHom_of_entries (r : I → E) (e : E) (σ : B →⋆ₙₐ[ℂ] E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then e else 0)
+    (he : ∀ b, e * σ b = σ b) (x : E) (M : CStarMatrix I I B)
+    (hentry : ∀ i j, star (r i) * x * r j = σ (M i j)) :
+    supportedCuntzMatrixHom r e σ hr he M =
+      (∑ i, r i * star (r i)) * x * (∑ i, r i * star (r i)) := by
+  rw [supportedCuntzMatrixHom_apply]
+  simp only [Finset.sum_mul, Finset.mul_sum]
+  conv_rhs => rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro i _
+  apply Finset.sum_congr rfl
+  intro j _
+  rw [← hentry]
+  simp only [mul_assoc]
+
+lemma supportedCuntz_compression_norm_le (r : I → E) (e : E) (σ : B →⋆ₙₐ[ℂ] E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then e else 0)
+    (he : ∀ b, e * σ b = σ b) (heStar : star e = e)
+    (hre : ∀ i, r i * e = r i) (hσ : Function.Injective σ)
+    (x : E) (M : CStarMatrix I I B)
+    (hentry : ∀ i j, star (r i) * x * r j = σ (M i j)) : ‖M‖ ≤ ‖x‖ := by
+  let P := ∑ i, r i * star (r i)
+  have hP : ‖P‖ ≤ 1 := IsStarProjection.norm_le _ (supportedCuntz_rangeProjection r e hr hre)
+  have hnorm := NonUnitalStarAlgHom.norm_map (supportedCuntzMatrixHom r e σ hr he)
+    (supportedCuntzMatrixHom_injective r e σ hr he heStar hσ) M
+  rw [← hnorm, supportedCuntzMatrixHom_of_entries r e σ hr he x M hentry]
+  calc
+    ‖P * x * P‖ ≤ ‖P‖ * ‖x‖ * ‖P‖ := norm_mul₃_le
+    _ ≤ 1 * ‖x‖ * 1 := mul_le_mul (mul_le_mul_of_nonneg_right hP (norm_nonneg _)) hP
+      (norm_nonneg _) (by positivity)
+    _ = ‖x‖ := by ring
+
+lemma supportedCuntz_gram_apply (r v : I → E) (e : E) (σ : B →⋆ₙₐ[ℂ] E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then e else 0)
+    (he : ∀ b, e * σ b = σ b) (heStar : star e = e)
+    (hv : ∀ i, e * v i = v i) (M : CStarMatrix I I B) :
+    star (∑ i, r i * v i) * supportedCuntzMatrixHom r e σ hr he M *
+      (∑ i, r i * v i) = ∑ i, ∑ j, star (v i) * σ (M i j) * v j := by
+  have hv' (i : I) : star (v i) * e = star (v i) := by
+    simpa only [star_mul, heStar] using congrArg star (hv i)
+  have hl (i : I) : star (∑ j, r j * v j) * r i = star (v i) := by
+    simp only [star_sum, Finset.sum_mul, star_mul, mul_assoc, hr]
+    simp only [mul_ite, mul_zero, Finset.sum_ite_eq', Finset.mem_univ, ite_true, hv']
+  have hh (j : I) : star (r j) * (∑ i, r i * v i) = v j := by
+    simp only [Finset.mul_sum, ← mul_assoc, hr]
+    simp [hv]
+  rw [supportedCuntzMatrixHom_apply]
+  conv_lhs => arg 1; rw [Finset.mul_sum]
+  rw [Finset.sum_mul]
+  apply Finset.sum_congr rfl
+  intro i _
+  conv_lhs => arg 1; rw [Finset.mul_sum]
+  rw [Finset.sum_mul]
+  apply Finset.sum_congr rfl
+  intro j _
+  calc
+    _ = (star (∑ k, r k * v k) * r i) * σ (M i j) *
+        (star (r j) * (∑ k, r k * v k)) := by noncomm_ring
+    _ = _ := by rw [hl, hh]
+
+lemma supportedCuntz_gram_norm_le (r v : I → E) (e : E) (σ : B →⋆ₙₐ[ℂ] E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then e else 0)
+    (he : ∀ b, e * σ b = σ b) (hv : ∀ i, e * v i = v i)
+    (M : CStarMatrix I I B) :
+    ‖star (∑ i, r i * v i) * supportedCuntzMatrixHom r e σ hr he M *
+      (∑ i, r i * v i)‖ ≤ ‖∑ i, star (v i) * v i‖ * ‖M‖ := by
+  let t := ∑ i, r i * v i
+  have ht : star t * t = ∑ i, star (v i) * v i := by
+    simp only [t, star_sum, Finset.sum_mul, Finset.mul_sum, star_mul]
+    have hh (i j : I) : (star (v i) * star (r i)) * (r j * v j) =
+        if i = j then star (v i) * v i else 0 := by
+      rw [mul_assoc, ← mul_assoc (star (r i)), hr]
+      split_ifs with hij
+      · subst j
+        rw [hv]
+      · simp
+    simp only [hh, Finset.sum_ite_eq', Finset.mem_univ, ite_true]
+  calc
+    _ ≤ (‖t‖ * ‖t‖) * ‖supportedCuntzMatrixHom r e σ hr he M‖ := by
+      exact norm_mul₃_le.trans_eq (by rw [norm_star]; ring)
+    _ = ‖∑ i, star (v i) * v i‖ * ‖supportedCuntzMatrixHom r e σ hr he M‖ := by
+      rw [← CStarRing.norm_star_mul_self, ht]
+    _ ≤ _ := mul_le_mul_of_nonneg_left
+      (NonUnitalStarAlgHom.norm_apply_le _ M) (norm_nonneg _)
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/TensorNorm.lean

@@ -0,0 +1,487 @@
+import OAI.Analysis.OInfinity.TensorApproximation
+import OAI.Analysis.OInfinity.VacuumCorner
+
+namespace OAI
+
+/-! # Tensor-norm nuclearity of O∞
+
+Finite unused-generator corners control the Fock matrix in every C*-completion
+of the algebraic tensor product.  The two Gram summands of the return map give
+a uniform factor-two norm comparison, and the C*-identity removes that factor.
+This proves the tensor-norm nuclearity input used by the absorption criterion.
+-/
+
+noncomputable section
+open scoped CStarAlgebra TensorProduct
+open Filter Topology
+
+namespace WeakPureInfiniteness
+
+private lemma algebraNorm_le_sub_add {R : Type*} [Ring R] [Algebra ℂ R]
+    (p : AlgebraNorm ℂ R) (x y : R) : p x ≤ p (x - y) + p y := by
+  simpa only [sub_add_cancel] using map_add_le_add p (x - y) y
+
+private lemma algebraNorm_le_rev_sub_add {R : Type*} [Ring R] [Algebra ℂ R]
+    (p : AlgebraNorm ℂ R) (x y : R) : p x ≤ p (y - x) + p y := by
+  simpa only [map_sub_rev p] using algebraNorm_le_sub_add p x y
+
+private lemma algebraNorm_le_of_approximation {R : Type*} [Ring R] [Algebra ℂ R]
+    (p : AlgebraNorm ℂ R) (x : R) (y : ℕ → R) (C : ℝ)
+    (ht : Tendsto (fun n => p (y n - x)) atTop (𝓝 0))
+    (hb : ∀ᶠ n : ℕ in atTop, p (y n) ≤ C) : p x ≤ C := by
+  have hupper : ∀ᶠ n : ℕ in atTop, p x ≤ p (y n - x) + C := by
+    filter_upwards [hb] with n hn
+    exact (algebraNorm_le_rev_sub_add p x (y n)).trans (add_le_add_right hn _)
+  simpa only [zero_add] using ge_of_tendsto (ht.add_const C) hupper
+
+private lemma map_smul_mul {A E : Type*} [NonUnitalCStarAlgebra A]
+    [NonUnitalCStarAlgebra E] (R : A →⋆ₙₐ[ℂ] E) (c : ℂ) (a : A) (z : E) :
+    R (c • a) * z = c • (R a * z) := by
+  calc
+    R (c • a) * z = (c • R a) * z := congrArg (fun x : E => x * z) (map_smul R c a)
+    _ = _ := smul_mul_assoc c (R a) z
+
+private lemma map_scaled_sum_mul {A E : Type*} [NonUnitalCStarAlgebra A]
+    [NonUnitalCStarAlgebra E] (R : A →⋆ₙₐ[ℂ] E) (c : ℂ) (a b : A) (z : E) :
+    R (c • (a + b)) * z = c • (R a * z + R b * z) := by
+  rw [map_smul_mul]
+  exact congrArg (fun x : E => c • x)
+    ((congrArg (fun x : E => x * z) (map_add R a b)).trans (add_mul (R a) (R b) z))
+
+private lemma map_star_sandwich {A E : Type*} [NonUnitalCStarAlgebra A]
+    [NonUnitalCStarAlgebra E] (R : A →⋆ₙₐ[ℂ] E) (x a y : A) :
+    star (R x) * R a * R y = R (star x * a * y) := by
+  rw [map_mul, map_mul, map_star]
+
+private lemma map_scalar_unit_mul {A B E : Type*} [CStarAlgebra A] [CStarAlgebra B]
+    [NonUnitalCStarAlgebra E] (R : A →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hsupport : ∀ b, R 1 * S b = S b) (c : ℂ) (b : B) :
+    R (c • (1 : A)) * S b = S (c • b) := by
+  calc
+    _ = c • (R 1 * S b) := map_smul_mul R c 1 (S b)
+    _ = c • S b := congrArg (fun x : E => c • x) (hsupport b)
+    _ = S (c • b) := (map_smul S c b).symm
+
+variable {B E : Type*} [CStarAlgebra B] [NonUnitalCStarAlgebra E]
+
+local instance oInfinityTensorNormLocal1 : PartialOrder B := CStarAlgebra.spectralOrder _
+local instance oInfinityTensorNormLocal2 : StarOrderedRing B := CStarAlgebra.spectralOrderedRing _
+local instance oInfinityTensorNormLocal3 : PartialOrder OInfinity := CStarAlgebra.spectralOrder _
+local instance oInfinityTensorNormLocal4 : StarOrderedRing OInfinity := CStarAlgebra.spectralOrderedRing _
+
+def fockTensorCoefficient (N m : ℕ) (a : OInfinity) :
+    B →ₗ[ℂ] CStarMatrix (FiniteFockIndex N m) (FiniteFockIndex N m) B where
+  toFun b := CStarMatrix.ofMatrix (fun i j => oInfinityFockCompression N m a i j • b)
+  map_add' b c := by
+    ext i j
+    change oInfinityFockCompression N m a i j • (b + c) =
+      oInfinityFockCompression N m a i j • b + oInfinityFockCompression N m a i j • c
+    exact smul_add _ _ _
+  map_smul' c b := by
+    ext i j
+    exact smul_comm _ _ _
+
+def fockTensorBilinear (N m : ℕ) :
+    OInfinity →ₗ[ℂ] B →ₗ[ℂ] CStarMatrix (FiniteFockIndex N m) (FiniteFockIndex N m) B where
+  toFun := fockTensorCoefficient N m
+  map_add' a b := by
+    ext c i j
+    change oInfinityFockCompression N m (a + b) i j • c = _
+    rw [map_add, CStarMatrix.add_apply, add_smul]
+    rfl
+  map_smul' c a := by
+    ext b i j
+    change oInfinityFockCompression N m (c • a) i j • b = _
+    rw [map_smul, CStarMatrix.smul_apply]
+    exact mul_smul _ _ _
+
+def fockTensorMatrix (N m : ℕ) :
+    OInfinity ⊗[ℂ] B →ₗ[ℂ] CStarMatrix (FiniteFockIndex N m) (FiniteFockIndex N m) B :=
+  TensorProduct.lift (fockTensorBilinear N m)
+
+@[simp] lemma fockTensorMatrix_tmul (N m : ℕ) (a : OInfinity) (b : B)
+    (i j : FiniteFockIndex N m) :
+    fockTensorMatrix N m (a ⊗ₜ[ℂ] b) i j = oInfinityFockCompression N m a i j • b := rfl
+
+def tensorCommutingBilinear {A : Type*} [NonUnitalCStarAlgebra A]
+    (R : A →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E) : A →ₗ[ℂ] B →ₗ[ℂ] E where
+  toFun a :=
+    { toFun b := R a * S b
+      map_add' b c := by rw [map_add, mul_add]
+      map_smul' c b := by rw [map_smul, mul_smul_comm]; rfl }
+  map_add' a b := by
+    ext c
+    change R (a + b) * S c = R a * S c + R b * S c
+    exact (congrArg (fun x : E => x * S c) (map_add R a b)).trans (add_mul _ _ _)
+  map_smul' c a := by
+    ext b
+    change R (c • a) * S b = c • (R a * S b)
+    exact map_smul_mul R c a (S b)
+
+def tensorCommutingEval {A : Type*} [NonUnitalCStarAlgebra A]
+    (R : A →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E) : A ⊗[ℂ] B →ₗ[ℂ] E := TensorProduct.lift (tensorCommutingBilinear R S)
+
+@[simp] lemma tensorCommutingEval_tmul {A : Type*} [NonUnitalCStarAlgebra A]
+    (R : A →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E) (a : A) (b : B) : tensorCommutingEval R S (a ⊗ₜ[ℂ] b) = R a * S b := rfl
+
+lemma commuting_vacuum_compression (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hcomm : ∀ a b, Commute (R a) (S b)) (hsupport : ∀ b, R 1 * S b = S b)
+    {N m : ℕ} (c : List (ℕ × Bool) →₀ ℂ)
+    (hc : ∀ w ∈ c.support, ∀ p ∈ w, p.1 < N) (b : B)
+    (i j : FiniteFockIndex N m) :
+    star (R (finiteVacuumCorner N m i)) *
+      tensorCommutingEval R S (cuntzPolynomial oInfinityIsometry c ⊗ₜ[ℂ] b) *
+        R (finiteVacuumCorner N m j) =
+    S (fockTensorMatrix N m (cuntzPolynomial oInfinityIsometry c ⊗ₜ[ℂ] b) i j) := by
+  rw [tensorCommutingEval_tmul, fockTensorMatrix_tmul]
+  calc
+    _ = (star (R (finiteVacuumCorner N m i)) * R (cuntzPolynomial oInfinityIsometry c)) *
+        (S b * R (finiteVacuumCorner N m j)) := by noncomm_ring
+    _ = (star (R (finiteVacuumCorner N m i)) * R (cuntzPolynomial oInfinityIsometry c) *
+        R (finiteVacuumCorner N m j)) * S b := by
+      rw [(hcomm _ b).symm.eq]
+      simp only [mul_assoc]
+    _ = R (star (finiteVacuumCorner N m i) * cuntzPolynomial oInfinityIsometry c *
+        finiteVacuumCorner N m j) * S b :=
+      congrArg (fun z : E => z * S b) (map_star_sandwich R _ _ _)
+    _ = R (oInfinityFockCompression N m (cuntzPolynomial oInfinityIsometry c) i j • 1) * S b :=
+      congrArg (fun z : OInfinity => R z * S b) (finiteVacuumCorner_polynomial c hc i j)
+    _ = _ := map_scalar_unit_mul R S hsupport _ b
+
+def polynomialTensorSum (l : List ((List (ℕ × Bool) →₀ ℂ) × B)) : OInfinity ⊗[ℂ] B :=
+  (l.map fun t => cuntzPolynomial oInfinityIsometry t.1 ⊗ₜ[ℂ] t.2).sum
+
+lemma exists_tensorApproximation_polynomialSum (n : ℕ) (x : OInfinity ⊗[ℂ] B) :
+    ∃ l : List ((List (ℕ × Bool) →₀ ℂ) × B),
+      oInfinityTensorApproximation n x = polynomialTensorSum l := by
+  induction x using TensorProduct.inductionOn with
+  | tmul a b =>
+    obtain ⟨c, hc⟩ := exists_oInfinityApproximation_polynomial n a
+    refine ⟨[(c, b)], ?_⟩
+    simp only [oInfinityTensorApproximation_tmul, polynomialTensorSum, List.map_cons,
+      List.map_nil, List.sum_cons, List.sum_nil, add_zero, hc]
+  | add x y hx hy =>
+    obtain ⟨l, hl⟩ := hx
+    obtain ⟨k, hk⟩ := hy
+    refine ⟨l ++ k, ?_⟩
+    simp only [map_add, hl, hk, polynomialTensorSum, List.map_append, List.sum_append]
+
+omit [CStarAlgebra B] in
+lemma exists_polynomialTensor_alphabet_bound (l : List ((List (ℕ × Bool) →₀ ℂ) × B)) :
+    ∃ N : ℕ, ∀ t ∈ l, ∀ w ∈ t.1.support, ∀ p ∈ w, p.1 < N := by
+  induction l with
+  | nil => exact ⟨0, by simp⟩
+  | cons t l ih =>
+    obtain ⟨N, hN⟩ := exists_polynomial_alphabet_bound t.1
+    obtain ⟨M, hM⟩ := ih
+    refine ⟨max N M, ?_⟩
+    intro u hu w hw p hp
+    rcases List.mem_cons.mp hu with rfl | hu
+    · exact (hN w hw p hp).trans_le (le_max_left _ _)
+    · exact (hM u hu w hw p hp).trans_le (le_max_right _ _)
+
+lemma commuting_vacuum_compression_list (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hcomm : ∀ a b, Commute (R a) (S b)) (hsupport : ∀ b, R 1 * S b = S b)
+    {N m : ℕ} (l : List ((List (ℕ × Bool) →₀ ℂ) × B))
+    (hl : ∀ t ∈ l, ∀ w ∈ t.1.support, ∀ p ∈ w, p.1 < N)
+    (i j : FiniteFockIndex N m) :
+    star (R (finiteVacuumCorner N m i)) * tensorCommutingEval R S (polynomialTensorSum l) *
+        R (finiteVacuumCorner N m j) = S (fockTensorMatrix N m (polynomialTensorSum l) i j) := by
+  induction l with
+  | nil => simp [polynomialTensorSum]
+  | cons t l ih =>
+    have ht := commuting_vacuum_compression R S hcomm hsupport t.1
+      (hl t (List.mem_cons_self ..)) t.2 i j
+    have htail := ih (fun u hu => hl u (List.mem_cons_of_mem _ hu))
+    simpa only [polynomialTensorSum, List.map_cons, List.sum_cons, map_add, mul_add,
+      add_mul, CStarMatrix.add_apply] using congrArg₂ (· + ·) ht htail
+
+lemma fockTensorMatrix_polynomial_norm_le (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hcomm : ∀ a b, Commute (R a) (S b)) (hsupport : ∀ b, R 1 * S b = S b)
+    (hS : Function.Injective S) {N m : ℕ} (l : List ((List (ℕ × Bool) →₀ ℂ) × B))
+    (hl : ∀ t ∈ l, ∀ w ∈ t.1.support, ∀ p ∈ w, p.1 < N) :
+    ‖fockTensorMatrix N m (polynomialTensorSum l)‖ ≤
+      ‖tensorCommutingEval R S (polynomialTensorSum l)‖ := by
+  let r (i : FiniteFockIndex N m) := R (finiteVacuumCorner N m i)
+  have hr (i j : FiniteFockIndex N m) : star (r i) * r j = if i = j then R 1 else 0 := by
+    dsimp [r]
+    rw [← map_star, ← map_mul, finiteVacuumCorner_relations]
+    split_ifs <;> simp only [map_zero]
+  have heStar : star (R 1) = R 1 := by rw [← map_star, star_one]
+  have hre (i : FiniteFockIndex N m) : r i * R 1 = r i := by
+    dsimp [r]
+    rw [← map_mul, mul_one]
+  exact supportedCuntz_compression_norm_le r (R 1) S hr hsupport heStar hre hS _ _
+    (commuting_vacuum_compression_list R S hcomm hsupport l hl)
+
+lemma mappedFockCuntz_relations (R : OInfinity →⋆ₙₐ[ℂ] E) (N m : ℕ)
+    (i j : FiniteFockIndex N m) :
+    star (R (finiteFockCuntzFamily N m i)) * R (finiteFockCuntzFamily N m j) =
+      if i = j then R 1 else 0 := by
+  rw [← map_star, ← map_mul, finiteFockCuntzFamily_relations]
+  split_ifs <;> simp only [map_zero]
+
+def representedFockGram (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hsupport : ∀ b, R 1 * S b = S b) (N m : ℕ)
+    (c : FiniteFockIndex N m → OInfinity) :
+    CStarMatrix (FiniteFockIndex N m) (FiniteFockIndex N m) B →L[ℂ] E :=
+  (ContinuousLinearMap.mulLeftRight ℂ E
+    (star (∑ i, R (finiteFockCuntzFamily N m i) * R (c i)))
+    (∑ i, R (finiteFockCuntzFamily N m i) * R (c i))).comp
+      (starHomContinuousLinear (supportedCuntzMatrixHom
+        (fun i => R (finiteFockCuntzFamily N m i)) (R 1) S
+        (mappedFockCuntz_relations R N m) hsupport))
+
+lemma representedFockGram_apply (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hsupport : ∀ b, R 1 * S b = S b) (N m : ℕ)
+    (c : FiniteFockIndex N m → OInfinity)
+    (M : CStarMatrix (FiniteFockIndex N m) (FiniteFockIndex N m) B) :
+    representedFockGram R S hsupport N m c M =
+      ∑ i, ∑ j, star (R (c i)) * S (M i j) * R (c j) := by
+  have heStar : star (R 1) = R 1 := by rw [← map_star, star_one]
+  have hv (i : FiniteFockIndex N m) : R 1 * R (c i) = R (c i) := by
+    rw [← map_mul, one_mul]
+  exact supportedCuntz_gram_apply _ _ _ _ (mappedFockCuntz_relations R N m)
+    hsupport heStar hv M
+
+lemma representedFockGram_norm_le (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hsupport : ∀ b, R 1 * S b = S b) (N m : ℕ)
+    (c : FiniteFockIndex N m → OInfinity)
+    (M : CStarMatrix (FiniteFockIndex N m) (FiniteFockIndex N m) B) :
+    ‖representedFockGram R S hsupport N m c M‖ ≤
+      ‖∑ i, star (c i) * c i‖ * ‖M‖ := by
+  have hv (i : FiniteFockIndex N m) : R 1 * R (c i) = R (c i) := by
+    rw [← map_mul, one_mul]
+  have h := supportedCuntz_gram_norm_le (fun i => R (finiteFockCuntzFamily N m i))
+    (fun i => R (c i)) (R 1) S (mappedFockCuntz_relations R N m) hsupport hv M
+  have he : (∑ i, star (R (c i)) * R (c i)) = R (∑ i, star (c i) * c i) := by
+    simp only [map_sum, map_mul, map_star]
+  have hR : ‖∑ i, star (R (c i)) * R (c i)‖ ≤ ‖∑ i, star (c i) * c i‖ := by
+    rw [he]
+    exact NonUnitalStarAlgHom.norm_apply_le R _
+  exact h.trans (mul_le_mul_of_nonneg_right hR (norm_nonneg _))
+
+lemma representedFockGram_tmul (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hcomm : ∀ a b, Commute (R a) (S b)) (hsupport : ∀ b, R 1 * S b = S b)
+    (N m : ℕ) (c : FiniteFockIndex N m → OInfinity) (a : OInfinity) (b : B) :
+    representedFockGram R S hsupport N m c (fockTensorMatrix N m (a ⊗ₜ[ℂ] b)) =
+      R (cuntzGramMap (finiteFockCuntzFamily N m) (finiteFockCuntzFamily_relations N m)
+        c (oInfinityFockCompression N m a)) * S b := by
+  rw [representedFockGram_apply, cuntzGramMap_apply]
+  simp only [fockTensorMatrix_tmul, map_sum, map_smul, Finset.sum_mul, smul_mul_assoc]
+  apply Finset.sum_congr rfl
+  intro i _
+  apply Finset.sum_congr rfl
+  intro j _
+  rw [mul_smul_comm, smul_mul_assoc, map_mul, map_star]
+  congr 1
+  calc
+    _ = star (R (c i)) * (S b * R (c j)) := mul_assoc _ _ _
+    _ = _ := by rw [(hcomm (c j) b).symm.eq]; simp only [mul_assoc]
+
+def representedFockReturn (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hsupport : ∀ b, R 1 * S b = S b) (N m : ℕ) :
+    CStarMatrix (FiniteFockIndex N m) (FiniteFockIndex N m) B →L[ℂ] E :=
+  (((((m : ℝ) + 1)⁻¹ : ℝ) : ℂ)) •
+    (representedFockGram R S hsupport N m finiteFockUnweightedCoefficient +
+      representedFockGram R S hsupport N m finiteFockWeightedCoefficient)
+
+lemma representedFockReturn_norm_le (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hsupport : ∀ b, R 1 * S b = S b) (N m : ℕ)
+    (M : CStarMatrix (FiniteFockIndex N m) (FiniteFockIndex N m) B) :
+    ‖representedFockReturn R S hsupport N m M‖ ≤ 2 * ‖M‖ := by
+  have hK : 0 < (m : ℝ) + 1 := by positivity
+  have hu := (representedFockGram_norm_le R S hsupport N m finiteFockUnweightedCoefficient M).trans
+    (mul_le_mul_of_nonneg_right (finiteFockCoefficient_norm_le N m).1 (norm_nonneg M))
+  have hw := (representedFockGram_norm_le R S hsupport N m finiteFockWeightedCoefficient M).trans
+    (mul_le_mul_of_nonneg_right (finiteFockCoefficient_norm_le N m).2 (norm_nonneg M))
+  change ‖(((((m : ℝ) + 1)⁻¹ : ℝ) : ℂ)) •
+    (representedFockGram R S hsupport N m finiteFockUnweightedCoefficient M +
+      representedFockGram R S hsupport N m finiteFockWeightedCoefficient M)‖ ≤ _
+  rw [norm_smul, Complex.norm_real, Real.norm_of_nonneg (inv_nonneg.mpr hK.le)]
+  calc
+    _ ≤ ((m : ℝ) + 1)⁻¹ * (((m : ℝ) + 1) * ‖M‖ + ((m : ℝ) + 1) * ‖M‖) :=
+      mul_le_mul_of_nonneg_left ((norm_add_le _ _).trans (add_le_add hu hw)) (inv_nonneg.mpr hK.le)
+    _ = _ := by field_simp [hK.ne']; ring
+
+lemma representedFockReturn_tmul (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hcomm : ∀ a b, Commute (R a) (S b)) (hsupport : ∀ b, R 1 * S b = S b)
+    (N m : ℕ) (a : OInfinity) (b : B) :
+    representedFockReturn R S hsupport N m (fockTensorMatrix N m (a ⊗ₜ[ℂ] b)) =
+      R (oInfinityFockApproximation N m a) * S b := by
+  change (((((m : ℝ) + 1)⁻¹ : ℝ) : ℂ)) •
+    (representedFockGram R S hsupport N m finiteFockUnweightedCoefficient
+        (fockTensorMatrix N m (a ⊗ₜ[ℂ] b)) +
+      representedFockGram R S hsupport N m finiteFockWeightedCoefficient
+        (fockTensorMatrix N m (a ⊗ₜ[ℂ] b))) = _
+  rw [representedFockGram_tmul R S hcomm, representedFockGram_tmul R S hcomm]
+  change _ = R ((((((m : ℝ) + 1)⁻¹ : ℝ) : ℂ)) •
+    (cuntzGramMap (finiteFockCuntzFamily N m) (finiteFockCuntzFamily_relations N m)
+      finiteFockUnweightedCoefficient (oInfinityFockCompression N m a) +
+     cuntzGramMap (finiteFockCuntzFamily N m) (finiteFockCuntzFamily_relations N m)
+      finiteFockWeightedCoefficient (oInfinityFockCompression N m a))) * S b
+  exact (map_scaled_sum_mul R _ _ _ (S b)).symm
+
+lemma representedFockReturn_approximation (R : OInfinity →⋆ₙₐ[ℂ] E) (S : B →⋆ₙₐ[ℂ] E)
+    (hcomm : ∀ a b, Commute (R a) (S b)) (hsupport : ∀ b, R 1 * S b = S b)
+    (n : ℕ) (x : OInfinity ⊗[ℂ] B) :
+    representedFockReturn R S hsupport n (n + 1) (fockTensorMatrix n (n + 1) x) =
+      tensorCommutingEval R S (oInfinityTensorApproximation n x) := by
+  induction x using TensorProduct.inductionOn with
+  | tmul a b =>
+    simpa only [oInfinityTensorApproximation_tmul, tensorCommutingEval_tmul,
+      oInfinityApproximationSequence] using
+      representedFockReturn_tmul R S hcomm hsupport n (n + 1) a b
+  | add x y hx hy => simp only [map_add, hx, hy]
+
+lemma tensor_norm_bound_of_approximation
+    (p q : Pureness.CStarAlgebraNorm (OInfinity ⊗[ℂ] B)) (x : OInfinity ⊗[ℂ] B)
+    {C : ℝ} (hC : 0 ≤ C)
+    (hb : ∀ n, q.toAlgebraNorm (oInfinityTensorApproximation n x) ≤
+      C * p.toAlgebraNorm (oInfinityTensorApproximation n x)) :
+    q.toAlgebraNorm x ≤ C * p.toAlgebraNorm x := by
+  have hupper (n : ℕ) : q.toAlgebraNorm x ≤
+      q.toAlgebraNorm (oInfinityTensorApproximation n x - x) +
+        C * (p.toAlgebraNorm (oInfinityTensorApproximation n x - x) + p.toAlgebraNorm x) := by
+    have hq := algebraNorm_le_rev_sub_add q.toAlgebraNorm x (oInfinityTensorApproximation n x)
+    have hp := algebraNorm_le_sub_add p.toAlgebraNorm (oInfinityTensorApproximation n x) x
+    exact hq.trans (add_le_add_right ((hb n).trans (mul_le_mul_of_nonneg_left hp hC)) _)
+  have ht := (oInfinityTensorApproximation_error_tendsto q x).add
+    (((oInfinityTensorApproximation_error_tendsto p x).add_const (p.toAlgebraNorm x)).const_mul C)
+  simpa only [zero_add] using ge_of_tendsto ht (Filter.Eventually.of_forall hupper)
+
+local instance (priority := 2000) tensorNormFastNonAssoc
+    {A : Type*} [CStarAlgebra A] (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) :
+    NonUnitalNonAssocSemiring p.Completion :=
+  (Pureness.CStarAlgebraNorm.completionCStarAlgebra p).toNonUnitalNonAssocSemiring
+
+local instance (priority := 2000) tensorNormFastAddMonoid
+    {A : Type*} [CStarAlgebra A] (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) : AddMonoid p.Completion :=
+  (Pureness.CStarAlgebraNorm.completionCStarAlgebra p).toAddMonoid
+
+local instance (priority := 2000) tensorNormFastAddCommGroup
+    {A : Type*} [CStarAlgebra A] (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) :
+    AddCommGroup p.Completion :=
+  (Pureness.CStarAlgebraNorm.completionCStarAlgebra p).toAddCommGroup
+
+local instance (priority := 2000) tensorNormFastModule
+    {A : Type*} [CStarAlgebra A] (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) : Module ℂ p.Completion :=
+  (Pureness.CStarAlgebraNorm.completionCStarAlgebra p).toNormedSpace.toModule
+
+local instance (priority := 2000) tensorNormFastDistribMulAction
+    {A : Type*} [CStarAlgebra A] (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) : DistribMulAction ℂ p.Completion :=
+  (tensorNormFastModule p).toDistribMulAction
+
+local instance (priority := 2000) tensorNormFastNorm
+    {A : Type*} [CStarAlgebra A] (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) : Norm p.Completion :=
+  (Pureness.CStarAlgebraNorm.completionCStarAlgebra p).toNorm
+
+def tensorNormLeft {A : Type*} [CStarAlgebra A]
+    (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) :
+    A →⋆ₙₐ[ℂ] p.Completion where
+  toFun a := p.completionMap (a ⊗ₜ[ℂ] (1 : B))
+  map_zero' := by simp
+  map_add' a b := by simp [TensorProduct.add_tmul]
+  map_smul' z a := by
+    rw [← TensorProduct.smul_tmul']
+    exact p.completionMap.map_smul z _
+  map_mul' a b := by rw [← map_mul]; simp
+  map_star' a := by rw [← map_star]; simp
+
+def tensorNormRight {A : Type*} [CStarAlgebra A]
+    (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) :
+    B →⋆ₙₐ[ℂ] p.Completion where
+  toFun b := p.completionMap ((1 : A) ⊗ₜ[ℂ] b)
+  map_zero' := by simp
+  map_add' a b := by simp [TensorProduct.tmul_add]
+  map_smul' z a := by
+    rw [TensorProduct.tmul_smul]
+    exact p.completionMap.map_smul z _
+  map_mul' a b := by rw [← map_mul]; simp
+  map_star' a := by rw [← map_star]; simp
+
+lemma tensorNorm_commute {A : Type*} [CStarAlgebra A]
+    (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) (a : A) (b : B) : Commute (tensorNormLeft p a) (tensorNormRight p b) := by
+  exact ((Commute.one_right a).tmul (Commute.one_left b)).map p.completionMap
+
+lemma tensorNorm_support {A : Type*} [CStarAlgebra A]
+    (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B))
+    (b : B) : tensorNormLeft p 1 * tensorNormRight p b = tensorNormRight p b := by
+  change p.completionMap (1 ⊗ₜ[ℂ] 1) * p.completionMap (1 ⊗ₜ[ℂ] b) = _
+  rw [← map_mul]
+  simp only [Algebra.TensorProduct.tmul_mul_tmul, one_mul]
+  rfl
+
+lemma tensorNormRight_injective {A : Type*} [CStarAlgebra A] [Nontrivial A]
+    (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) :
+    Function.Injective (tensorNormRight p) := by
+  apply (injective_iff_map_eq_zero _).mpr
+  intro b hb
+  have hn : ‖b‖ = 0 := by
+    have he := congrArg norm hb
+    change ‖p.completionMap ((1 : A) ⊗ₜ[ℂ] b)‖ = ‖(0 : p.Completion)‖ at he
+    rw [p.completionMap_norm, NuclearUnitization.cstar_norm_tmul, norm_one,
+      one_mul, norm_zero] at he
+    exact he
+  exact norm_eq_zero.mp hn
+
+lemma tensorNorm_eval {A : Type*} [CStarAlgebra A]
+    (p : Pureness.CStarAlgebraNorm (A ⊗[ℂ] B)) (x : A ⊗[ℂ] B) :
+    tensorCommutingEval (tensorNormLeft p) (tensorNormRight p) x = p.completionMap x := by
+  induction x using TensorProduct.inductionOn with
+  | tmul a b =>
+    change p.completionMap (a ⊗ₜ[ℂ] 1) * p.completionMap (1 ⊗ₜ[ℂ] b) = _
+    rw [← map_mul]
+    simp only [Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul]
+  | add x y hx hy => simp only [map_add, hx, hy]
+
+lemma tensorNorm_fock_return_bound
+    (q : Pureness.CStarAlgebraNorm (OInfinity ⊗[ℂ] B)) (n : ℕ) (x : OInfinity ⊗[ℂ] B) :
+    q.toAlgebraNorm (oInfinityTensorApproximation n x) ≤
+      2 * ‖fockTensorMatrix n (n + 1) x‖ := by
+  rw [← q.completionMap_norm, ← tensorNorm_eval, ← representedFockReturn_approximation
+    _ _ (tensorNorm_commute q) (tensorNorm_support q)]
+  exact representedFockReturn_norm_le _ _ _ _ _ _
+
+lemma tensorNorm_polynomial_bound
+    (p q : Pureness.CStarAlgebraNorm (OInfinity ⊗[ℂ] B))
+    (l : List ((List (ℕ × Bool) →₀ ℂ) × B)) :
+    q.toAlgebraNorm (polynomialTensorSum l) ≤ 2 * p.toAlgebraNorm (polynomialTensorSum l) := by
+  obtain ⟨N, hN⟩ := exists_polynomialTensor_alphabet_bound l
+  have hb : ∀ᶠ n : ℕ in atTop,
+      q.toAlgebraNorm (oInfinityTensorApproximation n (polynomialTensorSum l)) ≤
+        2 * p.toAlgebraNorm (polynomialTensorSum l) := by
+    filter_upwards [eventually_ge_atTop N] with n hn
+    have hc := fockTensorMatrix_polynomial_norm_le (tensorNormLeft p) (tensorNormRight p)
+      (tensorNorm_commute p) (tensorNorm_support p) (tensorNormRight_injective p)
+      (m := n + 1) l (fun t ht w hw a ha => (hN t ht w hw a ha).trans_le hn)
+    rw [tensorNorm_eval, p.completionMap_norm] at hc
+    exact (tensorNorm_fock_return_bound q n _).trans (mul_le_mul_of_nonneg_left hc (by norm_num))
+  exact algebraNorm_le_of_approximation q.toAlgebraNorm (polynomialTensorSum l)
+    (fun n => oInfinityTensorApproximation n (polynomialTensorSum l))
+    (2 * p.toAlgebraNorm (polynomialTensorSum l))
+    (oInfinityTensorApproximation_error_tendsto q (polynomialTensorSum l)) hb
+
+lemma tensorNorm_uniform_bound
+    (p q : Pureness.CStarAlgebraNorm (OInfinity ⊗[ℂ] B)) (x : OInfinity ⊗[ℂ] B) :
+    q.toAlgebraNorm x ≤ 2 * p.toAlgebraNorm x := by
+  apply tensor_norm_bound_of_approximation p q x (by norm_num)
+  intro n
+  obtain ⟨l, hl⟩ := exists_tensorApproximation_polynomialSum n x
+  rw [hl]
+  exact tensorNorm_polynomial_bound p q l
+
+/-- The Fock approximation and unused-generator corners give uniqueness of every
+C*-norm on the algebraic tensor product with `OInfinity`. -/
+theorem oInfinity_isNuclear : Pureness.IsNuclear OInfinity := by
+  intro B _
+  constructor
+  intro p q
+  exact Pureness.CStarAlgebraNorm.eq_of_mutual_bound p q
+    ⟨2, tensorNorm_uniform_bound q p⟩ ⟨2, tensorNorm_uniform_bound p q⟩
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/ToeplitzCompression.lean

@@ -0,0 +1,157 @@
+import Mathlib
+
+namespace OAI
+
+/-! # Finite Toeplitz rows compressed by an almost central projection
+
+These are the quantitative estimates in the projection-splitting step for a
+finite row of canonical O∞ isometries. In addition to almost centrality, a
+coisometric compression needs small compression of the original vacuum
+projection. No projection with these properties is assumed to exist here.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E I : Type*} [CStarAlgebra E] [Fintype I] [DecidableEq I]
+
+/-- Compression in the ambient algebra, with relative unit `q`. -/
+def toeplitzRowCompression (q : E) (s : I → E) (i : I) : E := q * s i * q
+
+/-- The defect of the finite isometry row before compression. -/
+def toeplitzRowVacuum (s : I → E) : E := 1 - ∑ i, s i * star (s i)
+
+private lemma compression_projection_norm (q : E) (hq : q * q = q)
+    (hqs : star q = q) : ‖q‖ ≤ 1 :=
+  IsStarProjection.norm_le q (isStarProjection_iff'.mpr ⟨hq, hqs⟩)
+
+private lemma compression_contract_mul_left (q x : E) (hq : ‖q‖ ≤ 1) :
+    ‖q * x‖ ≤ ‖x‖ :=
+  (norm_mul_le q x).trans (mul_le_of_le_one_left (norm_nonneg x) hq)
+
+private lemma compression_contract_mul_right (q x : E) (hq : ‖q‖ ≤ 1) :
+    ‖x * q‖ ≤ ‖x‖ :=
+  (norm_mul_le x q).trans (mul_le_of_le_one_right (norm_nonneg x) hq)
+
+/-- The adjoint has the same commutator error. -/
+lemma toeplitz_star_commutator_norm (q x : E) (hqs : star q = q) :
+    ‖q * star x - star x * q‖ = ‖q * x - x * q‖ := by
+  have h : q * star x - star x * q = -star (q * x - x * q) := by
+    rw [star_sub, star_mul, star_mul, hqs]
+    abel
+  rw [h, norm_neg, norm_star]
+
+omit [Fintype I] in
+/-- Exact defect formula for the compressed Gram matrix. -/
+lemma toeplitzRowCompression_gram (q : E) (s : I → E)
+    (hq : q * q = q) (hqs : star q = q)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0) (i j : I) :
+    star (toeplitzRowCompression q s i) * toeplitzRowCompression q s j -
+        (if i = j then q else 0) =
+      q * star (s i) * (q * s j - s j * q) * q := by
+  have hij : q * (star (s i) * s j) * q = if i = j then q else 0 := by
+    rw [hs]
+    split_ifs
+    · simpa only [mul_one] using hq
+    · simp only [mul_zero, zero_mul]
+  rw [← hij]
+  simp only [toeplitzRowCompression, star_mul, hqs]
+  noncomm_ring
+  simp only [← mul_assoc q q, hq]
+
+omit [Fintype I] in
+/-- Every Gram entry is controlled by one generator commutator. -/
+lemma toeplitzRowCompression_gram_bound (q : E) (s : I → E)
+    (hq : q * q = q) (hqs : star q = q)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (hns : ∀ i, ‖s i‖ ≤ 1) (δ : ℝ)
+    (hcomm : ∀ i, ‖q * s i - s i * q‖ ≤ δ) (i j : I) :
+    ‖star (toeplitzRowCompression q s i) * toeplitzRowCompression q s j -
+        (if i = j then q else 0)‖ ≤ δ := by
+  rw [toeplitzRowCompression_gram q s hq hqs hs]
+  have hnq := compression_projection_norm q hq hqs
+  calc
+    _ ≤ ‖q * star (s i) * (q * s j - s j * q)‖ :=
+      compression_contract_mul_right _ _ hnq
+    _ ≤ ‖star (s i) * (q * s j - s j * q)‖ := by
+      rw [mul_assoc]
+      exact compression_contract_mul_left _ _ hnq
+    _ ≤ ‖q * s j - s j * q‖ :=
+      compression_contract_mul_left _ _ (by simpa only [norm_star] using hns i)
+    _ ≤ δ := hcomm j
+
+omit [DecidableEq I] in
+/-- The coisometry defect contains the compressed original vacuum explicitly. -/
+lemma toeplitzRowCompression_coisometry (q : E) (s : I → E)
+    (hq : q * q = q) (hqs : star q = q) :
+    (∑ i, toeplitzRowCompression q s i * star (toeplitzRowCompression q s i)) - q =
+      (∑ i, q * s i * (q * star (s i) - star (s i) * q) * q) -
+        q * toeplitzRowVacuum s * q := by
+  have hterm (i : I) :
+      toeplitzRowCompression q s i * star (toeplitzRowCompression q s i) =
+        q * s i * (q * star (s i) - star (s i) * q) * q +
+          q * (s i * star (s i)) * q := by
+    simp only [toeplitzRowCompression, star_mul, hqs]
+    noncomm_ring
+    simp only [← mul_assoc q q, hq]
+    abel
+  simp_rw [hterm]
+  rw [Finset.sum_add_distrib]
+  unfold toeplitzRowVacuum
+  rw [mul_sub, sub_mul, mul_one, hq, Finset.mul_sum, Finset.sum_mul]
+  abel
+
+omit [DecidableEq I] in
+/-- Approximate centrality and small vacuum compression give the finite
+coisometry estimate used before perturbing a Toeplitz row to a Cuntz row. -/
+lemma toeplitzRowCompression_coisometry_bound (q : E) (s : I → E)
+    (hq : q * q = q) (hqs : star q = q) (hns : ∀ i, ‖s i‖ ≤ 1)
+    (δ : ℝ) (hcomm : ∀ i, ‖q * s i - s i * q‖ ≤ δ) :
+    ‖(∑ i, toeplitzRowCompression q s i * star (toeplitzRowCompression q s i)) - q‖ ≤
+      (Fintype.card I : ℝ) * δ + ‖q * toeplitzRowVacuum s * q‖ := by
+  rw [toeplitzRowCompression_coisometry q s hq hqs]
+  apply (norm_sub_le _ _).trans
+  apply add_le_add _ le_rfl
+  calc
+    _ ≤ ∑ i, ‖q * s i * (q * star (s i) - star (s i) * q) * q‖ :=
+      norm_sum_le _ _
+    _ ≤ ∑ _i : I, δ := by
+      apply Finset.sum_le_sum
+      intro i _
+      calc
+        _ ≤ ‖q * s i * (q * star (s i) - star (s i) * q)‖ :=
+          compression_contract_mul_right _ _ (compression_projection_norm q hq hqs)
+        _ ≤ ‖s i * (q * star (s i) - star (s i) * q)‖ := by
+          rw [mul_assoc]
+          exact compression_contract_mul_left _ _ (compression_projection_norm q hq hqs)
+        _ ≤ ‖q * star (s i) - star (s i) * q‖ :=
+          compression_contract_mul_left _ _ (hns i)
+        _ = ‖q * s i - s i * q‖ := toeplitz_star_commutator_norm q (s i) hqs
+        _ ≤ δ := hcomm i
+    _ = (Fintype.card I : ℝ) * δ := by simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul]
+
+/-- The two relative compressions recover each generator up to twice its
+commutator error. No smallness is asserted for either complementary projection. -/
+lemma toeplitz_complementary_compression_bound (q x : E)
+    (hq : q * q = q) (hqs : star q = q) :
+    ‖q * x * q + (1 - q) * x * (1 - q) - x‖ ≤ 2 * ‖q * x - x * q‖ := by
+  have hnq := compression_projection_norm q hq hqs
+  have hnp : ‖1 - q‖ ≤ 1 := compression_projection_norm (1 - q)
+    (by noncomm_ring [hq]) (by rw [star_sub, star_one, hqs])
+  have he : q * x * q + (1 - q) * x * (1 - q) - x =
+      (q * x - x * q) * q - (q * x - x * q) * (1 - q) := by
+    noncomm_ring [hq]
+  rw [he]
+  calc
+    _ ≤ ‖(q * x - x * q) * q‖ + ‖(q * x - x * q) * (1 - q)‖ := norm_sub_le _ _
+    _ ≤ ‖q * x - x * q‖ + ‖q * x - x * q‖ :=
+      add_le_add (compression_contract_mul_right _ _ hnq) (compression_contract_mul_right _ _ hnp)
+    _ = 2 * ‖q * x - x * q‖ := by ring
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/TransportedBuffer.lean

@@ -0,0 +1,118 @@
+import OAI.Analysis.OInfinity.BufferAnchor
+import Mathlib.Algebra.Star.UnitaryStarAlgAut
+
+namespace OAI
+
+/-! # Transporting the explicit absorption anchor
+
+The canonical Fock split transports its corner by a connected unitary,
+but transports its complementary isometry by left multiplication.  This
+asymmetric transport still preserves connectedness of the absorption
+anchor: its anchor is conjugate to a value of the original rotation path.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+namespace BufferAbsorptionCorner
+
+/-- Corner coefficients are conjugated, whereas the complementary
+isometry is moved by left multiplication, as in the finite Fock split. -/
+def transported (D : BufferAbsorptionCorner E) (u : unitary E) : BufferAbsorptionCorner E := by
+  let F := Unitary.conjStarAlgAut ℂ E u
+  refine {
+    q := F D.q
+    w := (u : E) * D.w
+    a := F D.a
+    b := F D.b
+    projection := isStarProjection_iff'.mpr ⟨?_, ?_⟩
+    w_gram := ?_
+    w_range := ?_
+    w_orthogonal := ?_
+    a_gram := ?_
+    b_gram := ?_
+    orthogonal := ?_
+    ranges := ?_
+  }
+  · rw [← map_mul, D.projection.isIdempotentElem.eq]
+  · rw [← map_star, D.projection.isSelfAdjoint.star_eq]
+  · rw [star_mul]
+    calc
+      _ = star D.w * (star (u : E) * (u : E)) * D.w := by noncomm_ring
+      _ = 1 := by rw [Unitary.star_mul_self_of_mem u.property, mul_one, D.w_gram]
+  · calc
+      _ = (u : E) * (D.w * star D.w) * star (u : E) := by rw [star_mul]; noncomm_ring
+      _ = F (1 - D.q) := by rw [D.w_range]; rfl
+      _ = 1 - F D.q := by rw [map_sub, map_one]
+  · change ((u : E) * D.q * star (u : E)) * ((u : E) * D.w) = 0
+    calc
+      _ = (u : E) * D.q * (star (u : E) * (u : E)) * D.w := by noncomm_ring
+      _ = 0 := by rw [Unitary.star_mul_self_of_mem u.property, mul_one,
+        mul_assoc, D.w_orthogonal, mul_zero]
+  · rw [← map_star, ← map_mul, D.a_gram]
+  · rw [← map_star, ← map_mul, D.b_gram]
+  · rw [← map_star, ← map_mul, D.orthogonal, map_zero]
+  · rw [← map_star, ← map_star, ← map_mul, ← map_mul, ← map_add, D.ranges]
+
+lemma transported_q (D : BufferAbsorptionCorner E) (u : unitary E) :
+    (D.transported u).q = (u : E) * D.q * star (u : E) := rfl
+
+lemma transported_w (D : BufferAbsorptionCorner E) (u : unitary E) :
+    (D.transported u).w = (u : E) * D.w := rfl
+
+lemma transported_a (D : BufferAbsorptionCorner E) (u : unitary E) :
+    (D.transported u).a = (u : E) * D.a * star (u : E) := rfl
+
+lemma transported_b (D : BufferAbsorptionCorner E) (u : unitary E) :
+    (D.transported u).b = (u : E) * D.b * star (u : E) := rfl
+
+/-- Exact asymmetric transport identity for the anchor. -/
+lemma transported_anchor (D : BufferAbsorptionCorner E) (u : unitary E) :
+    (D.transported u).anchor = u * D.rotation u * star u := by
+  apply Subtype.ext
+  change star ((u : E) * D.a * star (u : E)) +
+      ((u : E) * D.w) * 1 *
+        (star ((u : E) * D.b * star (u : E)) +
+          (1 - (u : E) * D.q * star (u : E))) =
+    ((u : E) * (star D.a + D.w * (u : E) * (star D.b + (1 - D.q)))) * star (u : E)
+  simp only [star_mul, star_star, mul_one]
+  calc
+    _ = (u : E) * star D.a * star (u : E) +
+        (u : E) * D.w * (u : E) * star D.b * star (u : E) +
+        (u : E) * D.w - (u : E) * D.w * (u : E) * D.q * star (u : E) := by
+      noncomm_ring
+    _ = (u : E) * star D.a * star (u : E) +
+        (u : E) * D.w * (u : E) * star D.b * star (u : E) +
+        (u : E) * D.w * ((u : E) * star (u : E)) -
+        (u : E) * D.w * (u : E) * D.q * star (u : E) := by
+      rw [Unitary.mul_star_self_of_mem u.property, mul_one]
+    _ = _ := by noncomm_ring
+
+/-- The anchor remains connected for the actual transported Fock corner;
+no path in a corner stabilizer is inferred from an ambient endpoint. -/
+lemma transported_anchor_joined (D : BufferAbsorptionCorner E) (u : unitary E)
+    (hD : Joined (1 : unitary E) D.anchor) (hu : Joined (1 : unitary E) u) :
+    Joined (1 : unitary E) (D.transported u).anchor := by
+  have hrot : Joined (1 : unitary E) (D.rotation u) := by
+    have h := (hD.trans (D.absorption_joined_anchor u hu)).mul hu
+    have he : D.absorption u * u = D.rotation u := by
+      apply Subtype.ext
+      change ((D.rotation u : E) * star (u : E)) * (u : E) = (D.rotation u : E)
+      rw [mul_assoc, Unitary.star_mul_self_of_mem u.property, mul_one]
+    simpa only [one_mul, he] using h
+  have hus : Joined (1 : unitary E) (star u) := by
+    simpa only [star_one] using
+      hu.map (continuous_star : Continuous (star : unitary E → unitary E))
+  simpa only [one_mul, D.transported_anchor u] using (hu.mul hrot).mul hus
+
+end BufferAbsorptionCorner
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/VacuumBufferAbsorption.lean

@@ -0,0 +1,121 @@
+import OAI.Analysis.OInfinity.ProperBufferAbsorption
+import OAI.Analysis.OInfinity.FiniteRowCompletion
+
+namespace OAI
+
+/-! # Absorption with a canonical vacuum spare
+
+A second unused source isometry is orthogonal to every word in the finite
+Fock sum. It therefore completes that sum to a connected ambient unitary
+without requiring the target corner to commute with the source row. The
+commutation requirements on the tested target entries remain explicit.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E I : Type*} [CStarAlgebra E] [Fintype I] [DecidableEq I]
+
+/-- The second source spare replaces source-corner commutation in the
+connected Fock completion. Only the selected target entries must commute
+with the fixed binary coefficients. -/
+lemma BufferAbsorptionCorner.exists_vacuum_absorption_on [Nontrivial E]
+    (D : BufferAbsorptionCorner E) (s t : I → E) (r z : E) (P : I → Prop)
+    (hrr : star r * r = 1) (hr : ∀ i, star r * s i = 0)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (hzz : star z * z = 1) (hqz : D.q * z = 0)
+    (hzr : star z * r = 0) (hzs : ∀ i, star z * s i = 0)
+    (htq : ∀ i, t i * D.q = t i) (ht : ∑ i, t i * star (t i) = D.q)
+    (htt : ∀ i j, star (t i) * t j = if i = j then D.q else 0)
+    (hat : ∀ i, P i → Commute (star D.a) (t i))
+    (hbt : ∀ i, P i → Commute (star D.b) (t i))
+    (ε : ℝ) (hε : 0 < ε) :
+    ∃ W : unitary E, Joined D.anchor W ∧
+      ∀ i, P i → ‖(W : E) * s i - (t i + D.w * s i * star D.w) * (W : E)‖ < ε := by
+  let δ := ε / 6
+  have hδ : 0 < δ := by dsimp only [δ]; positivity
+  obtain ⟨m, hm⟩ := exists_nat_gt (2 / δ ^ 2)
+  have hsmall : 2 / ((m : ℝ) + 1) < δ ^ 2 := by
+    have hδsq : 0 < δ ^ 2 := sq_pos_of_pos hδ
+    have hm' : 2 < (m : ℝ) * δ ^ 2 := (div_lt_iff₀ hδsq).mp hm
+    apply (div_lt_iff₀ (by positivity : 0 < (m : ℝ) + 1)).mpr
+    nlinarith
+  let v := finiteRowIsometry s t r D.q m
+  have hvg : star v * v = D.q := finiteRowIsometry_gram s t r D.q
+    D.projection.isIdempotentElem.eq D.projection.isSelfAdjoint.star_eq hrr hr hs htq ht m
+  have hvq : v * D.q = v := relativeIsometry_mul_support v D.q hvg
+    D.projection.isSelfAdjoint.star_eq D.projection.isIdempotentElem.eq
+  have hvz : star v * z = 0 := by
+    simpa only [star_mul, star_star, star_zero] using congrArg star
+      (finiteRowIsometry_unused s t r D.q z hzr hzs m)
+  obtain ⟨u, hu, _, huv⟩ := exists_explicit_connected_unitary_extension v z
+    (by rw [mul_assoc, hvg, hvq]) hzz (by rw [hvg]; exact hqz)
+    (by rw [mul_assoc, hvz, mul_zero])
+  have huq : (u : E) * D.q = v := by simpa only [hvg] using huv
+  have hvn : ‖v‖ ≤ 1 := finiteRowIsometry_norm_le s t r D.q
+    D.projection.isIdempotentElem.eq D.projection.isSelfAdjoint.star_eq hrr hr hs htq ht m
+  refine ⟨D.absorption u, D.absorption_joined_anchor u hu, ?_⟩
+  intro i hi
+  have hf : ‖s i * v - v * t i‖ < δ := by
+    have h := finiteRowIsometry_forward_norm_sq s t r D.q
+      D.projection.isIdempotentElem.eq D.projection.isSelfAdjoint.star_eq
+      hrr hr hs htq ht htt m i
+    change ‖s i * v - v * t i‖ ^ 2 ≤ _ at h
+    nlinarith [norm_nonneg (s i * v - v * t i)]
+  have hb : ‖star v * s i - t i * star v‖ < δ := by
+    have h := finiteRowIsometry_backward_norm_sq s t r D.q
+      D.projection.isIdempotentElem.eq D.projection.isSelfAdjoint.star_eq
+      hrr hr hs htq ht htt m i
+    have he : star v * s i - t i * star v =
+        star (star (s i) * v - v * star (t i)) := by
+      simp only [star_sub, star_mul, star_star]
+    rw [he, norm_star]
+    have hone : ((m : ℝ) + 1)⁻¹ ≤ 2 / ((m : ℝ) + 1) := by
+      rw [← one_div]
+      exact div_le_div_of_nonneg_right (by norm_num) (by positivity)
+    change ‖star (s i) * v - v * star (t i)‖ ^ 2 ≤ _ at h
+    nlinarith [norm_nonneg (star (s i) * v - v * star (t i))]
+  calc
+    _ ≤ 2 * ‖s i * v - v * t i‖ + 3 * ‖star v * s i - t i * star v‖ :=
+      D.absorption_error_bound u v (s i) (t i) huq (htq i) (hat i hi) (hbt i hi) hvn
+    _ < ε := by dsimp only [δ] at hf hb; linarith
+
+
+/-- Canonical source rows supply both required spare isometries. The
+only geometric condition on the target corner is its annihilation of the
+second unused generator, as provided by the canonical vacuum split. -/
+lemma BufferAbsorptionCorner.exists_canonical_vacuum_absorption [Nontrivial E]
+    (D : BufferAbsorptionCorner E) (s : ℕ → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (n : ℕ) (t : Fin n → E)
+    (hqz : D.q * s (n + 1) = 0)
+    (htq : ∀ i, t i * D.q = t i) (ht : ∑ i, t i * star (t i) = D.q)
+    (htt : ∀ i j, star (t i) * t j = if i = j then D.q else 0)
+    (hat : ∀ i, Commute (star D.a) (t i))
+    (hbt : ∀ i, Commute (star D.b) (t i))
+    (ε : ℝ) (hε : 0 < ε) :
+    ∃ W : unitary E, Joined D.anchor W ∧
+      ∀ i : Fin n,
+        ‖(W : E) * s i - (t i + D.w * s i * star D.w) * (W : E)‖ < ε := by
+  have hsource (i j : Fin n) : star (s i) * s j = if i = j then 1 else 0 := by
+    simpa only [Fin.ext_iff] using hs i j
+  have hroot (i : Fin n) : star (s n) * s i = 0 := by
+    rw [hs, ite_eq_right (by omega)]
+  have hspare (i : Fin n) : star (s (n + 1)) * s i = 0 := by
+    rw [hs, ite_eq_right (by omega)]
+  obtain ⟨W, hW, hWi⟩ := D.exists_vacuum_absorption_on (fun i : Fin n => s i) t
+    (s n) (s (n + 1)) (fun _ => True)
+    (by simpa only [ite_true] using hs n n) hroot hsource
+    (by simpa only [ite_true] using hs (n + 1) (n + 1)) hqz
+    (by rw [hs, ite_eq_right (by omega)]) hspare htq ht htt
+    (fun i _ => hat i) (fun i _ => hbt i) ε hε
+  exact ⟨W, hW, fun i => hWi i True.intro⟩
+
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/VacuumCorner.lean

@@ -0,0 +1,282 @@
+import OAI.Analysis.OInfinity.FockRangeProjection
+
+namespace OAI
+
+/-! # Finite Fock coefficients from an unused Cuntz generator
+
+For words in the first `N` generators, the next generator has exactly the
+vacuum annihilation relations.  This realizes every finite Fock compression
+of such a word as a corner in the Cuntz algebra itself.
+-/
+
+noncomputable section
+open scoped CStarAlgebra InnerProductSpace
+
+namespace WeakPureInfiniteness
+
+local instance : SMulWithZero ℂ OInfinity :=
+  @MulActionWithZero.toSMulWithZero ℂ OInfinity _ _
+    (@Module.toMulActionWithZero ℂ OInfinity _ _ inferInstance)
+local instance : DistribSMul ℂ OInfinity :=
+  @DistribMulAction.toDistribSMul ℂ OInfinity _ _
+    (@Module.toDistribMulAction ℂ OInfinity _ _ inferInstance)
+
+def oInfinityVacuumWord (N : ℕ) : List (Fin N) → OInfinity
+  | [] => oInfinityIsometry N
+  | p :: w => oInfinityIsometry p * oInfinityVacuumWord N w
+
+lemma oInfinityVacuumWord_relations (N : ℕ) (v w : List (Fin N)) :
+    star (oInfinityVacuumWord N v) * oInfinityVacuumWord N w =
+      if v = w then 1 else 0 := by
+  induction v generalizing w with
+  | nil =>
+    cases w with
+    | nil => simp [oInfinityVacuumWord, oInfinityIsometry_relations]
+    | cons q w =>
+      simp only [oInfinityVacuumWord, (List.cons_ne_nil q w).symm, ite_false]
+      rw [← mul_assoc, oInfinityIsometry_relations,
+        ite_eq_right (ne_of_gt q.isLt), zero_mul]
+  | cons p v ih =>
+    cases w with
+    | nil =>
+      simp only [oInfinityVacuumWord, star_mul, List.cons_ne_nil, ite_false]
+      rw [mul_assoc, oInfinityIsometry_relations, ite_eq_right (ne_of_lt p.isLt), mul_zero]
+    | cons q w =>
+      change star (oInfinityIsometry p * oInfinityVacuumWord N v) *
+        (oInfinityIsometry q * oInfinityVacuumWord N w) = _
+      rw [star_mul]
+      calc
+        _ = star (oInfinityVacuumWord N v) *
+          (star (oInfinityIsometry p) * oInfinityIsometry q) * oInfinityVacuumWord N w := by
+            noncomm_ring
+        _ = _ := by
+          rw [oInfinityIsometry_relations]
+          by_cases hpq : p = q
+          · subst q
+            simp only [ite_true, mul_one, ih, List.cons.injEq, true_and]
+          · have hpq' : p.val ≠ q.val := fun h => hpq (Fin.ext h)
+            simp [hpq', hpq]
+
+def finiteAlphabetWord (N : ℕ) (z : List (Fin N × Bool)) : OInfinity :=
+  cuntzWord oInfinityIsometry (z.map fun p => (p.1.val, p.2))
+
+@[simp] lemma finiteAlphabetWord_nil (N : ℕ) : finiteAlphabetWord N [] = 1 := rfl
+
+@[simp] lemma finiteAlphabetWord_cons (N : ℕ) (p : Fin N) (b : Bool)
+    (z : List (Fin N × Bool)) :
+    finiteAlphabetWord N ((p, b) :: z) =
+      (if b then oInfinityIsometry p else star (oInfinityIsometry p)) * finiteAlphabetWord N z := rfl
+
+def finiteAlphabetPop {N : ℕ} (p : Fin N) : List (Fin N) → Option (List (Fin N))
+  | [] => none
+  | q :: w => if p = q then some w else none
+
+def finiteAlphabetRun (N : ℕ) : List (Fin N × Bool) → List (Fin N) → Option (List (Fin N))
+  | [], w => some w
+  | (p, true) :: z, w => (finiteAlphabetRun N z w).map (List.cons p)
+  | (p, false) :: z, w => (finiteAlphabetRun N z w).bind (finiteAlphabetPop p)
+
+def vacuumRunValue {N : ℕ} (v : Option (List (Fin N))) : OInfinity :=
+  v.elim 0 (oInfinityVacuumWord N)
+
+lemma oInfinityVacuumWord_annihilate {N : ℕ} (p : Fin N) (w : List (Fin N)) :
+    star (oInfinityIsometry p) * oInfinityVacuumWord N w =
+      vacuumRunValue (finiteAlphabetPop p w) := by
+  cases w with
+  | nil =>
+    simp only [oInfinityVacuumWord, oInfinityIsometry_relations,
+      ite_eq_right (ne_of_lt p.isLt), finiteAlphabetPop, vacuumRunValue, Option.elim_none]
+  | cons q w =>
+    rw [oInfinityVacuumWord, ← mul_assoc, oInfinityIsometry_relations]
+    by_cases hpq : p = q
+    · subst q
+      simp [finiteAlphabetPop, vacuumRunValue]
+    · have hpq' : p.val ≠ q.val := fun h => hpq (Fin.ext h)
+      simp [hpq', hpq, finiteAlphabetPop, vacuumRunValue]
+
+lemma finiteAlphabetWord_vacuum_action {N : ℕ} (z : List (Fin N × Bool))
+    (w : List (Fin N)) :
+    finiteAlphabetWord N z * oInfinityVacuumWord N w =
+      vacuumRunValue (finiteAlphabetRun N z w) := by
+  induction z with
+  | nil => simp [finiteAlphabetRun, vacuumRunValue]
+  | cons pb z ih =>
+    rcases pb with ⟨p, b⟩
+    cases b with
+    | false =>
+      change (star (oInfinityIsometry p) * finiteAlphabetWord N z) *
+        oInfinityVacuumWord N w = _
+      rw [mul_assoc, ih]
+      cases hrun : finiteAlphabetRun N z w with
+      | none => simp [finiteAlphabetRun, hrun, vacuumRunValue]
+      | some v =>
+        simpa only [finiteAlphabetRun, hrun, Option.bind_some, vacuumRunValue,
+          Option.elim_some] using oInfinityVacuumWord_annihilate p v
+    | true =>
+      change (oInfinityIsometry p * finiteAlphabetWord N z) *
+        oInfinityVacuumWord N w = _
+      rw [mul_assoc, ih]
+      cases hrun : finiteAlphabetRun N z w with
+      | none => simp [finiteAlphabetRun, hrun, vacuumRunValue]
+      | some v => simp [finiteAlphabetRun, hrun, vacuumRunValue, oInfinityVacuumWord]
+
+def finiteAlphabetBasis {N : ℕ} (w : List (Fin N)) : FockSpace :=
+  lp.single 2 (w.map Fin.val) 1
+
+def fockRunValue {N : ℕ} (v : Option (List (Fin N))) : FockSpace :=
+  v.elim 0 finiteAlphabetBasis
+
+lemma finiteAlphabetBasis_create {N : ℕ} (p : Fin N) (w : List (Fin N)) :
+    fockShift p (finiteAlphabetBasis w) = finiteAlphabetBasis (p :: w) := by
+  simp only [finiteAlphabetBasis, fockShift_single, List.map_cons]
+
+lemma finiteAlphabetBasis_annihilate {N : ℕ} (p : Fin N) (w : List (Fin N)) :
+    (fockShift p).toContinuousLinearMap.adjoint (finiteAlphabetBasis w) =
+      fockRunValue (finiteAlphabetPop p w) := by
+  cases w with
+  | nil => simp [finiteAlphabetBasis, fockShift_adjoint_single_nil, finiteAlphabetPop, fockRunValue]
+  | cons q w =>
+    simp only [finiteAlphabetBasis, List.map_cons, fockShift_adjoint_single_cons,
+      finiteAlphabetPop]
+    by_cases hpq : p = q
+    · subst q; simp [fockRunValue, finiteAlphabetBasis]
+    · have hpq' : p.val ≠ q.val := fun h => hpq (Fin.ext h)
+      simp [hpq', hpq, fockRunValue]
+
+lemma finiteAlphabetWord_fock_action {N : ℕ} (z : List (Fin N × Bool))
+    (w : List (Fin N)) :
+    fockOperatorRepresentation (finiteAlphabetWord N z) (finiteAlphabetBasis w) =
+      fockRunValue (finiteAlphabetRun N z w) := by
+  induction z with
+  | nil => simp [finiteAlphabetRun, fockRunValue]
+  | cons pb z ih =>
+    rcases pb with ⟨p, b⟩
+    cases b with
+    | false =>
+      change (fockOperatorRepresentation (star (oInfinityIsometry p) * finiteAlphabetWord N z))
+        (finiteAlphabetBasis w) = _
+      rw [map_mul, mul_apply_eq_comp, ih]
+      change (fockShift p).toContinuousLinearMap.adjoint (fockRunValue (finiteAlphabetRun N z w)) = _
+      cases hrun : finiteAlphabetRun N z w with
+      | none => simp [finiteAlphabetRun, hrun, fockRunValue]
+      | some v =>
+        simpa only [finiteAlphabetRun, hrun, Option.bind_some, fockRunValue,
+          Option.elim_some] using finiteAlphabetBasis_annihilate p v
+    | true =>
+      change (fockOperatorRepresentation (oInfinityIsometry p * finiteAlphabetWord N z))
+        (finiteAlphabetBasis w) = _
+      rw [map_mul, mul_apply_eq_comp, ih]
+      change fockShift p (fockRunValue (finiteAlphabetRun N z w)) = _
+      cases hrun : finiteAlphabetRun N z w with
+      | none => simp [finiteAlphabetRun, hrun, fockRunValue]
+      | some v =>
+        simpa only [finiteAlphabetRun, hrun, Option.map_some, fockRunValue,
+          Option.elim_some] using finiteAlphabetBasis_create p v
+
+lemma finiteAlphabetBasis_inner {N : ℕ} (v w : List (Fin N)) :
+    inner ℂ (finiteAlphabetBasis v) (finiteAlphabetBasis w) = if v = w then 1 else 0 := by
+  have he : v.map Fin.val = w.map Fin.val ↔ v = w :=
+    (List.map_injective_iff.mpr Fin.val_injective).eq_iff
+  simp [finiteAlphabetBasis, lp.inner_single_left, lp.single_apply, Pi.single_apply, he]
+
+lemma finiteAlphabetWord_coefficient {N : ℕ} (z : List (Fin N × Bool))
+    (v w : List (Fin N)) :
+    star (oInfinityVacuumWord N v) * finiteAlphabetWord N z * oInfinityVacuumWord N w =
+      (inner ℂ (finiteAlphabetBasis v)
+        (fockOperatorRepresentation (finiteAlphabetWord N z) (finiteAlphabetBasis w))) •
+          (1 : OInfinity) := by
+  rw [mul_assoc, finiteAlphabetWord_vacuum_action, finiteAlphabetWord_fock_action]
+  cases hrun : finiteAlphabetRun N z w with
+  | none => simp [vacuumRunValue, fockRunValue]
+  | some t =>
+    simp only [vacuumRunValue, fockRunValue, Option.elim_some,
+      oInfinityVacuumWord_relations, finiteAlphabetBasis_inner]
+    split_ifs <;> simp
+
+lemma oInfinityVacuumWord_ofFn (N k : ℕ) (w : Fin k → Fin N) :
+    oInfinityVacuumWord N (List.ofFn w) =
+      oInfinityPositiveWord N w * oInfinityIsometry N := by
+  induction k with
+  | zero => simp [oInfinityVacuumWord]
+  | succ k ih =>
+    rw [List.ofFn_succ]
+    change oInfinityIsometry (w 0) * oInfinityVacuumWord N (List.ofFn (Fin.tail w)) =
+      (oInfinityIsometry (w 0) * oInfinityPositiveWord N (Fin.tail w)) * oInfinityIsometry N
+    rw [ih, mul_assoc]
+
+def finiteVacuumCorner (N m : ℕ) (i : FiniteFockIndex N m) : OInfinity :=
+  finiteFockAlgebraWord i * oInfinityIsometry N
+
+lemma finiteVacuumCorner_relations (N m : ℕ) (i j : FiniteFockIndex N m) :
+    star (finiteVacuumCorner N m i) * finiteVacuumCorner N m j =
+      if i = j then 1 else 0 := by
+  have he : List.ofFn i.2 = List.ofFn j.2 ↔ i = j := by
+    constructor
+    · intro h
+      apply finiteFockWord_injective N m
+      have hh := congrArg (List.map Fin.val) h
+      simpa only [List.map_ofFn, Function.comp_def, finiteFockWord] using hh
+    · rintro rfl; rfl
+  change star (oInfinityPositiveWord N i.2 * oInfinityIsometry N) *
+    (oInfinityPositiveWord N j.2 * oInfinityIsometry N) = _
+  rw [← oInfinityVacuumWord_ofFn, ← oInfinityVacuumWord_ofFn, oInfinityVacuumWord_relations]
+  simp only [he]
+
+lemma finiteVacuumCorner_compression {N m : ℕ} (z : List (Fin N × Bool))
+    (i j : FiniteFockIndex N m) :
+    star (finiteVacuumCorner N m i) * finiteAlphabetWord N z * finiteVacuumCorner N m j =
+      oInfinityFockCompression N m (finiteAlphabetWord N z) i j • (1 : OInfinity) := by
+  have hi : finiteVacuumCorner N m i = oInfinityVacuumWord N (List.ofFn i.2) :=
+    (oInfinityVacuumWord_ofFn N i.1.val i.2).symm
+  have hj : finiteVacuumCorner N m j = oInfinityVacuumWord N (List.ofFn j.2) :=
+    (oInfinityVacuumWord_ofFn N j.1.val j.2).symm
+  rw [hi, hj, finiteAlphabetWord_coefficient, oInfinityFockCompression_apply]
+  simp only [finiteAlphabetBasis, finiteFockVector, finiteFockWord, List.map_ofFn, Function.comp_def]
+
+lemma exists_finiteAlphabet_lift {N : ℕ} (w : List (ℕ × Bool))
+    (hw : ∀ p ∈ w, p.1 < N) :
+    ∃ z : List (Fin N × Bool), z.map (fun p => (p.1.val, p.2)) = w := by
+  induction w with
+  | nil => exact ⟨[], rfl⟩
+  | cons p w ih =>
+    obtain ⟨z, hz⟩ := ih (fun q hq => hw q (List.mem_cons_of_mem _ hq))
+    refine ⟨(⟨p.1, hw p (List.mem_cons_self ..)⟩, p.2) :: z, ?_⟩
+    simp only [List.map_cons, hz, Prod.mk.eta]
+
+lemma finiteVacuumCorner_cuntzWord {N m : ℕ} (w : List (ℕ × Bool))
+    (hw : ∀ p ∈ w, p.1 < N) (i j : FiniteFockIndex N m) :
+    star (finiteVacuumCorner N m i) * cuntzWord oInfinityIsometry w * finiteVacuumCorner N m j =
+      oInfinityFockCompression N m (cuntzWord oInfinityIsometry w) i j • (1 : OInfinity) := by
+  obtain ⟨z, rfl⟩ := exists_finiteAlphabet_lift w hw
+  exact finiteVacuumCorner_compression z i j
+
+lemma finiteVacuumCorner_polynomial {N m : ℕ} (c : List (ℕ × Bool) →₀ ℂ)
+    (hc : ∀ w ∈ c.support, ∀ p ∈ w, p.1 < N) (i j : FiniteFockIndex N m) :
+    star (finiteVacuumCorner N m i) * cuntzPolynomial oInfinityIsometry c *
+      finiteVacuumCorner N m j =
+    oInfinityFockCompression N m (cuntzPolynomial oInfinityIsometry c) i j • (1 : OInfinity) := by
+  have hentry (f : List (ℕ × Bool) → CStarMatrix (FiniteFockIndex N m) (FiniteFockIndex N m) ℂ) :
+      (∑ w ∈ c.support, f w) i j = ∑ w ∈ c.support, f w i j :=
+    map_sum (matrixEntryLinear i j) f c.support
+  simp only [cuntzPolynomial, Finsupp.sum, Finset.mul_sum, Finset.sum_mul,
+    mul_smul_comm, smul_mul_assoc, map_sum, map_smul, hentry,
+    CStarMatrix.smul_apply, Finset.sum_smul]
+  apply Finset.sum_congr rfl
+  intro w hw
+  rw [finiteVacuumCorner_cuntzWord w (hc w hw), smul_smul, smul_eq_mul]
+
+lemma exists_polynomial_alphabet_bound (c : List (ℕ × Bool) →₀ ℂ) :
+    ∃ N : ℕ, ∀ w ∈ c.support, ∀ p ∈ w, p.1 < N := by
+  let s := c.support.biUnion (fun w => w.toFinset.image Prod.fst)
+  refine ⟨s.sup id + 1, ?_⟩
+  intro w hw p hp
+  apply Nat.lt_succ_of_le
+  apply Finset.le_sup (f := id)
+  exact Finset.mem_biUnion.mpr ⟨w, hw,
+    Finset.mem_image.mpr ⟨p, List.mem_toFinset.mpr hp, rfl⟩⟩
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/VacuumSplit.lean

@@ -0,0 +1,271 @@
+import OAI.Analysis.OInfinity.FiniteRowCompletion
+
+namespace OAI
+
+/-! # A concrete almost central split of a canonical finite O∞ row
+
+The corner and its coisometric row are constructed from unused canonical
+isometries and the finite word sum. Its complement is the range of an actual
+isometry. Thus the vacuum compression and the complement are both controlled
+without assuming a projection-classification theorem.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+private lemma transported_row {J : Type*} [Fintype J] [DecidableEq J]
+    (v q : E) (t : J → E) (hv : star v * v = q) (hvq : v * q = v)
+    (htl : ∀ i, q * t i = t i) (htr : ∀ i, t i * q = t i)
+    (htt : ∀ i j, star (t i) * t j = if i = j then q else 0)
+    (ht : ∑ i, t i * star (t i) = q) :
+    (∀ i j, star (v * t i * star v) * (v * t j * star v) =
+      if i = j then v * star v else 0) ∧
+    (∑ i, (v * t i * star v) * star (v * t i * star v)) = v * star v := by
+  constructor
+  · intro i j
+    calc
+      _ = v * star (t i) * (star v * v) * t j * star v := by
+        simp only [star_mul, star_star]
+        noncomm_ring
+      _ = v * (star (t i) * t j) * star v := by rw [hv, mul_assoc (v * star (t i)), htl]; noncomm_ring
+      _ = _ := by rw [htt]; split_ifs <;> simp only [hvq, mul_zero, zero_mul]
+  · have he (i : J) : (v * t i * star v) * star (v * t i * star v) =
+        v * (t i * star (t i)) * star v := by
+      simp only [star_mul, star_star]
+      calc
+        _ = v * (t i * q) * star (t i) * star v := by
+          rw [← hv]; noncomm_ring
+        _ = _ := by rw [htr]; noncomm_ring
+    simp only [he, ← Finset.mul_sum, ← Finset.sum_mul, ht, hvq]
+
+private lemma transported_zeroCornerRow (q a b v : E)
+    (hqq : q * q = q) (hqa : q * a = a) (hqb : q * b = b) (hbq : b * q = b)
+    (hvg : star v * v = q) (hvq : v * q = v) :
+    ∀ n i, v * zeroCornerRow q a b n i * star v =
+      zeroCornerRow (v * star v) (v * a * star v) (v * b * star v) n i := by
+  intro n
+  induction n with
+  | zero => intro i; change v * q * star v = v * star v; rw [hvq]
+  | succ n ih =>
+    intro i
+    refine Fin.cases rfl (fun j => ?_) i
+    change v * (a * zeroCornerRow q a b n j) * star v =
+      (v * a * star v) * zeroCornerRow (v * star v) (v * a * star v) (v * b * star v) n j
+    rw [← ih j]
+    calc
+      _ = v * a * (q * zeroCornerRow q a b n j) * star v := by
+        rw [(zeroCornerRow_support q a b hqq hqa hqb hbq n j).1]
+        noncomm_ring
+      _ = _ := by rw [← hvg]; noncomm_ring
+
+/-- The explicit finite split, retaining its transported binary generators. -/
+lemma exists_canonical_vacuum_split_with_pair_and_isometry [Nontrivial E] (s : ℕ → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (n : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ (f w : E) (g : Fin (n + 1) → E),
+      f ≠ 0 ∧ star f = f ∧ f * f = f ∧
+      star w * w = 1 ∧ w * star w = 1 - f ∧
+      (∀ i j, star (g i) * g j = if i = j then f else 0) ∧
+      (∑ i, g i * star (g i)) = f ∧
+      (∀ i : Fin (n + 1), ‖s i * f - f * s i‖ < ε) ∧
+      (∀ i : Fin (n + 1), ‖f * s i * f - g i‖ < ε) ∧
+      ‖f * (1 - ∑ i : Fin (n + 1), s i * star (s i)) * f‖ < ε ∧
+      f * s (n + 2) = 0 ∧
+      ∃ A B : E, star A * A = f ∧ star B * B = f ∧ star A * B = 0 ∧
+        A * star A + B * star B = f ∧
+        (∀ i, g i = zeroCornerRow f A B n i) ∧
+        ∃ z : E, star z * z = 1 ∧ f * z = z := by
+  let z := s (n + 2)
+  let r := s (n + 1)
+  let q := 1 - z * star z
+  have hz : star z * z = 1 := by simpa only [z, ite_true] using hs (n + 2) (n + 2)
+  have hrr : star r * r = 1 := by simpa only [r, ite_true] using hs (n + 1) (n + 1)
+  have hqstar : star q = q := by simp only [q, star_sub, star_one, star_mul, star_star]
+  have hqq : q * q = q := by
+    have hzz : (z * star z) * (z * star z) = z * star z := by
+      calc
+        _ = z * (star z * z) * star z := by noncomm_ring
+        _ = _ := by rw [hz, mul_one]
+    dsimp only [q]
+    noncomm_ring [hzz]
+  have hz₁ : star z * s (n + 3) = 0 := by simp only [z, hs, show n + 2 ≠ n + 3 by omega, ite_false]
+  have hz₂ : star z * s (n + 4) = 0 := by simp only [z, hs, show n + 2 ≠ n + 4 by omega, ite_false]
+  have h₁₂ : star (s (n + 3)) * s (n + 4) = 0 := by simp only [hs, show n + 3 ≠ n + 4 by omega, ite_false]
+  obtain ⟨a, b, u₀, _hu₀, _ha, _hb, _hu₀eq, haa, hbb, hab, habsum⟩ :=
+    exists_zero_corner_cuntz_pair z (s (n + 3)) (s (n + 4)) hz
+      (by simpa using hs (n + 3) (n + 3)) (by simpa using hs (n + 4) (n + 4))
+      hz₁ hz₂ h₁₂
+  change star a * a = q at haa
+  change star b * b = q at hbb
+  change a * star a + b * star b = q at habsum
+  obtain ⟨hqa, haq, hqb, hbq⟩ := relativeCuntzPair_support q a b hqstar hqq haa hbb hab habsum
+  let t := zeroCornerRow q a b n
+  have htl (i : Fin (n + 1)) : q * t i = t i := (zeroCornerRow_support q a b hqq hqa hqb hbq n i).1
+  have htr (i : Fin (n + 1)) : t i * q = t i := (zeroCornerRow_support q a b hqq hqa hqb hbq n i).2
+  have htt : ∀ i j, star (t i) * t j = if i = j then q else 0 :=
+    zeroCornerRow_gram q a b hqstar hqq haa hbb hab hqa hqb hbq n
+  have ht : ∑ i, t i * star (t i) = q := zeroCornerRow_range_sum q a b hqstar hqq haq habsum n
+  let s' (i : Fin (n + 1)) := s i
+  have hs' (i j : Fin (n + 1)) : star (s' i) * s' j = if i = j then 1 else 0 := by
+    simpa only [s', Fin.ext_iff] using hs i j
+  have hri (i : Fin (n + 1)) : star r * s' i = 0 := by
+    change star (s (n + 1)) * s i = 0
+    rw [hs, ite_eq_right (by omega)]
+  have hzi (i : Fin (n + 1)) : star z * s' i = 0 := by
+    change star (s (n + 2)) * s i = 0
+    rw [hs, ite_eq_right (by omega)]
+  have hzr : star z * r = 0 := by simp only [z, r, hs, show n + 2 ≠ n + 1 by omega, ite_false]
+  obtain ⟨m, hm⟩ := exists_nat_one_div_lt (show (0 : ℝ) < min ε ((ε / 4) ^ 2) by positivity)
+  have hmε : ((m : ℝ) + 1)⁻¹ < ε := by simpa only [one_div] using hm.trans_le (min_le_left _ _)
+  have hmSq : ((m : ℝ) + 1)⁻¹ < (ε / 4) ^ 2 := by simpa only [one_div] using hm.trans_le (min_le_right _ _)
+  let v := finiteRowIsometry s' t r q m
+  let f := finiteRowRange s' t r q m
+  have hvg : star v * v = q := finiteRowIsometry_gram s' t r q hqq hqstar hrr hri hs' htr ht m
+  have hvq : v * q = v := relativeIsometry_mul_support v q hvg hqstar hqq
+  have hfv : f * v = v := by change (v * star v) * v = v; rw [mul_assoc, hvg, hvq]
+  obtain ⟨u, _hu, _hueq, _huq, huw, hwrange⟩ :=
+    exists_connected_finiteRowCompletion s' t r q z hqq hqstar hrr hri hs' htr ht hz hzr hzi rfl m
+  let g (i : Fin (n + 1)) := v * t i * star v
+  have hg := transported_row v q t hvg hvq htl htr htt ht
+  have hqne : q ≠ 0 := by
+    intro hq0
+    have hqa₁ : q * s (n + 3) = s (n + 3) := by
+      dsimp only [q]
+      rw [sub_mul, one_mul, mul_assoc, hz₁, mul_zero, sub_zero]
+    rw [hq0, zero_mul] at hqa₁
+    have hx := hs (n + 3) (n + 3)
+    rw [← hqa₁, star_zero, zero_mul, ite_eq_left rfl] at hx
+    exact zero_ne_one hx
+  refine ⟨f, (u : E) * z, g, ?_, finiteRowRange_star s' t r q m,
+    finiteRowRange_sq s' t r q hqq hqstar hrr hri hs' htr ht m, huw, hwrange,
+    hg.1, hg.2, ?_, ?_, ?_, ?_⟩
+  · intro hf
+    have hv0 : v = 0 := by rw [← hfv, hf, zero_mul]
+    have hq0 : q = 0 := by rw [← hvg, hv0, star_zero, zero_mul]
+    exact hqne hq0
+  · intro i
+    have hbound := finiteRowRange_commutator_bound s' t r q hqq hqstar hrr hri hs' htr ht htt m i
+    have hsqrt₁ := Real.sq_sqrt (show 0 ≤ ((m : ℝ) + 1)⁻¹ by positivity)
+    have hsqrt₂ := Real.sq_sqrt (show 0 ≤ 2 / ((m : ℝ) + 1) by positivity)
+    have hc : 2 / ((m : ℝ) + 1) = 2 * ((m : ℝ) + 1)⁻¹ := by rw [div_eq_mul_inv]
+    have h₁ : Real.sqrt (((m : ℝ) + 1)⁻¹) < ε / 4 := by nlinarith [Real.sqrt_nonneg (((m : ℝ) + 1)⁻¹)]
+    have h₂ : Real.sqrt (2 / ((m : ℝ) + 1)) < ε / 2 := by
+      have hsqrt₂' := hsqrt₂.trans hc
+      nlinarith [Real.sqrt_nonneg (2 / ((m : ℝ) + 1))]
+    exact hbound.trans_lt (by linarith)
+  · intro i
+    have hcomp : f * s i * f = (((m : ℝ) / ((m : ℝ) + 1) : ℝ) : ℂ) • g i := by
+      calc
+        _ = v * (star v * s' i * v) * star v := by change (v * star v) * s' i * (v * star v) = _; noncomm_ring
+        _ = _ := by
+          rw [finiteRowIsometry_compression s' t r q hqq hqstar hrr hri hs' htr ht m i,
+            mul_smul_comm, smul_mul_assoc]
+    have hgn : ‖g i‖ ≤ 1 := by
+      have he := congrArg norm (hg.1 i i)
+      simp only [ite_true, CStarRing.norm_star_mul_self] at he
+      change ‖g i‖ * ‖g i‖ = ‖f‖ at he
+      have hfn : ‖f‖ ≤ 1 := IsStarProjection.norm_le _ (isStarProjection_iff'.mpr
+        ⟨finiteRowRange_sq s' t r q hqq hqstar hrr hri hs' htr ht m, finiteRowRange_star s' t r q m⟩)
+      nlinarith [norm_nonneg (g i)]
+    have he : f * s i * f - g i = -(((((m : ℝ) + 1)⁻¹ : ℝ) : ℂ) • g i) := by
+      rw [hcomp]
+      have hc : ((m : ℝ) / ((m : ℝ) + 1)) - 1 = -((m : ℝ) + 1)⁻¹ := by
+        have hn : (m : ℝ) + 1 ≠ 0 := by positivity
+        field_simp
+        ring
+      calc
+        _ = (((m : ℝ) / ((m : ℝ) + 1) - 1 : ℝ) : ℂ) • g i := by push_cast; module
+        _ = _ := by rw [hc, Complex.ofReal_neg, neg_smul]
+    rw [he, norm_neg, norm_smul, Complex.norm_real, Real.norm_eq_abs,
+      abs_of_nonneg (by positivity : 0 ≤ ((m : ℝ) + 1)⁻¹)]
+    exact (mul_le_of_le_one_right (by positivity) hgn).trans_lt hmε
+  · exact (finiteRowRange_vacuum_norm s' t r q hqq hqstar hrr hri hs' htr ht m).trans_lt hmε
+  · refine ⟨finiteRowRange_unused s' t r q z hzr hzi m, ?_⟩
+    let pair : Fin 2 → E := ![a, b]
+    have hba : star b * a = 0 := by
+      simpa only [star_mul, star_star, star_zero] using congrArg star hab
+    have hpl (i : Fin 2) : q * pair i = pair i := by
+      fin_cases i
+      · exact hqa
+      · exact hqb
+    have hpr (i : Fin 2) : pair i * q = pair i := by
+      fin_cases i
+      · exact haq
+      · exact hbq
+    have hpg (i j : Fin 2) : star (pair i) * pair j = if i = j then q else 0 := by
+      fin_cases i <;> fin_cases j <;> simp [pair, haa, hbb, hab, hba]
+    have hps : ∑ i, pair i * star (pair i) = q := by
+      simpa only [Fin.sum_univ_two, pair, Matrix.cons_val_zero, Matrix.cons_val_one,
+        Matrix.cons_val_fin_one] using habsum
+    have hpair := transported_row v q pair hvg hvq hpl hpr hpg hps
+    have hvf : v * star v = f := rfl
+    refine ⟨v * a * star v, v * b * star v, ?_, ?_, ?_, ?_, ?_, ?_⟩
+    · simpa only [pair, Matrix.cons_val_zero, ite_true, hvf] using hpair.1 0 0
+    · simpa only [pair, Matrix.cons_val_one, Matrix.cons_val_fin_one, ite_true, hvf] using hpair.1 1 1
+    · simpa only [pair, Matrix.cons_val_zero, Matrix.cons_val_one,
+        Matrix.cons_val_fin_one, Fin.zero_ne_one, ite_false] using hpair.1 0 1
+    · simpa only [Fin.sum_univ_two, pair, Matrix.cons_val_zero, Matrix.cons_val_one,
+        Matrix.cons_val_fin_one, hvf] using hpair.2
+    · intro i
+      exact transported_zeroCornerRow q a b v hqq hqa hqb hbq hvg hvq n i
+    · have hqz : q * s (n + 3) = s (n + 3) := by
+        dsimp only [q]
+        rw [sub_mul, one_mul, mul_assoc, hz₁, mul_zero, sub_zero]
+      refine ⟨v * s (n + 3), ?_, ?_⟩
+      · rw [star_mul]
+        calc
+          _ = star (s (n + 3)) * (star v * v) * s (n + 3) := by noncomm_ring
+          _ = 1 := by
+            rw [hvg, mul_assoc, hqz]
+            simpa only [ite_true] using hs (n + 3) (n + 3)
+      · rw [← mul_assoc, hfv]
+
+/-- The explicit finite split, retaining its transported binary generators. -/
+lemma exists_canonical_vacuum_split_with_pair [Nontrivial E] (s : ℕ → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (n : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ (f w : E) (g : Fin (n + 1) → E),
+      f ≠ 0 ∧ star f = f ∧ f * f = f ∧
+      star w * w = 1 ∧ w * star w = 1 - f ∧
+      (∀ i j, star (g i) * g j = if i = j then f else 0) ∧
+      (∑ i, g i * star (g i)) = f ∧
+      (∀ i : Fin (n + 1), ‖s i * f - f * s i‖ < ε) ∧
+      (∀ i : Fin (n + 1), ‖f * s i * f - g i‖ < ε) ∧
+      ‖f * (1 - ∑ i : Fin (n + 1), s i * star (s i)) * f‖ < ε ∧
+      f * s (n + 2) = 0 ∧
+      ∃ A B : E, star A * A = f ∧ star B * B = f ∧ star A * B = 0 ∧
+        A * star A + B * star B = f ∧
+        ∀ i, g i = zeroCornerRow f A B n i := by
+  obtain ⟨f, w, g, hf, hfs, hff, hw, hwr, hg, hgs, hc, hfg, hfv, hfz,
+    A, B, hA, hB, hAB, hsum, he, _hz⟩ :=
+    exists_canonical_vacuum_split_with_pair_and_isometry s hs n ε hε
+  exact ⟨f, w, g, hf, hfs, hff, hw, hwr, hg, hgs, hc, hfg, hfv, hfz,
+    A, B, hA, hB, hAB, hsum, he⟩
+
+/-- Every finite canonical row admits the explicit vacuum-killing split.
+The returned row is coisometric in `f`, and an actual isometry fills `1-f`. -/
+lemma exists_canonical_vacuum_split [Nontrivial E] (s : ℕ → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (n : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ (f w : E) (g : Fin (n + 1) → E),
+      f ≠ 0 ∧ star f = f ∧ f * f = f ∧
+      star w * w = 1 ∧ w * star w = 1 - f ∧
+      (∀ i j, star (g i) * g j = if i = j then f else 0) ∧
+      (∑ i, g i * star (g i)) = f ∧
+      (∀ i : Fin (n + 1), ‖s i * f - f * s i‖ < ε) ∧
+      (∀ i : Fin (n + 1), ‖f * s i * f - g i‖ < ε) ∧
+      ‖f * (1 - ∑ i : Fin (n + 1), s i * star (s i)) * f‖ < ε ∧
+      f * s (n + 2) = 0 := by
+  obtain ⟨f, w, g, hf, hfs, hff, hw, hwr, hg, hgs, hc, hfg, hfv, hfz, _hp⟩ :=
+    exists_canonical_vacuum_split_with_pair s hs n ε hε
+  exact ⟨f, w, g, hf, hfs, hff, hw, hwr, hg, hgs, hc, hfg, hfv, hfz⟩
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/ZeroCorner.lean

@@ -0,0 +1,427 @@
+import OAI.Analysis.OInfinity.CentralIsometries
+
+namespace OAI
+
+/-! # An explicit coisometric pair in the complementary corner
+
+Three orthogonal isometries suffice to construct two relative isometries
+whose ranges add up to `1 - r₀ * star r₀`. The construction uses the checked
+two-swap completion, with its connected unitary retained explicitly. The
+unit of this pair is the stated corner projection, not the ambient unit.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+lemma partialIsometrySwap_commutes (a y : E)
+    (ha : Commute a y) (hastar : Commute (star a) y) :
+    Commute (partialIsometrySwap a) y := by
+  exact (ha.add_left hastar).add_left
+    (((Commute.one_left y).sub_left (hastar.mul_left ha)).sub_left (ha.mul_left hastar))
+
+lemma partialIsometryCompletion_commutes (r p v y : E)
+    (hr : Commute r y) (hrstar : Commute (star r) y)
+    (hp : Commute p y) (hpstar : Commute (star p) y)
+    (hv : Commute v y) (hvstar : Commute (star v) y) :
+    Commute (partialIsometryCompletion r p v) y := by
+  apply Commute.mul_left
+  · apply partialIsometrySwap_commutes
+    · exact hv.mul_left hrstar
+    · simpa only [star_mul, star_star] using hr.mul_left hvstar
+  · apply partialIsometrySwap_commutes
+    · exact hr.mul_left hp
+    · simpa only [star_mul] using hpstar.mul_left hrstar
+
+lemma exists_zero_corner_cuntz_pair [Nontrivial E] (r₀ r₁ r₂ : E)
+    (h₀ : star r₀ * r₀ = 1) (h₁ : star r₁ * r₁ = 1) (h₂ : star r₂ * r₂ = 1)
+    (h₀₁ : star r₀ * r₁ = 0) (h₀₂ : star r₀ * r₂ = 0) (h₁₂ : star r₁ * r₂ = 0) :
+    let q := 1 - r₀ * star r₀
+    ∃ (a b : E) (u : unitary E), Joined (1 : unitary E) u ∧
+      a = r₁ * q ∧ b = (u : E) * q ∧
+      (u : E) = partialIsometryCompletion r₂ (r₀ * star r₀)
+        (((r₀ * star r₀) + r₁ * q) * star r₀) ∧
+      star a * a = q ∧ star b * b = q ∧ star a * b = 0 ∧
+      a * star a + b * star b = q := by
+  intro q
+  let p := r₀ * star r₀
+  let a := r₁ * q
+  let z := p + a
+  let v := z * star r₀
+  have hpstar : star p = p := by simp only [p, star_mul, star_star]
+  have hpp : p * p = p := by
+    dsimp only [p]
+    rw [mul_assoc, ← mul_assoc (star r₀), h₀, one_mul]
+  have hqstar : star q = q := by change star (1 - p) = 1 - p; rw [star_sub, star_one, hpstar]
+  have hqq : q * q = q := by change (1 - p) * (1 - p) = 1 - p; noncomm_ring [hpp]
+  have hpq : p * q = 0 := by change p * (1 - p) = 0; noncomm_ring [hpp]
+  have hqp : q * p = 0 := by change (1 - p) * p = 0; noncomm_ring [hpp]
+  have hpr₁ : p * r₁ = 0 := by
+    change (r₀ * star r₀) * r₁ = 0
+    rw [mul_assoc, h₀₁, mul_zero]
+  have hr₁p : star r₁ * p = 0 := by
+    simpa only [star_mul, hpstar, star_zero] using congrArg star hpr₁
+  have hpa : p * a = 0 := by dsimp only [a]; rw [← mul_assoc, hpr₁, zero_mul]
+  have hasp : star a * p = 0 := by
+    simpa only [star_mul, hpstar, star_zero] using congrArg star hpa
+  have hqa : q * a = a := by change (1 - p) * a = a; rw [sub_mul, one_mul, hpa, sub_zero]
+  have haq : a * q = a := by dsimp only [a]; rw [mul_assoc, hqq]
+  have haas : star a * a = q := by
+    dsimp only [a]
+    rw [star_mul, hqstar]
+    calc
+      _ = q * (star r₁ * r₁) * q := by noncomm_ring
+      _ = q := by rw [h₁, mul_one, hqq]
+  have hziso : star z * z = 1 := by
+    change star (p + a) * (p + a) = 1
+    rw [star_add, hpstar, add_mul, mul_add, mul_add, hpp, hpa, hasp, haas]
+    change p + 0 + (0 + (1 - p)) = 1
+    noncomm_ring
+  have hztarget : z * star z = p + a * star a := by
+    change (p + a) * star (p + a) = p + a * star a
+    rw [star_add, hpstar]
+    have hap : a * p = 0 := by dsimp only [a]; rw [mul_assoc, hqp, mul_zero]
+    have hpas' : p * star a = 0 := by
+      simpa only [star_mul, hpstar, star_zero] using congrArg star hap
+    noncomm_ring [hpp, hap, hpas']
+  have hvsource : star v * v = p := by
+    change star (z * star r₀) * (z * star r₀) = p
+    rw [star_mul, star_star]
+    calc
+      _ = r₀ * (star z * z) * star r₀ := by noncomm_ring
+      _ = p := by rw [hziso, mul_one]
+  have hvtarget : v * star v = p + a * star a := by
+    change (z * star r₀) * star (z * star r₀) = _
+    rw [star_mul, star_star]
+    calc
+      _ = z * (star r₀ * r₀) * star z := by noncomm_ring
+      _ = _ := by rw [h₀, mul_one, hztarget]
+  have hvpartial : v * star v * v = v := by
+    change (z * star r₀) * star (z * star r₀) * (z * star r₀) = z * star r₀
+    rw [star_mul, star_star]
+    calc
+      _ = z * (star r₀ * r₀) * (star z * z) * star r₀ := by noncomm_ring
+      _ = _ := by rw [h₀, hziso, mul_one, mul_one]
+  have hpr₂ : p * r₂ = 0 := by
+    change (r₀ * star r₀) * r₂ = 0
+    rw [mul_assoc, h₀₂, mul_zero]
+  have hasr₂ : star a * r₂ = 0 := by
+    dsimp only [a]
+    rw [star_mul, mul_assoc, h₁₂, mul_zero]
+  have hvr₂ : (v * star v) * r₂ = 0 := by
+    rw [hvtarget, add_mul, hpr₂, mul_assoc, hasr₂, mul_zero, add_zero]
+  obtain ⟨u, hu, hueq, huvp⟩ := exists_explicit_connected_unitary_extension v r₂
+    hvpartial h₂ (by rw [hvsource]; exact hpr₂) hvr₂
+  have hup : (u : E) * p = v := by simpa only [hvsource] using huvp
+  have hupu : (u : E) * p * star (u : E) = p + a * star a := by
+    calc
+      _ = ((u : E) * p) * star ((u : E) * p) := by
+        rw [star_mul, hpstar]
+        symm
+        calc
+          _ = (u : E) * (p * p) * star (u : E) := by noncomm_ring
+          _ = _ := by rw [hpp]
+      _ = _ := by rw [hup, hvtarget]
+  let b := (u : E) * q
+  have hbsource : star b * b = q := by
+    dsimp only [b]
+    rw [star_mul, hqstar]
+    calc
+      _ = q * (star (u : E) * (u : E)) * q := by noncomm_ring
+      _ = q := by rw [Unitary.coe_star_mul_self, mul_one, hqq]
+  have hbtarget : b * star b = q - a * star a := by
+    dsimp only [b]
+    rw [star_mul, hqstar]
+    calc
+      _ = (u : E) * q * star (u : E) := by
+        calc
+          _ = (u : E) * (q * q) * star (u : E) := by noncomm_ring
+          _ = _ := by rw [hqq]
+      _ = 1 - (p + a * star a) := by
+        change (u : E) * (1 - p) * star (u : E) = _
+        rw [mul_sub, sub_mul, mul_one, Unitary.mul_star_self_of_mem u.property, hupu]
+      _ = _ := by change 1 - (p + a * star a) = (1 - p) - a * star a; abel
+  have hbq : b * q = b := by dsimp only [b]; rw [mul_assoc, hqq]
+  have hbpartial : b * star b * b = b := by rw [mul_assoc, hbsource, hbq]
+  have haapartial : (a * star a) * (a * star a) = a * star a := by
+    calc
+      _ = a * (star a * a) * star a := by noncomm_ring
+      _ = _ := by rw [haas, haq]
+  have haaq : (a * star a) * q = a * star a := by
+    have h := congrArg star hqa
+    simpa only [star_mul, hqstar, mul_assoc] using congrArg (fun y => a * y) h
+  have habproj : (a * star a) * (b * star b) = 0 := by
+    rw [hbtarget, mul_sub, haaq, haapartial, sub_self]
+  have haab : (a * star a) * b = 0 := by
+    rw [← hbpartial, ← mul_assoc, habproj, zero_mul]
+  have hab : star a * b = 0 := by
+    apply (CStarRing.star_mul_self_eq_zero_iff _).mp
+    rw [star_mul, star_star]
+    calc
+      _ = star b * ((a * star a) * b) := by noncomm_ring
+      _ = 0 := by rw [haab, mul_zero]
+  refine ⟨a, b, u, hu, rfl, rfl, ?_, haas, hbsource, hab, ?_⟩
+  · simpa only [hvsource] using hueq
+  · rw [hbtarget]
+    abel
+
+/-- The zero-corner completion is a fixed finite polynomial, so it retains
+exact commutation with every element commuting with the three input
+isometries and their adjoints. -/
+lemma zeroCornerCompletion_commutes (r₀ r₁ r₂ y : E)
+    (h₀ : Commute r₀ y) (h₀s : Commute (star r₀) y)
+    (h₁ : Commute r₁ y) (h₁s : Commute (star r₁) y)
+    (h₂ : Commute r₂ y) (h₂s : Commute (star r₂) y) :
+    Commute (partialIsometryCompletion r₂ (r₀ * star r₀)
+      (((r₀ * star r₀) + r₁ * (1 - r₀ * star r₀)) * star r₀)) y := by
+  have hp := h₀.mul_left h₀s
+  have hps : Commute (star (r₀ * star r₀)) y := by
+    simpa only [star_mul, star_star] using hp
+  have hq := (Commute.one_left y).sub_left hp
+  have hqs : Commute (star (1 - r₀ * star r₀)) y := by
+    simpa only [star_sub, star_one, star_mul, star_star] using hq
+  apply partialIsometryCompletion_commutes _ _ _ _ h₂ h₂s hp hps
+  · exact (hp.add_left (h₁.mul_left hq)).mul_left h₀s
+  · simpa only [star_mul, star_add, star_star] using
+      h₀.mul_left (hps.add_left (hqs.mul_left h₁s))
+
+private structure ZeroCornerControl (x a : E) (N C : ℝ) : Prop where
+  norm_bound : ‖a‖ ≤ N
+  bound : ‖a * x - x * a‖ ≤ C
+  star_bound : ‖star a * x - x * star a‖ ≤ C
+
+private lemma zeroCornerControl_one [Nontrivial E] (x : E) : ZeroCornerControl x 1 1 0 := by
+  constructor <;> simp
+
+private lemma zeroCornerControl_star {x a : E} {N C : ℝ}
+    (h : ZeroCornerControl x a N C) : ZeroCornerControl x (star a) N C := by
+  exact ⟨by simpa only [norm_star] using h.norm_bound, h.star_bound,
+    by simpa only [star_star] using h.bound⟩
+
+private lemma zeroCornerControl_add {x a b : E} {N M C D : ℝ}
+    (ha : ZeroCornerControl x a N C) (hb : ZeroCornerControl x b M D) :
+    ZeroCornerControl x (a + b) (N + M) (C + D) := by
+  constructor
+  · exact (norm_add_le _ _).trans (add_le_add ha.norm_bound hb.norm_bound)
+  · have he : (a + b) * x - x * (a + b) = (a * x - x * a) + (b * x - x * b) := by
+      noncomm_ring
+    rw [he]
+    exact (norm_add_le _ _).trans (add_le_add ha.bound hb.bound)
+  · have he : star (a + b) * x - x * star (a + b) =
+        (star a * x - x * star a) + (star b * x - x * star b) := by
+      rw [star_add]; noncomm_ring
+    rw [he]
+    exact (norm_add_le _ _).trans (add_le_add ha.star_bound hb.star_bound)
+
+private lemma zeroCornerControl_sub {x a b : E} {N M C D : ℝ}
+    (ha : ZeroCornerControl x a N C) (hb : ZeroCornerControl x b M D) :
+    ZeroCornerControl x (a - b) (N + M) (C + D) := by
+  constructor
+  · exact (norm_sub_le _ _).trans (add_le_add ha.norm_bound hb.norm_bound)
+  · have he : (a - b) * x - x * (a - b) = (a * x - x * a) - (b * x - x * b) := by
+      noncomm_ring
+    rw [he]
+    exact (norm_sub_le _ _).trans (add_le_add ha.bound hb.bound)
+  · have he : star (a - b) * x - x * star (a - b) =
+        (star a * x - x * star a) - (star b * x - x * star b) := by
+      rw [star_sub]; noncomm_ring
+    rw [he]
+    exact (norm_sub_le _ _).trans (add_le_add ha.star_bound hb.star_bound)
+
+private lemma zeroCornerControl_mul_bound {x a b : E} {N M C D : ℝ}
+    (haN : ‖a‖ ≤ N) (hbM : ‖b‖ ≤ M)
+    (ha : ‖a * x - x * a‖ ≤ C) (hb : ‖b * x - x * b‖ ≤ D) :
+    ‖(a * b) * x - x * (a * b)‖ ≤ N * D + C * M := by
+  have hC : 0 ≤ C := (norm_nonneg _).trans ha
+  have hD : 0 ≤ D := (norm_nonneg _).trans hb
+  have he : (a * b) * x - x * (a * b) =
+      a * (b * x - x * b) + (a * x - x * a) * b := by noncomm_ring
+  rw [he]
+  calc
+    _ ≤ ‖a * (b * x - x * b)‖ + ‖(a * x - x * a) * b‖ := norm_add_le _ _
+    _ ≤ ‖a‖ * ‖b * x - x * b‖ + ‖a * x - x * a‖ * ‖b‖ :=
+      add_le_add (norm_mul_le _ _) (norm_mul_le _ _)
+    _ ≤ N * D + C * M := add_le_add
+      (mul_le_mul haN hb (norm_nonneg _) ((norm_nonneg _).trans haN))
+      (mul_le_mul ha hbM (norm_nonneg _) hC)
+
+private lemma zeroCornerControl_mul {x a b : E} {N M C D : ℝ}
+    (ha : ZeroCornerControl x a N C) (hb : ZeroCornerControl x b M D) :
+    ZeroCornerControl x (a * b) (N * M) (N * D + C * M) := by
+  constructor
+  · exact (norm_mul_le _ _).trans
+      (mul_le_mul ha.norm_bound hb.norm_bound (norm_nonneg _) ((norm_nonneg _).trans ha.norm_bound))
+  · exact zeroCornerControl_mul_bound ha.norm_bound hb.norm_bound ha.bound hb.bound
+  · rw [star_mul]
+    have h := zeroCornerControl_mul_bound
+      (zeroCornerControl_star hb).norm_bound (zeroCornerControl_star ha).norm_bound
+      hb.star_bound ha.star_bound
+    convert h using 1; ring
+
+private lemma zeroCornerControl_swap [Nontrivial E] {x a : E} {N C : ℝ}
+    (ha : ZeroCornerControl x a N C) :
+    ZeroCornerControl x (partialIsometrySwap a)
+      (N + N + (1 + N * N + N * N))
+      (C + C + (0 + (N * C + C * N) + (N * C + C * N))) := by
+  exact zeroCornerControl_add (zeroCornerControl_add ha (zeroCornerControl_star ha))
+    (zeroCornerControl_sub (zeroCornerControl_sub (zeroCornerControl_one x)
+      (zeroCornerControl_mul (zeroCornerControl_star ha) ha))
+        (zeroCornerControl_mul ha (zeroCornerControl_star ha)))
+
+/-- A uniform polynomial estimate, valid before the Cuntz relations are used.
+The deliberately coarse constant keeps the input tolerance independent of
+the test element and of the ambient algebra. -/
+lemma zeroCornerCompletion_commutator_bound [Nontrivial E] (r₀ r₁ r₂ x : E) (δ : ℝ)
+    (hN : ∀ r ∈ ({r₀, r₁, r₂} : Set E), ‖r‖ ≤ 1)
+    (hC : ∀ r ∈ ({r₀, r₁, r₂} : Set E),
+      ‖r * x - x * r‖ ≤ δ ∧ ‖star r * x - x * star r‖ ≤ δ) :
+    let U := partialIsometryCompletion r₂ (r₀ * star r₀)
+      (((r₀ * star r₀) + r₁ * (1 - r₀ * star r₀)) * star r₀)
+    ‖U * x - x * U‖ ≤ 1290 * δ ∧ ‖star U * x - x * star U‖ ≤ 1290 * δ := by
+  have h₀ : ZeroCornerControl x r₀ 1 δ :=
+    ⟨hN r₀ (by simp), (hC r₀ (by simp)).1, (hC r₀ (by simp)).2⟩
+  have h₁ : ZeroCornerControl x r₁ 1 δ :=
+    ⟨hN r₁ (by simp), (hC r₁ (by simp)).1, (hC r₁ (by simp)).2⟩
+  have h₂ : ZeroCornerControl x r₂ 1 δ :=
+    ⟨hN r₂ (by simp), (hC r₂ (by simp)).1, (hC r₂ (by simp)).2⟩
+  have hp := zeroCornerControl_mul h₀ (zeroCornerControl_star h₀)
+  have hq := zeroCornerControl_sub (zeroCornerControl_one x) hp
+  have hz := zeroCornerControl_add hp (zeroCornerControl_mul h₁ hq)
+  have hv := zeroCornerControl_mul hz (zeroCornerControl_star h₀)
+  have hA := zeroCornerControl_swap (zeroCornerControl_mul hv (zeroCornerControl_star h₂))
+  have hB := zeroCornerControl_swap (zeroCornerControl_mul h₂ hp)
+  have hU := zeroCornerControl_mul hA hB
+  dsimp only [partialIsometryCompletion]
+  constructor
+  · convert hU.bound using 1; ring
+  · convert hU.star_bound using 1; ring
+
+lemma zeroCornerPair_commutator_bound [Nontrivial E] (r₀ r₁ r₂ x : E) (δ : ℝ) (hδ : 0 ≤ δ)
+    (hN : ∀ r ∈ ({r₀, r₁, r₂} : Set E), ‖r‖ ≤ 1)
+    (hC : ∀ r ∈ ({r₀, r₁, r₂} : Set E),
+      ‖r * x - x * r‖ ≤ δ ∧ ‖star r * x - x * star r‖ ≤ δ)
+    (u : unitary E)
+    (hu : (u : E) = partialIsometryCompletion r₂ (r₀ * star r₀)
+      (((r₀ * star r₀) + r₁ * (1 - r₀ * star r₀)) * star r₀)) :
+    let q := 1 - r₀ * star r₀
+    ‖(r₁ * q) * x - x * (r₁ * q)‖ ≤ 2582 * δ ∧
+      ‖((u : E) * q) * x - x * ((u : E) * q)‖ ≤ 2582 * δ := by
+  have h₀ : ZeroCornerControl x r₀ 1 δ :=
+    ⟨hN r₀ (by simp), (hC r₀ (by simp)).1, (hC r₀ (by simp)).2⟩
+  have h₁ : ZeroCornerControl x r₁ 1 δ :=
+    ⟨hN r₁ (by simp), (hC r₁ (by simp)).1, (hC r₁ (by simp)).2⟩
+  have hq := zeroCornerControl_sub (zeroCornerControl_one x)
+    (zeroCornerControl_mul h₀ (zeroCornerControl_star h₀))
+  have hubounds := zeroCornerCompletion_commutator_bound r₀ r₁ r₂ x δ hN hC
+  have hU : ZeroCornerControl x (u : E) 1 (1290 * δ) := by
+    refine ⟨(CStarRing.norm_coe_unitary u).le, ?_, ?_⟩
+    · simpa only [hu] using hubounds.1
+    · simpa only [hu] using hubounds.2
+  constructor
+  · have hb := (zeroCornerControl_mul h₁ hq).bound
+    nlinarith
+  · have hb := (zeroCornerControl_mul hU hq).bound
+    nlinarith
+
+private lemma zeroCorner_star_commutator_norm (a x : E) :
+    ‖star a * x - x * star a‖ = ‖a * star x - star x * a‖ := by
+  rw [← norm_star (a * star x - star x * a)]
+  simp only [star_sub, star_mul, star_star]
+  exact norm_sub_rev _ _
+
+/-- Global central rows produce a coisometric pair in their complementary
+corner with arbitrarily small finite-set commutators. The corner unit is
+kept explicit in the conclusion. -/
+lemma exists_approximately_central_zero_corner_pair [Nontrivial E] (s t : ℕ → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (hc : ∀ i j, Commute (s i) (t j) ∧ Commute (s i) (star (t j)))
+    (n : ℕ) (δ : ℝ) (hδ : 0 < δ) :
+    ∃ (q a b : E), q ≠ 0 ∧ star q = q ∧ q * q = q ∧
+      star a * a = q ∧ star b * b = q ∧ star a * b = 0 ∧
+      a * star a + b * star b = q ∧
+      (∀ i < n, ‖a * s i - s i * a‖ < δ ∧ ‖b * s i - s i * b‖ < δ ∧
+        ‖a * star (s i) - star (s i) * a‖ < δ ∧
+        ‖b * star (s i) - star (s i) * b‖ < δ) ∧
+      ∀ k, Commute a (t k) ∧ Commute b (t k) ∧
+        Commute a (star (t k)) ∧ Commute b (star (t k)) := by
+  let η := δ / 3000
+  have hη : 0 < η := by dsimp only [η]; positivity
+  obtain ⟨r, hr, hcomm, hother⟩ := exists_approximately_central_cuntz_row s t hs hc n η hη
+  have hiso (j : ℕ) : star (r j) * r j = 1 := by simpa using hr j j
+  have hnorm (j : ℕ) : ‖r j‖ = 1 := by
+    have h := congrArg norm (hiso j)
+    rw [CStarRing.norm_star_mul_self, norm_one] at h
+    nlinarith [norm_nonneg (r j)]
+  let q := 1 - r 0 * star (r 0)
+  obtain ⟨a, b, u, hujoin, ha, hb, hu, haa, hbb, hab, hsum⟩ :=
+    exists_zero_corner_cuntz_pair (r 0) (r 1) (r 2) (hiso 0) (hiso 1) (hiso 2)
+      (by simpa using hr 0 1) (by simpa using hr 0 2) (by simpa using hr 1 2)
+  have hqstar : star q = q := by simp only [q, star_sub, star_one, star_mul, star_star]
+  have hp : (r 0 * star (r 0)) * (r 0 * star (r 0)) = r 0 * star (r 0) := by
+    rw [mul_assoc, ← mul_assoc (star (r 0)), hiso, one_mul]
+  have hqq : q * q = q := by dsimp only [q]; noncomm_ring [hp]
+  have hqne : q ≠ 0 := by
+    intro hzero
+    have hqr : q * r 1 = r 1 := by
+      dsimp only [q]
+      rw [sub_mul, one_mul, mul_assoc, show star (r 0) * r 1 = 0 by simpa using hr 0 1,
+        mul_zero, sub_zero]
+    rw [hzero, zero_mul] at hqr
+    have hz := hiso 1
+    rw [← hqr, star_zero, zero_mul] at hz
+    exact zero_ne_one hz
+  have hN : ∀ z ∈ ({r 0, r 1, r 2} : Set E), ‖z‖ ≤ 1 := by
+    intro z hz
+    simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
+    rcases hz with rfl | rfl | rfl <;> exact (hnorm _).le
+  refine ⟨q, a, b, hqne, hqstar, hqq, haa, hbb, hab, hsum, ?_, ?_⟩
+  · intro i hi
+    have hC : ∀ z ∈ ({r 0, r 1, r 2} : Set E),
+        ‖z * s i - s i * z‖ ≤ η ∧ ‖star z * s i - s i * star z‖ ≤ η := by
+      intro z hz
+      have hz' (j : ℕ) : ‖r j * s i - s i * r j‖ ≤ η ∧
+          ‖star (r j) * s i - s i * star (r j)‖ ≤ η := by
+        exact ⟨(hcomm j i hi).1.le,
+          by rw [zeroCorner_star_commutator_norm]; exact (hcomm j i hi).2.le⟩
+      simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
+      rcases hz with rfl | rfl | rfl <;> exact hz' _
+    have hCs : ∀ z ∈ ({r 0, r 1, r 2} : Set E),
+        ‖z * star (s i) - star (s i) * z‖ ≤ η ∧
+        ‖star z * star (s i) - star (s i) * star z‖ ≤ η := by
+      intro z hz
+      have hz' (j : ℕ) : ‖r j * star (s i) - star (s i) * r j‖ ≤ η ∧
+          ‖star (r j) * star (s i) - star (s i) * star (r j)‖ ≤ η := by
+        exact ⟨(hcomm j i hi).2.le, by
+          rw [zeroCorner_star_commutator_norm, star_star]
+          exact (hcomm j i hi).1.le⟩
+      simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
+      rcases hz with rfl | rfl | rfl <;> exact hz' _
+    have hsmall : 2582 * η < δ := by dsimp only [η]; nlinarith
+    have h₁ := zeroCornerPair_commutator_bound (r 0) (r 1) (r 2) (s i) η hη.le hN hC u hu
+    have h₂ := zeroCornerPair_commutator_bound (r 0) (r 1) (r 2) (star (s i)) η hη.le hN hCs u hu
+    dsimp only at h₁ h₂
+    rw [← ha, ← hb] at h₁ h₂
+    exact ⟨h₁.1.trans_lt hsmall, h₁.2.trans_lt hsmall,
+      h₂.1.trans_lt hsmall, h₂.2.trans_lt hsmall⟩
+  · intro k
+    have hpoly (y : E) (hry : ∀ j, Commute (r j) y ∧ Commute (star (r j)) y) :
+        Commute a y ∧ Commute b y := by
+      have hqc := (Commute.one_left y).sub_left ((hry 0).1.mul_left (hry 0).2)
+      have huc : Commute (u : E) y := by
+        rw [hu]
+        exact zeroCornerCompletion_commutes _ _ _ _
+          (hry 0).1 (hry 0).2 (hry 1).1 (hry 1).2 (hry 2).1 (hry 2).2
+      exact ⟨by rw [ha]; exact (hry 1).1.mul_left hqc,
+        by rw [hb]; exact huc.mul_left hqc⟩
+    have h₁ := hpoly (t k) (fun j => ⟨(hother j k).1, (hother j k).2.star_left⟩)
+    have h₂ := hpoly (star (t k)) (fun j => ⟨(hother j k).2, (hother j k).1.star_star⟩)
+    exact ⟨h₁.1, h₁.2, h₂.1, h₂.2⟩
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/ZeroCornerRows.lean

@@ -0,0 +1,280 @@
+import OAI.Analysis.OInfinity.ZeroCorner
+
+namespace OAI
+
+/-! # Finite Cuntz rows in the explicit complementary corner
+
+Repeatedly splitting the first range of a relative Cuntz pair produces every
+finite row size. All ranges still sum to the same projection `q`; the
+complement `1 - q` is retained. The commutator estimate grows only linearly
+with the number of splittings.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+/-- Right support follows from the relative isometry equation. -/
+lemma relativeIsometry_mul_support (a q : E) (ha : star a * a = q)
+    (hqstar : star q = q) (hqq : q * q = q) : a * q = a := by
+  have hz : star (a * q - a) * (a * q - a) = 0 := by
+    rw [star_sub, star_mul, hqstar]
+    calc
+      _ = q * (star a * a) * q - q * (star a * a) - (star a * a) * q + star a * a := by
+        noncomm_ring
+      _ = 0 := by simp only [ha, hqq]; abel
+  exact sub_eq_zero.mp ((CStarRing.star_mul_self_eq_zero_iff _).mp hz)
+
+lemma relativeCuntzPair_support (q a b : E) (hqstar : star q = q) (hqq : q * q = q)
+    (ha : star a * a = q) (hb : star b * b = q) (hab : star a * b = 0)
+    (hsum : a * star a + b * star b = q) :
+    q * a = a ∧ a * q = a ∧ q * b = b ∧ b * q = b := by
+  have haq := relativeIsometry_mul_support a q ha hqstar hqq
+  have hbq := relativeIsometry_mul_support b q hb hqstar hqq
+  have hba : star b * a = 0 := by
+    simpa only [star_mul, star_star, star_zero] using congrArg star hab
+  refine ⟨?_, haq, ?_, hbq⟩
+  · rw [← hsum, add_mul, mul_assoc, ha, haq, mul_assoc, hba, mul_zero, add_zero]
+  · rw [← hsum, add_mul, mul_assoc, hab, mul_zero, zero_add, mul_assoc, hb, hbq]
+
+/-- At stage zero the row is the corner unit. Every successor replaces it
+by `b` followed by the old row multiplied on the left by `a`. -/
+def zeroCornerRow (q a b : E) : (n : ℕ) → Fin (n + 1) → E
+  | 0, _ => q
+  | n + 1, i => Fin.cases b (fun j => a * zeroCornerRow q a b n j) i
+
+lemma zeroCornerRow_support (q a b : E) (hqq : q * q = q)
+    (hqa : q * a = a) (hqb : q * b = b) (hbq : b * q = b) :
+    ∀ n i, q * zeroCornerRow q a b n i = zeroCornerRow q a b n i ∧
+      zeroCornerRow q a b n i * q = zeroCornerRow q a b n i := by
+  intro n
+  induction n with
+  | zero => intro i; exact ⟨hqq, hqq⟩
+  | succ n ih =>
+    intro i
+    refine Fin.cases ?_ (fun j => ?_) i
+    · exact ⟨hqb, hbq⟩
+    · change q * (a * zeroCornerRow q a b n j) = a * zeroCornerRow q a b n j ∧
+        (a * zeroCornerRow q a b n j) * q = a * zeroCornerRow q a b n j
+      exact ⟨by rw [← mul_assoc, hqa], by rw [mul_assoc, (ih j).2]⟩
+
+lemma zeroCornerRow_gram (q a b : E) (hqstar : star q = q) (hqq : q * q = q)
+    (ha : star a * a = q) (hb : star b * b = q) (hab : star a * b = 0)
+    (hqa : q * a = a) (hqb : q * b = b) (hbq : b * q = b) :
+    ∀ n i j, star (zeroCornerRow q a b n i) * zeroCornerRow q a b n j =
+      if i = j then q else 0 := by
+  have hba : star b * a = 0 := by
+    simpa only [star_mul, star_star, star_zero] using congrArg star hab
+  intro n
+  induction n with
+  | zero =>
+    intro i j
+    have hij : i = j := by omega
+    simp only [zeroCornerRow, hqstar, hqq, hij, ite_true]
+  | succ n ih =>
+    intro i j
+    refine Fin.cases ?_ (fun i => ?_) i
+    · refine Fin.cases ?_ (fun j => ?_) j
+      · simpa only [zeroCornerRow, Fin.cases_zero, ite_true] using hb
+      · simp only [zeroCornerRow, Fin.cases_zero, Fin.cases_succ, (Fin.succ_ne_zero j).symm,
+          ite_false, ← mul_assoc, hba, zero_mul]
+    · refine Fin.cases ?_ (fun j => ?_) j
+      · simp only [zeroCornerRow, Fin.cases_zero, Fin.cases_succ, Fin.succ_ne_zero,
+          ite_false, star_mul, mul_assoc, hab, mul_zero]
+      · simp only [zeroCornerRow, Fin.cases_succ, star_mul, Fin.succ_inj]
+        calc
+          _ = star (zeroCornerRow q a b n i) * (star a * a) *
+              zeroCornerRow q a b n j := by noncomm_ring
+          _ = star (zeroCornerRow q a b n i) * (q * zeroCornerRow q a b n j) := by
+            rw [ha, mul_assoc]
+          _ = _ := by
+            rw [(zeroCornerRow_support q a b hqq hqa hqb hbq n j).1, ih]
+
+lemma zeroCornerRow_range_sum (q a b : E) (hqstar : star q = q) (hqq : q * q = q)
+    (haq : a * q = a) (hsum : a * star a + b * star b = q) :
+    ∀ n, ∑ i, zeroCornerRow q a b n i * star (zeroCornerRow q a b n i) = q := by
+  intro n
+  induction n with
+  | zero =>
+    change (∑ _i : Fin 1, q * star q) = q
+    rw [Fin.sum_univ_one, hqstar, hqq]
+  | succ n ih =>
+    rw [Fin.sum_univ_succ]
+    simp only [zeroCornerRow, Fin.cases_zero, Fin.cases_succ, star_mul]
+    calc
+      _ = b * star b + a * (∑ i, zeroCornerRow q a b n i *
+          star (zeroCornerRow q a b n i)) * star a := by
+        rw [Finset.mul_sum, Finset.sum_mul]
+        congr 1
+        apply Finset.sum_congr rfl
+        intro i _
+        noncomm_ring
+      _ = q := by rw [ih, haq, add_comm, hsum]
+
+lemma zeroCornerRow_norm_le (q a b : E) (hq : ‖q‖ ≤ 1) (ha : ‖a‖ ≤ 1) (hb : ‖b‖ ≤ 1) :
+    ∀ n i, ‖zeroCornerRow q a b n i‖ ≤ 1 := by
+  intro n
+  induction n with
+  | zero => intro i; exact hq
+  | succ n ih =>
+    intro i
+    refine Fin.cases hb (fun j => ?_) i
+    exact (norm_mul_le _ _).trans (by
+      simpa only [one_mul] using mul_le_mul ha (ih j)
+        (norm_nonneg (zeroCornerRow q a b n j)) zero_le_one)
+
+private lemma row_product_commutator_le (a b x : E)
+    (ha : ‖a‖ ≤ 1) (hb : ‖b‖ ≤ 1) :
+    ‖(a * b) * x - x * (a * b)‖ ≤ ‖a * x - x * a‖ + ‖b * x - x * b‖ := by
+  have he : (a * b) * x - x * (a * b) =
+      (a * x - x * a) * b + a * (b * x - x * b) := by noncomm_ring
+  rw [he]
+  calc
+    _ ≤ ‖(a * x - x * a) * b‖ + ‖a * (b * x - x * b)‖ := norm_add_le _ _
+    _ ≤ ‖a * x - x * a‖ * ‖b‖ + ‖a‖ * ‖b * x - x * b‖ :=
+      add_le_add (norm_mul_le _ _) (norm_mul_le _ _)
+    _ ≤ _ := add_le_add
+      (by simpa only [mul_one] using mul_le_mul_of_nonneg_left hb (norm_nonneg _))
+      (by simpa only [one_mul] using mul_le_mul_of_nonneg_right ha (norm_nonneg _))
+
+/-- Each splitting costs at most one extra input commutator. -/
+lemma zeroCornerRow_commutator_bound (q a b x : E) (δ γ : ℝ) (hδ : 0 ≤ δ) (hγ : 0 ≤ γ)
+    (hq : ‖q‖ ≤ 1) (ha : ‖a‖ ≤ 1) (hb : ‖b‖ ≤ 1)
+    (hqc : ‖q * x - x * q‖ ≤ γ) (hac : ‖a * x - x * a‖ ≤ δ)
+    (hbc : ‖b * x - x * b‖ ≤ δ) :
+    ∀ n i, ‖zeroCornerRow q a b n i * x - x * zeroCornerRow q a b n i‖ ≤
+      (n : ℝ) * δ + γ := by
+  intro n
+  induction n with
+  | zero => intro i; simpa only [zeroCornerRow, Nat.cast_zero, zero_mul, zero_add] using hqc
+  | succ n ih =>
+    intro i
+    refine Fin.cases ?_ (fun j => ?_) i
+    · change ‖b * x - x * b‖ ≤ _
+      have hn : 0 ≤ (n : ℝ) * δ := mul_nonneg (Nat.cast_nonneg n) hδ
+      exact hbc.trans (by rw [Nat.cast_add, Nat.cast_one]; nlinarith)
+    · change ‖(a * zeroCornerRow q a b n j) * x - x * (a * zeroCornerRow q a b n j)‖ ≤ _
+      have hp := row_product_commutator_le a (zeroCornerRow q a b n j) x ha
+        (zeroCornerRow_norm_le q a b hq ha hb n j)
+      have hi := ih j
+      rw [Nat.cast_add, Nat.cast_one]
+      linarith
+
+lemma zeroCornerRow_commutes (q a b x : E) (hq : Commute q x)
+    (ha : Commute a x) (hb : Commute b x) :
+    ∀ n i, Commute (zeroCornerRow q a b n i) x := by
+  intro n
+  induction n with
+  | zero => intro i; exact hq
+  | succ n ih =>
+    intro i
+    exact Fin.cases hb (fun j => ha.mul_left (ih j)) i
+
+
+private lemma projection_norm_le_one (q : E) (hqstar : star q = q) (hqq : q * q = q) :
+    ‖q‖ ≤ 1 := by
+  have h : ‖star q * q‖ = ‖q‖ * ‖q‖ := CStarRing.norm_star_mul_self
+  rw [hqstar, hqq] at h
+  nlinarith [norm_nonneg q]
+
+private lemma relativeIsometry_norm_le_one (a q : E) (ha : star a * a = q)
+    (hq : ‖q‖ ≤ 1) : ‖a‖ ≤ 1 := by
+  have h := congrArg norm ha
+  rw [CStarRing.norm_star_mul_self] at h
+  nlinarith [norm_nonneg a]
+
+private lemma row_star_commutator_norm (a x : E) :
+    ‖star a * x - x * star a‖ = ‖a * star x - star x * a‖ := by
+  rw [← norm_star (a * star x - star x * a)]
+  simp only [star_sub, star_mul, star_star]
+  exact norm_sub_rev _ _
+
+private lemma pair_projection_commutator_le (q a b x : E) (δ : ℝ)
+    (hsum : a * star a + b * star b = q) (ha : ‖a‖ ≤ 1) (hb : ‖b‖ ≤ 1)
+    (hac : ‖a * x - x * a‖ ≤ δ) (hasc : ‖star a * x - x * star a‖ ≤ δ)
+    (hbc : ‖b * x - x * b‖ ≤ δ) (hbsc : ‖star b * x - x * star b‖ ≤ δ) :
+    ‖q * x - x * q‖ ≤ 4 * δ := by
+  have he : q * x - x * q =
+      ((a * star a) * x - x * (a * star a)) +
+      ((b * star b) * x - x * (b * star b)) := by rw [← hsum]; noncomm_ring
+  rw [he]
+  have h₁ := row_product_commutator_le a (star a) x ha (by simpa only [norm_star] using ha)
+  have h₂ := row_product_commutator_le b (star b) x hb (by simpa only [norm_star] using hb)
+  exact (norm_add_le _ _).trans (by linarith)
+
+/-- Every finite size occurs in a nonzero approximately central corner.
+Choosing `m = 2*k+1` gives an even row of size `2*k+2`. -/
+lemma exists_approximately_central_finite_corner_row [Nontrivial E]
+    (s t : ℕ → E)
+    (hs : ∀ i j, star (s i) * s j = if i = j then 1 else 0)
+    (hc : ∀ i j, Commute (s i) (t j) ∧ Commute (s i) (star (t j)))
+    (n m : ℕ) (δ : ℝ) (hδ : 0 < δ) :
+    ∃ (q : E) (v : Fin (m + 1) → E),
+      q ≠ 0 ∧ star q = q ∧ q * q = q ∧
+      (∀ i j, star (v i) * v j = if i = j then q else 0) ∧
+      (∑ i, v i * star (v i)) = q ∧
+      (∀ i, q * v i = v i ∧ v i * q = v i) ∧
+      (∀ i k, k < n → ‖v i * s k - s k * v i‖ < δ ∧
+        ‖v i * star (s k) - star (s k) * v i‖ < δ) ∧
+      ∀ i k, Commute (v i) (t k) ∧ Commute (v i) (star (t k)) := by
+  let η := δ / ((m : ℝ) + 5)
+  have hη : 0 < η := by dsimp only [η]; positivity
+  obtain ⟨q, a, b, hqne, hqstar, hqq, haa, hbb, hab, hsum, hcomm, hother⟩ :=
+    exists_approximately_central_zero_corner_pair s t hs hc n η hη
+  obtain ⟨hqa, haq, hqb, hbq⟩ := relativeCuntzPair_support q a b hqstar hqq haa hbb hab hsum
+  have hqn := projection_norm_le_one q hqstar hqq
+  have han := relativeIsometry_norm_le_one a q haa hqn
+  have hbn := relativeIsometry_norm_le_one b q hbb hqn
+  refine ⟨q, zeroCornerRow q a b m, hqne, hqstar, hqq,
+    zeroCornerRow_gram q a b hqstar hqq haa hbb hab hqa hqb hbq m,
+    zeroCornerRow_range_sum q a b hqstar hqq haq hsum m,
+    zeroCornerRow_support q a b hqq hqa hqb hbq m, ?_, ?_⟩
+  · intro i k hk
+    have h := hcomm k hk
+    have hasc : ‖star a * s k - s k * star a‖ ≤ η := by
+      rw [row_star_commutator_norm]
+      exact h.2.2.1.le
+    have hbsc : ‖star b * s k - s k * star b‖ ≤ η := by
+      rw [row_star_commutator_norm]
+      exact h.2.2.2.le
+    have hascs : ‖star a * star (s k) - star (s k) * star a‖ ≤ η := by
+      rw [row_star_commutator_norm, star_star]
+      exact h.1.le
+    have hbscs : ‖star b * star (s k) - star (s k) * star b‖ ≤ η := by
+      rw [row_star_commutator_norm, star_star]
+      exact h.2.1.le
+    have hqc := pair_projection_commutator_le q a b (s k) η hsum han hbn
+      h.1.le hasc h.2.1.le hbsc
+    have hqcs := pair_projection_commutator_le q a b (star (s k)) η hsum han hbn
+      h.2.2.1.le hascs h.2.2.2.le hbscs
+    have h₁ := zeroCornerRow_commutator_bound q a b (s k) η (4 * η) hη.le
+      (by positivity) hqn han hbn hqc h.1.le h.2.1.le m i
+    have h₂ := zeroCornerRow_commutator_bound q a b (star (s k)) η (4 * η) hη.le
+      (by positivity) hqn han hbn hqcs h.2.2.1.le h.2.2.2.le m i
+    have hsmall : (m : ℝ) * η + 4 * η < δ := by
+      have hmul : η * ((m : ℝ) + 5) = δ := by
+        dsimp only [η]
+        exact div_mul_cancel₀ δ (by positivity)
+      nlinarith
+    exact ⟨h₁.trans_lt hsmall, h₂.trans_lt hsmall⟩
+  · intro i k
+    have h := hother k
+    have has : Commute (star a) (t k) := h.2.2.1.star_left
+    have hbs : Commute (star b) (t k) := h.2.2.2.star_left
+    have hqc : Commute q (t k) := by
+      rw [← hsum]
+      exact (h.1.mul_left has).add_left (h.2.1.mul_left hbs)
+    have hqcs : Commute q (star (t k)) := by
+      rw [← hsum]
+      exact (h.2.2.1.mul_left h.1.star_star).add_left (h.2.2.2.mul_left h.2.1.star_star)
+    exact ⟨zeroCornerRow_commutes q a b (t k) hqc h.1 h.2.1 m i,
+      zeroCornerRow_commutes q a b (star (t k)) hqcs h.2.2.1 h.2.2.2 m i⟩
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/ZeroUnitBuffer.lean

@@ -0,0 +1,194 @@
+import OAI.Analysis.OInfinity.NegativeGlobal
+import OAI.Analysis.OInfinity.CentralBuffer
+
+namespace OAI
+
+/-! # Shrinking zero-unit rows against the actual third buffer
+
+The initial corner, its complementary isometry and the isometry inside it
+remain explicit. These are the data supplied by the finite vacuum split;
+no equivalence of arbitrary projections is assumed.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+/-- A full binary row in any supported corner can be shrunk against an
+orthogonal commuting buffer row, with no change in its finite-word error. -/
+lemma exists_commuting_binary_corner_shrink
+    (q : E) (hq : star q = q) (hqq : q * q = q) (hq0 : q ≠ 0)
+    (a r : Fin 2 → E)
+    (ha : ∀ i j, star (a i) * a j = if i = j then q else 0)
+    (has : (∑ i, a i * star (a i)) = q)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (har : bergRowsCommute a r)
+    (hqr : ∀ j, Commute q (r j))
+    (m : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ c : E, q * c = c ∧ c * q = c ∧ star c * c = q ∧
+      c * star c = q * (1 - r 0 * star (r 0)) ∧
+      ∀ i ≤ m, ‖c * (a 0 ^ i * a 1) * star c -
+        (a 0 ^ i * a 1) * (1 - r 0 * star (r 0))‖ < ε := by
+  let R : Fin 2 → E := fun i => r i * q
+  have hasp (i : Fin 2) : q * a i = a i ∧ a i * q = a i :=
+    ⟨finiteRow_left_support q a hq hqq ha has i,
+      finiteRow_right_support q a hq hqq ha i⟩
+  have hRsp (i : Fin 2) : q * R i = R i ∧ R i * q = R i := by
+    constructor
+    · change q * (r i * q) = r i * q
+      rw [← mul_assoc, (hqr i).eq, mul_assoc, hqq]
+    · change (r i * q) * q = r i * q
+      rw [mul_assoc, hqq]
+  have hR (i j : Fin 2) : star (R i) * R j = if i = j then q else 0 := by
+    change star (r i * q) * (r j * q) = _
+    rw [star_mul, hq]
+    calc
+      _ = q * (star (r i) * r j) * q := by noncomm_ring
+      _ = _ := by rw [hr]; split_ifs <;> simp only [mul_one, mul_zero, zero_mul, hqq]
+  have haR : bergRowsCommute a R := by
+    intro i j
+    have haq : Commute (a i) q := (hasp i).2.trans (hasp i).1.symm
+    constructor
+    · exact (har i j).1.mul_right haq
+    · change Commute (a i) (star (r j * q))
+      rw [star_mul, hq]
+      exact haq.mul_right (har i j).2
+  have hfinal : q - R 0 * star (R 0) = q * (1 - r 0 * star (r 0)) := by
+    change q - (r 0 * q) * star (r 0 * q) = _
+    rw [star_mul, hq]
+    have he : (r 0 * q) * (q * star (r 0)) = q * (r 0 * star (r 0)) := by
+      calc
+        _ = r 0 * (q * q) * star (r 0) := by noncomm_ring
+        _ = _ := by rw [hqq, ← (hqr 0).eq]; noncomm_ring
+    rw [he]
+    noncomm_ring
+  obtain ⟨c, hcl, hcr, hcg, hcc, he⟩ := exists_relative_binary_encoded_shrink
+    q hq hqq hq0 R a hRsp hasp hR ha has haR m ε hε
+  refine ⟨c, hcl, hcr, hcg, hcc.trans hfinal, fun i hi => ?_⟩
+  have hxq : (a 0 ^ i * a 1) * q = a 0 ^ i * a 1 := by
+    rw [mul_assoc, (hasp 1).2]
+  have hh := he i hi
+  have hsimp : (a 0 ^ i * a 1) * (q * (1 - r 0 * star (r 0))) =
+      (a 0 ^ i * a 1) * (1 - r 0 * star (r 0)) := by
+    rw [← mul_assoc, hxq]
+  rw [hfinal, hsimp] at hh
+  exact hh
+
+/-- Every element of the buffer's closed row algebra inherits its exact
+commutation with the supplied finite construction data. -/
+lemma closedCanonicalRowAlgebra_commutes_element
+    (r : ℕ → E) (x : E)
+    (hx : ∀ i, Commute (r i) x ∧ Commute (star (r i)) x)
+    (b : closedCanonicalRowAlgebra r) : Commute (b : E) x := by
+  have hxc : x ∈ StarSubalgebra.centralizer ℂ (Set.range r) := by
+    apply (StarSubalgebra.mem_centralizer_iff ℂ).mpr
+    rintro _ ⟨i, rfl⟩
+    exact ⟨(hx i).1.eq, (hx i).2.eq⟩
+  have hbc : (b : E) ∈ StarSubalgebra.centralizer ℂ
+      (StarSubalgebra.centralizer ℂ (Set.range r) : Set E) :=
+    StarSubalgebra.topologicalClosure_adjoin_le_centralizer_centralizer ℂ (Set.range r) b.property
+  exact (((StarSubalgebra.mem_centralizer_iff ℂ).mp hbc) x hxc).1.symm
+
+/-- The explicit complement isometry and an isometry inside `q` give the
+reverse shrink. The initial corner is `p`; the final corner is exactly `pq`.
+No equivalence of an unspecified complementary projection is required. -/
+lemma exists_complementary_binary_corner_shrink
+    (p q w z : E)
+    (hp : star p = p) (hpp : p * p = p) (hp0 : p ≠ 0)
+    (hw : star w * w = 1) (hww : w * star w = 1 - q)
+    (hz : star z * z = 1) (hqz : q * z = z)
+    (hpw : Commute p w) (hpz : Commute p z)
+    (b : Fin 2 → E)
+    (hb : ∀ i j, star (b i) * b j = if i = j then p else 0)
+    (hbs : (∑ i, b i * star (b i)) = p)
+    (hbw : ∀ i, Commute (b i) w ∧ Commute (b i) (star w))
+    (hbz : ∀ i, Commute (b i) z ∧ Commute (b i) (star z))
+    (m : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ d : E, p * d = d ∧ d * p = d ∧ star d * d = p ∧
+      d * star d = p * q ∧
+      ∀ i ≤ m, ‖d * (b 0 ^ i * b 1) * star d - (b 0 ^ i * b 1) * q‖ < ε := by
+  let v : Fin 2 → E := ![w, z]
+  have hwz : star w * z = 0 := by
+    have hwq : star w * q = 0 := by
+      calc
+        _ = star w * (1 - w * star w) := by rw [hww]; noncomm_ring
+        _ = 0 := by rw [mul_sub, mul_one, ← mul_assoc, hw, one_mul, sub_self]
+    calc
+      _ = star w * (q * z) := by rw [hqz]
+      _ = 0 := by rw [← mul_assoc, hwq, zero_mul]
+  have hzw : star z * w = 0 := by
+    simpa only [star_mul, star_star, star_zero] using congrArg star hwz
+  have hv : ∀ i j, star (v i) * v j = if i = j then 1 else 0 := by
+    intro i j
+    fin_cases i <;> fin_cases j <;> simp [v, hw, hz, hwz, hzw]
+  have hbv : bergRowsCommute b v := by
+    intro i j
+    fin_cases j
+    · exact hbw i
+    · exact hbz i
+  have hpv (i : Fin 2) : Commute p (v i) := by
+    fin_cases i
+    · exact hpw
+    · exact hpz
+  obtain ⟨d, hdl, hdr, hdg, hdf, he⟩ :=
+    exists_commuting_binary_corner_shrink p hp hpp hp0 b v hb hbs hv hbv hpv m ε hε
+  have hfinal : 1 - v 0 * star (v 0) = q := by
+    change 1 - w * star w = q
+    rw [hww]
+    noncomm_ring
+  refine ⟨d, hdl, hdr, hdg, ?_, fun i hi => ?_⟩
+  · exact hdf.trans (congrArg (fun x : E => p * x) hfinal)
+  · simpa only [hfinal] using he i hi
+
+/-- A third canonical row supplies its finite binary encoding inside the
+closed buffer algebra. Consequently all supplied construction data commute
+with the encoding, including their adjoints. -/
+lemma exists_buffer_binary_encoding [Nontrivial E]
+    (r : ℕ → E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (m : ℕ) :
+    ∃ b : Fin 2 → closedCanonicalRowAlgebra r,
+      (∀ i j, star (b i : E) * (b j : E) =
+        if i = j then canonicalTailProjection r 1 else 0) ∧
+      (∑ i, (b i : E) * star (b i : E)) = canonicalTailProjection r 1 ∧
+      ∀ i ≤ m, (b 0 : E) ^ i * (b 1 : E) = canonicalNegativeRow r i := by
+  let C := closedCanonicalRowAlgebra r
+  let R : ℕ → C := fun i => ⟨r i, mem_closedCanonicalRowAlgebra r i⟩
+  have hR (i j : ℕ) : star (R i) * R j = if i = j then 1 else 0 := by
+    by_cases hij : i = j
+    · rw [ite_eq_left hij]
+      apply Subtype.ext
+      change star (r i) * r j = 1
+      simpa only [ite_eq_left hij] using hr i j
+    · rw [ite_eq_right hij]
+      apply Subtype.ext
+      change star (r i) * r j = 0
+      simpa only [ite_eq_right hij] using hr i j
+  obtain ⟨b0, b1, h0, h1, h01, hsum, he⟩ :=
+    exists_canonicalNegative_binary_encoding R hR m
+  let b : Fin 2 → C := ![b0, b1]
+  have h10 : star b1 * b0 = 0 := by
+    simpa only [star_mul, star_star, star_zero] using congrArg star h01
+  have hb (i j : Fin 2) : star (b i) * b j =
+      if i = j then canonicalTailProjection R 1 else 0 := by
+    fin_cases i <;> fin_cases j <;> simp [b, h0, h1, h01, h10]
+  refine ⟨b, fun i j => ?_, ?_, fun i hi => ?_⟩
+  · have h := congrArg C.subtype (hb i j)
+    simpa only [map_mul, map_star, apply_ite, map_zero,
+      StarSubalgebra.subtype_apply, canonicalTailProjection_coe] using h
+  · have h := congrArg C.subtype hsum
+    simpa only [Fin.sum_univ_two, b, Matrix.cons_val_zero, Matrix.cons_val_one,
+      map_add, map_mul, map_star, StarSubalgebra.subtype_apply,
+      canonicalTailProjection_coe] using h
+  · have h := congrArg C.subtype (he i hi)
+    simpa only [map_mul, map_pow, StarSubalgebra.subtype_apply,
+      canonicalNegativeRow_coe, b, Matrix.cons_val_zero, Matrix.cons_val_one] using h
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/ZeroUnitComparison.lean

@@ -0,0 +1,331 @@
+import OAI.Analysis.OInfinity.ZeroUnitBuffer
+
+namespace OAI
+
+/-! # Zero-unit finite comparison with a concrete central buffer
+
+The two complementary isometries remain supplied as actual elements. The
+common-corner restriction uses only the closed algebra of the buffer and
+its commutant, so no arbitrary-map uniqueness theorem is invoked.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+/-- Elements in the closed buffer algebra commute with its full star
+commutant, not just with individual row generators. -/
+lemma bufferAlgebra_commutes_commutant (r : ℕ → E)
+    (x : StarSubalgebra.centralizer ℂ (Set.range r))
+    (y : closedCanonicalRowAlgebra r) : Commute (x : E) (y : E) := by
+  have hy : (y : E) ∈ StarSubalgebra.centralizer ℂ
+      (StarSubalgebra.centralizer ℂ (Set.range r) : Set E) :=
+    StarSubalgebra.topologicalClosure_adjoin_le_centralizer_centralizer ℂ (Set.range r) y.property
+  exact (((StarSubalgebra.mem_centralizer_iff ℂ).mp hy) x x.property).1
+
+/-- Restrict a full binary row in the buffer commutant and its finite
+buffer encoding to their actual common unit, then compare them there. -/
+lemma exists_buffer_common_binary_comparison
+    (r : ℕ → E)
+    (q : StarSubalgebra.centralizer ℂ (Set.range r))
+    (p : closedCanonicalRowAlgebra r)
+    (hq : star q = q) (hqq : q * q = q)
+    (hp : star p = p) (hpp : p * p = p)
+    (hqp0 : (q : E) * (p : E) ≠ 0)
+    (a : Fin 2 → StarSubalgebra.centralizer ℂ (Set.range r))
+    (b : Fin 2 → closedCanonicalRowAlgebra r)
+    (ha : ∀ i j, star (a i) * a j = if i = j then q else 0)
+    (hb : ∀ i j, star (b i) * b j = if i = j then p else 0)
+    (has : (∑ i, a i * star (a i)) = q)
+    (hbs : (∑ i, b i * star (b i)) = p)
+    (m : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ u : unitary E, Joined (1 : unitary E) u ∧
+      (u : E) * (1 - (q : E) * (p : E)) = 1 - (q : E) * (p : E) ∧
+      (1 - (q : E) * (p : E)) * (u : E) = 1 - (q : E) * (p : E) ∧
+      ∀ i ≤ m, ‖(u : E) * (((a 0 : E) ^ i * (a 1 : E)) * (p : E)) *
+        star (u : E) - ((b 0 : E) ^ i * (b 1 : E)) * (q : E)‖ < ε := by
+  let C := StarSubalgebra.centralizer ℂ (Set.range r)
+  let D := closedCanonicalRowAlgebra r
+  let : IsClosed (C : Set E) := Set.isClosed_centralizer _
+  have hc (x : C) (y : D) : Commute (x : E) (y : E) :=
+    bufferAlgebra_commutes_commutant r x y
+  let f := commutingProjectionRestriction C (p : E)
+    (congrArg D.subtype hp) (congrArg D.subtype hpp) (fun x => hc x p)
+  let g := commutingProjectionRestriction D (q : E)
+    (congrArg C.subtype hq) (congrArg C.subtype hqq) (fun y => (hc q y).symm)
+  have hrestr := restrict_commuting_binary_rows C D hc q p hq hqq hp hpp a b ha hb has hbs
+  change (∀ i j, star (f (a i)) * f (a j) = if i = j then (q : E) * (p : E) else 0) ∧
+    (∀ i j, star (g (b i)) * g (b j) = if i = j then (q : E) * (p : E) else 0) ∧
+    (∑ i, f (a i) * star (f (a i))) = (q : E) * (p : E) ∧
+    (∑ i, g (b i) * star (g (b i))) = (q : E) * (p : E) ∧
+    bergRowsCommute (fun i => f (a i)) (fun i => g (b i)) at hrestr
+  have hqp : Commute (q : E) (p : E) := hc q p
+  have hqs : star (q : E) = (q : E) := congrArg C.subtype hq
+  have hps : star (p : E) = (p : E) := congrArg D.subtype hp
+  have hq2 : (q : E) * (q : E) = (q : E) := congrArg C.subtype hqq
+  have hp2 : (p : E) * (p : E) = (p : E) := congrArg D.subtype hpp
+  have hstar : star ((q : E) * (p : E)) = (q : E) * (p : E) := by
+    rw [star_mul, hqs, hps, hqp.eq]
+  have hsq : ((q : E) * (p : E)) * ((q : E) * (p : E)) = (q : E) * (p : E) := by
+    calc
+      _ = (q : E) * ((p : E) * (q : E)) * (p : E) := by noncomm_ring
+      _ = _ := by rw [← hqp.eq, ← mul_assoc, hq2, mul_assoc, hp2]
+  obtain ⟨u, hu, hur, hul, he⟩ := exists_relative_binary_power_conjugacy
+    ((q : E) * (p : E)) hstar hsq hqp0
+    (fun i => f (a i)) (fun i => g (b i))
+    hrestr.1 hrestr.2.1 hrestr.2.2.1 hrestr.2.2.2.1 hrestr.2.2.2.2 m ε hε
+  refine ⟨u, hu, hur, hul, fun i hi => ?_⟩
+  have haev : f (a 0) ^ i * f (a 1) = ((a 0 : E) ^ i * (a 1 : E)) * (p : E) := by
+    rw [← nonunital_map_pow_mul]
+    change ((a 0 ^ i * a 1 : C) : E) * (p : E) = _
+    rfl
+  have hbev : g (b 0) ^ i * g (b 1) = ((b 0 : E) ^ i * (b 1 : E)) * (q : E) := by
+    rw [← nonunital_map_pow_mul]
+    change ((b 0 ^ i * b 1 : D) : E) * (q : E) = _
+    rfl
+  simpa only [haev, hbev] using he i hi
+
+/-- Compare the finite encoding of a zero-unit row with the actual negative
+buffer row. Both a complement isometry and an isometry inside the initial
+corner are retained as concrete data. The resulting ambient unitary is
+connected to one; this does not compare the original unsplit generators. -/
+lemma exists_zeroUnit_buffer_comparison_with_unit [Nontrivial E]
+    (r : ℕ → E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (q w z : StarSubalgebra.centralizer ℂ (Set.range r))
+    (hq : star q = q) (hqq : q * q = q) (hq0 : q ��� 0)
+    (hw : star w * w = 1) (hww : w * star w = 1 - q)
+    (hz : star z * z = 1) (hqz : q * z = z)
+    (a : Fin 2 → StarSubalgebra.centralizer ℂ (Set.range r))
+    (ha : ∀ i j, star (a i) * a j = if i = j then q else 0)
+    (has : (∑ i, a i * star (a i)) = q)
+    (m : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ u : unitary E, Joined (1 : unitary E) u ∧
+      (u : E) * (q : E) * star (u : E) = canonicalTailProjection r 1 ∧
+      ∀ i ≤ m, ‖(u : E) * ((a 0 : E) ^ i * (a 1 : E)) * star (u : E) -
+        canonicalNegativeRow r i‖ < ε := by
+  let C := StarSubalgebra.centralizer ℂ (Set.range r)
+  let D := closedCanonicalRowAlgebra r
+  let : IsClosed (C : Set E) := Set.isClosed_centralizer _
+  let R : ℕ → D := fun i => ⟨r i, mem_closedCanonicalRowAlgebra r i⟩
+  have hR (i j : ℕ) : star (R i) * R j = if i = j then 1 else 0 := by
+    by_cases hij : i = j
+    · rw [ite_eq_left hij]
+      apply Subtype.ext
+      change star (r i) * r j = 1
+      simpa only [ite_eq_left hij] using hr i j
+    · rw [ite_eq_right hij]
+      apply Subtype.ext
+      change star (r i) * r j = 0
+      simpa only [ite_eq_right hij] using hr i j
+  let p := canonicalTailProjection R 1
+  let P := canonicalTailProjection r 1
+  have hpc : (p : E) = P := canonicalTailProjection_coe D R 1
+  have hp : star p = p := canonicalTailProjection_star R 1
+  have hpp : p * p = p := canonicalTailProjection_idempotent R hR 1
+  have hP : star P = P := canonicalTailProjection_star r 1
+  have hPP : P * P = P := canonicalTailProjection_idempotent r hr 1
+  have hP0 : P ≠ 0 := canonicalTailProjection_ne_zero r hr 1
+  have hPdef : P = 1 - r 0 * star (r 0) := by
+    dsimp only [P]
+    rw [show (1 : ℕ) = 0 + 1 by rfl, canonicalTailProjection_succ, canonicalTailProjection_zero]
+  have hqE : star (q : E) = (q : E) := congrArg C.subtype hq
+  have hqqE : (q : E) * (q : E) = (q : E) := congrArg C.subtype hqq
+  have hq0E : (q : E) ≠ 0 := fun h => hq0 (Subtype.ext h)
+  have hwE : star (w : E) * (w : E) = 1 := congrArg C.subtype hw
+  have hwwE : (w : E) * star (w : E) = 1 - (q : E) := congrArg C.subtype hww
+  have hzE : star (z : E) * (z : E) = 1 := congrArg C.subtype hz
+  have hqzE : (q : E) * (z : E) = (z : E) := congrArg C.subtype hqz
+  have hcomm (x : C) (y : D) : Commute (x : E) (y : E) :=
+    bufferAlgebra_commutes_commutant r x y
+  have hxrow (x : C) (j : ℕ) : Commute (x : E) (r j) ∧ Commute (x : E) (star (r j)) := by
+    have h := (StarSubalgebra.mem_centralizer_iff ℂ).mp x.property (r j) ⟨j, rfl⟩
+    exact ⟨h.1.symm, h.2.symm⟩
+  have hqP : Commute (q : E) P := by simpa only [hpc] using hcomm q p
+  have hzP : Commute (z : E) P := by simpa only [hpc] using hcomm z p
+  have hPw : Commute P (w : E) := by simpa only [hpc] using (hcomm w p).symm
+  have hPz : Commute P (z : E) := hzP.symm
+  have hqP0 : (q : E) * P ≠ 0 := by
+    let v := (z : E) * r 1
+    have hv : star v * v = 1 := by
+      dsimp only [v]
+      rw [star_mul]
+      calc
+        _ = star (r 1) * (star (z : E) * (z : E)) * r 1 := by noncomm_ring
+        _ = 1 := by rw [hzE, mul_one]; simpa only [ite_true] using hr 1 1
+    have hPr : P * r 1 = r 1 := by
+      simpa only [Nat.lt_irrefl, ite_false] using canonicalTailProjection_mul_generator r hr 1 1
+    have hs : ((q : E) * P) * v = v := by
+      dsimp only [v]
+      calc
+        _ = (q : E) * (P * (z : E)) * r 1 := by noncomm_ring
+        _ = ((q : E) * (z : E)) * (P * r 1) := by rw [← hzP.eq]; noncomm_ring
+        _ = _ := by rw [hqzE, hPr]
+    intro hzero
+    have hv0 : v = 0 := by simpa only [hzero, zero_mul] using hs.symm
+    have h10 : (1 : E) = 0 := by simpa only [hv0, star_zero, zero_mul] using hv.symm
+    exact one_ne_zero h10
+  obtain ⟨b0, b1, hb0, hb1, hb01, hbs, hbe⟩ :=
+    exists_canonicalNegative_binary_encoding R hR m
+  let b : Fin 2 → D := ![b0, b1]
+  have hb10 : star b1 * b0 = 0 := by
+    simpa only [star_mul, star_star, star_zero] using congrArg star hb01
+  have hb (i j : Fin 2) : star (b i) * b j = if i = j then p else 0 := by
+    fin_cases i <;> fin_cases j <;> simp [b, p, hb0, hb1, hb01, hb10]
+  have hbs' : (∑ i, b i * star (b i)) = p := by
+    simpa only [Fin.sum_univ_two, b, Matrix.cons_val_zero, Matrix.cons_val_one] using hbs
+  let A : Fin 2 → E := fun i => a i
+  let B : Fin 2 → E := fun i => b i
+  have haE (i j : Fin 2) : star (A i) * A j = if i = j then (q : E) else 0 := by
+    have h := congrArg C.subtype (ha i j)
+    simpa only [map_mul, map_star, apply_ite, map_zero, StarSubalgebra.subtype_apply] using h
+  have hasE : (∑ i, A i * star (A i)) = (q : E) := by
+    have h := congrArg C.subtype has
+    simpa only [map_sum, map_mul, map_star, StarSubalgebra.subtype_apply] using h
+  have hbE (i j : Fin 2) : star (B i) * B j = if i = j then P else 0 := by
+    have h := congrArg D.subtype (hb i j)
+    simpa only [map_mul, map_star, apply_ite, map_zero, StarSubalgebra.subtype_apply, hpc] using h
+  have hbsE : (∑ i, B i * star (B i)) = P := by
+    have h := congrArg D.subtype hbs'
+    simpa only [map_sum, map_mul, map_star, StarSubalgebra.subtype_apply, hpc] using h
+  let δ := ε / 3
+  have hδ : 0 < δ := by dsimp only [δ]; positivity
+  obtain ⟨c, _hcL, hcq, hcg, hcc, hec⟩ := exists_commuting_binary_corner_shrink
+    (q : E) hqE hqqE hq0E A (fun i : Fin 2 => r i) haE hasE
+    (fun i j => by simpa only [Fin.ext_iff] using hr i j)
+    (fun i j => hxrow (a i) j) (fun j => (hxrow q j).1) m δ hδ
+  simp only [Fin.val_zero] at hcc hec
+  rw [← hPdef] at hcc
+  have hbw (i : Fin 2) : Commute (B i) (w : E) ∧ Commute (B i) (star (w : E)) :=
+    ⟨(hcomm w (b i)).symm, (hcomm (star w) (b i)).symm⟩
+  have hbz (i : Fin 2) : Commute (B i) (z : E) ∧ Commute (B i) (star (z : E)) :=
+    ⟨(hcomm z (b i)).symm, (hcomm (star z) (b i)).symm⟩
+  obtain ⟨d, _hdL, hdp, hdg, hdd, hed⟩ := exists_complementary_binary_corner_shrink
+    P (q : E) (w : E) (z : E) hP hPP hP0 hwE hwwE hzE hqzE hPw hPz
+    B hbE hbsE hbw hbz m δ hδ
+  have hdd' : d * star d = (q : E) * P := hdd.trans hqP.eq.symm
+  have hqpc : (q : E) * (p : E) ≠ 0 := by simpa only [hpc] using hqP0
+  obtain ⟨v, _hv, hvr, hvl, hev⟩ := exists_buffer_common_binary_comparison
+    r q p hq hqq hp hpp hqpc a b ha hb has hbs' m δ hδ
+  have hvR : Commute (v : E) ((q : E) * P) := by
+    have h := hvr.trans hvl.symm
+    rw [mul_sub, sub_mul, mul_one, one_mul] at h
+    change (v : E) * ((q : E) * P) = ((q : E) * P) * (v : E)
+    simpa only [hpc] using sub_right_inj.mp h
+  let W := star d * (v : E) * c
+  obtain ⟨hWq, hWP, hWright⟩ := commonCornerTransfer_products
+    (q : E) P ((q : E) * P) c d v hcg hcc hcq hdg hdd' hdp hvR
+  have hdn : ‖d‖ ≤ 1 := by
+    have hn := congrArg norm hdg
+    rw [CStarRing.norm_star_mul_self] at hn
+    have hPn : ‖P‖ ≤ 1 := IsStarProjection.norm_le P (isStarProjection_iff'.mpr ⟨hPP, hP⟩)
+    nlinarith [norm_nonneg d]
+  have hclose (i : ℕ) (hi : i ≤ m) :
+      ‖W * (A 0 ^ i * A 1) * star W - (B 0 ^ i * B 1)‖ < ε := by
+    have hbl : P * (B 0 ^ i * B 1) = B 0 ^ i * B 1 := by
+      have hs0 := finiteRow_left_support P B hP hPP hbE hbsE 0
+      have hs1 := finiteRow_left_support P B hP hPP hbE hbsE 1
+      cases i with
+      | zero => simpa only [pow_zero, one_mul] using hs1
+      | succ i =>
+        calc
+          _ = (P * B 0) * (B 0 ^ i * B 1) := by rw [pow_succ']; noncomm_ring
+          _ = _ := by rw [hs0, pow_succ']; noncomm_ring
+    have hbr : (B 0 ^ i * B 1) * P = B 0 ^ i * B 1 := by
+      rw [mul_assoc, finiteRow_right_support P B hP hPP hbE 1]
+    have hvclose := hev i hi
+    rw [hpc] at hvclose
+    have hcclose := hec i hi
+    rw [← hPdef] at hcclose
+    have he := commonCornerTransfer_error P c d (A 0 ^ i * A 1) (B 0 ^ i * B 1)
+      ((A 0 ^ i * A 1) * P) ((B 0 ^ i * B 1) * (q : E)) v hdg hbl hbr hdn δ
+      hcclose (hed i hi) hvclose
+    exact he.trans_eq (by dsimp only [δ]; ring)
+  let spare := (w : E) * r 0
+  have hsGram : star spare * spare = 1 := by
+    dsimp only [spare]
+    rw [star_mul]
+    calc
+      _ = star (r 0) * (star (w : E) * (w : E)) * r 0 := by noncomm_ring
+      _ = 1 := by rw [hwE, mul_one]; simpa only [ite_true] using hr 0 0
+  have hqw : (q : E) * (w : E) = 0 := by
+    calc
+      _ = (1 - (w : E) * star (w : E)) * (w : E) := by rw [hwwE]; noncomm_ring
+      _ = 0 := by rw [sub_mul, one_mul, mul_assoc, hwE, mul_one, sub_self]
+  have hqsp : (q : E) * spare = 0 := by dsimp only [spare]; rw [← mul_assoc, hqw, zero_mul]
+  have hPsp : P * spare = 0 := by
+    have hPr : P * r 0 = 0 := by
+      simpa only [show (0 : ℕ) < 1 by omega, ite_true] using canonicalTailProjection_mul_generator r hr 1 0
+    dsimp only [spare]
+    rw [← mul_assoc, hPw.eq, mul_assoc, hPr, mul_zero]
+  have hWpartial : W * star W * W = W := by rw [mul_assoc, hWq, hWright]
+  obtain ⟨u, hu, _huEq, huq⟩ := exists_explicit_connected_unitary_extension W spare
+    hWpartial hsGram (by rw [hWq]; exact hqsp) (by rw [hWP]; exact hPsp)
+  have huq' : (u : E) * (q : E) = W := by
+    have hWq' : star W * W = (q : E) := hWq
+    rw [hWq'] at huq
+    exact huq
+  have huRange : (u : E) * (q : E) * star (u : E) = P := by
+    have hstar := congrArg star huq'
+    rw [star_mul, hqE] at hstar
+    calc
+      _ = (u : E) * ((q : E) * (q : E)) * star (u : E) := by rw [hqqE]
+      _ = ((u : E) * (q : E)) * ((q : E) * star (u : E)) := by noncomm_ring
+      _ = P := by rw [huq', hstar]; exact hWP
+  refine ⟨u, hu, huRange, fun i hi => ?_⟩
+  have hxl : (q : E) * (A 0 ^ i * A 1) = A 0 ^ i * A 1 := by
+    have hs0 := finiteRow_left_support (q : E) A hqE hqqE haE hasE 0
+    have hs1 := finiteRow_left_support (q : E) A hqE hqqE haE hasE 1
+    cases i with
+    | zero => simpa only [pow_zero, one_mul] using hs1
+    | succ i =>
+      calc
+        _ = ((q : E) * A 0) * (A 0 ^ i * A 1) := by rw [pow_succ']; noncomm_ring
+        _ = _ := by rw [hs0, pow_succ']; noncomm_ring
+  have hxr : (A 0 ^ i * A 1) * (q : E) = A 0 ^ i * A 1 := by
+    rw [mul_assoc, finiteRow_right_support (q : E) A hqE hqqE haE 1]
+  have hue : (u : E) * (A 0 ^ i * A 1) * star (u : E) =
+      W * (A 0 ^ i * A 1) * star W := by
+    calc
+      _ = ((u : E) * (q : E)) * (A 0 ^ i * A 1) * star ((u : E) * (q : E)) := by
+        rw [star_mul, hqE]
+        symm
+        calc
+          _ = (u : E) * ((q : E) * (A 0 ^ i * A 1) * (q : E)) * star (u : E) := by noncomm_ring
+          _ = _ := by rw [hxl, hxr]
+      _ = _ := by rw [huq']
+  have hbeE : B 0 ^ i * B 1 = canonicalNegativeRow r i := by
+    have h := congrArg D.subtype (hbe i hi)
+    simpa only [map_pow, map_mul, StarSubalgebra.subtype_apply, canonicalNegativeRow_coe,
+      B, b, Matrix.cons_val_zero, Matrix.cons_val_one] using h
+  change ‖(u : E) * (A 0 ^ i * A 1) * star (u : E) - canonicalNegativeRow r i‖ < ε
+  rw [hue, ← hbeE]
+  exact hclose i hi
+
+/-- The comparison-only form preserves the original finite interface. -/
+lemma exists_zeroUnit_buffer_comparison [Nontrivial E]
+    (r : ℕ → E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (q w z : StarSubalgebra.centralizer ℂ (Set.range r))
+    (hq : star q = q) (hqq : q * q = q) (hq0 : q ≠ 0)
+    (hw : star w * w = 1) (hww : w * star w = 1 - q)
+    (hz : star z * z = 1) (hqz : q * z = z)
+    (a : Fin 2 → StarSubalgebra.centralizer ℂ (Set.range r))
+    (ha : ∀ i j, star (a i) * a j = if i = j then q else 0)
+    (has : (∑ i, a i * star (a i)) = q)
+    (m : ℕ) (ε : ℝ) (hε : 0 < ε) :
+    ∃ u : unitary E, Joined (1 : unitary E) u ∧
+      ∀ i ≤ m, ‖(u : E) * ((a 0 : E) ^ i * (a 1 : E)) * star (u : E) -
+        canonicalNegativeRow r i‖ < ε := by
+  obtain ⟨u, hu, _, he⟩ := exists_zeroUnit_buffer_comparison_with_unit
+    r hr q w z hq hqq hq0 hw hww hz hqz a ha has m ε hε
+  exact ⟨u, hu, he⟩
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/ZeroUnitCompletion.lean

@@ -0,0 +1,368 @@
+import OAI.Analysis.OInfinity.NegativeBinary
+
+namespace OAI
+
+/-! # Finite range completion in a zero unit corner
+
+A proper finite row and an orthogonal spare are combined with a concrete
+coisometric row. The resulting isometry fills exactly the missing range.
+The construction is algebraic and does not use projection classification.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+/-- Turn a coisometry into an isometry by moving its initial support into
+one specified isometric range. -/
+lemma coisometry_range_filler (A y : E)
+    (hA : A * star A = 1) (hy : star y * y = 1)
+    (hpy : (star A * A) * y = y) :
+    let C := 1 - star A * A + y * A
+    star C * C = 1 ∧ C * star C = 1 - star A * A + y * star y := by
+  intro C
+  let p := star A * A
+  let e := 1 - p
+  have hp : star p = p := by simp only [p, star_mul, star_star]
+  have hpp : p * p = p := by
+    change (star A * A) * (star A * A) = star A * A
+    calc
+      _ = star A * (A * star A) * A := by noncomm_ring
+      _ = _ := by rw [hA, mul_one]
+  have he : star e = e := by simp only [e, star_sub, star_one, hp]
+  have hee : e * e = e := by dsimp only [e]; noncomm_ring [hpp]
+  have hey : e * y = 0 := by
+    change (1 - p) * y = 0
+    rw [sub_mul, one_mul, hpy, sub_self]
+  have hAe : A * e = 0 := by
+    have hAp : A * p = A := by
+      change A * (star A * A) = A
+      rw [← mul_assoc, hA, one_mul]
+    dsimp only [e]
+    rw [mul_sub, mul_one, hAp, sub_self]
+  have h1 : e * (y * A) = 0 := by rw [← mul_assoc, hey, zero_mul]
+  have h2 : star (y * A) * e = 0 := by
+    have hh := congrArg star h1
+    simpa only [star_mul, he, star_zero] using hh
+  have h3 : (y * A) * e = 0 := by rw [mul_assoc, hAe, mul_zero]
+  have h4 : e * star (y * A) = 0 := by
+    have hh := congrArg star h3
+    simpa only [star_mul, he, star_zero] using hh
+  have hyy : star (y * A) * (y * A) = p := by
+    rw [star_mul]
+    calc
+      _ = star A * (star y * y) * A := by noncomm_ring
+      _ = p := by rw [hy, mul_one]
+  have haa : (y * A) * star (y * A) = y * star y := by
+    rw [star_mul]
+    calc
+      _ = y * (A * star A) * star y := by noncomm_ring
+      _ = _ := by rw [hA, mul_one]
+  constructor
+  · change star (e + y * A) * (e + y * A) = 1
+    rw [star_add, he, add_mul, mul_add, mul_add, hee, h1, h2, hyy]
+    dsimp only [e]
+    noncomm_ring
+  · change (e + y * A) * star (e + y * A) = e + y * star y
+    rw [star_add, he, add_mul, mul_add, mul_add, hee, h4, h3, haa]
+    abel
+
+/-- A full finite target row fills the defect of an arbitrary finite
+proper row with its given orthogonal spare. -/
+lemma finite_zero_unit_range_completion {n : ℕ}
+    (x : Fin n → E) (y : E) (a : Fin (n + 1) → E)
+    (hx : ∀ i j, star (x i) * x j = if i = j then 1 else 0)
+    (hy : star y * y = 1) (hyx : ∀ i, star y * x i = 0)
+    (ha : ∀ i j, star (a i) * a j = if i = j then 1 else 0)
+    (has : (∑ i, a i * star (a i)) = 1) :
+    ∃ C : E, star C * C = 1 ∧
+      C * star C = 1 - ∑ i, x i * star (x i) := by
+  let r : Fin (n + 1) → E := Fin.cons y x
+  have hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0 := by
+    intro i j
+    refine Fin.cases ?_ (fun i => ?_) i <;> refine Fin.cases ?_ (fun j => ?_) j
+    · simpa only [r, Fin.cons_zero, ite_true] using hy
+    · simp only [r, Fin.cons_zero, Fin.cons_succ, hyx, (Fin.succ_ne_zero j).symm, ite_false]
+    · have hh := congrArg star (hyx i)
+      simpa only [r, Fin.cons_zero, Fin.cons_succ, star_mul, star_star, star_zero,
+        Fin.succ_ne_zero, ite_false] using hh
+    · simpa only [r, Fin.cons_succ, Fin.succ_inj] using hx i j
+  let A := finiteCuntzTransfer r a 1
+  have hAst : star A = finiteCuntzTransfer a r 1 := by
+    simpa only [A, star_one] using finiteCuntzTransfer_star r a 1
+  have hAA : A * star A = 1 := by
+    have hh := finiteCuntzTransfer_star_mul a r hr 1
+    rw [← hAst, star_star] at hh
+    simpa only [star_one, one_mul, mul_one, has] using hh
+  have hAA' : star A * A = ∑ i, r i * star (r i) := by
+    simpa only [A, star_one, one_mul, mul_one] using
+      finiteCuntzTransfer_star_mul r a ha 1
+  have hpy : (star A * A) * y = y := by
+    rw [hAA']
+    have hh := finiteRowPermutation_mul_row 1 r (by simp) (by simp) hr 1 0
+    simpa only [finiteRowPermutation, Equiv.Perm.one_apply, r, Fin.cons_zero] using hh
+  obtain ⟨hC, hC'⟩ := coisometry_range_filler A y hAA hy hpy
+  refine ⟨1 - star A * A + y * A, hC, ?_⟩
+  rw [hC', hAA', Fin.sum_univ_succ]
+  simp only [r, Fin.cons_zero, Fin.cons_succ]
+  abel
+
+/-- A coisometric binary pair supplies every finite target size, so only
+an actual orthogonal spare is needed to fill the prescribed proper row. -/
+lemma finite_zero_unit_completion_from_binary {n : ℕ}
+    (x : Fin n → E) (y a b : E)
+    (hx : ∀ i j, star (x i) * x j = if i = j then 1 else 0)
+    (hy : star y * y = 1) (hyx : ∀ i, star y * x i = 0)
+    (ha : star a * a = 1) (hb : star b * b = 1) (hab : star a * b = 0)
+    (hsum : a * star a + b * star b = 1) :
+    ∃ C : E, star C * C = 1 ∧
+      C * star C = 1 - ∑ i, x i * star (x i) := by
+  exact finite_zero_unit_range_completion x y (zeroCornerRow 1 a b n) hx hy hyx
+    (zeroCornerRow_gram 1 a b (star_one _) (one_mul _) ha hb hab
+      (one_mul _) (one_mul _) (mul_one _) n)
+    (zeroCornerRow_range_sum 1 a b (star_one _) (one_mul _) (mul_one _) hsum n)
+
+/-- Appending the concrete missing-range isometry gives a full finite row. -/
+lemma finite_zero_unit_full_row {n : ℕ}
+    (x : Fin n → E) (y a b : E)
+    (hx : ∀ i j, star (x i) * x j = if i = j then 1 else 0)
+    (hy : star y * y = 1) (hyx : ∀ i, star y * x i = 0)
+    (ha : star a * a = 1) (hb : star b * b = 1) (hab : star a * b = 0)
+    (hsum : a * star a + b * star b = 1) :
+    ∃ r : Fin (n + 1) → E,
+      (∀ i : Fin n, r i.succ = x i) ∧
+      (∀ i j, star (r i) * r j = if i = j then 1 else 0) ∧
+      (∑ i, r i * star (r i)) = 1 := by
+  obtain ⟨C, hC, hCr⟩ := finite_zero_unit_completion_from_binary x y a b
+    hx hy hyx ha hb hab hsum
+  have hPx (i : Fin n) : (∑ j, x j * star (x j)) * x i = x i := by
+    simpa only [finiteRowPermutation, Equiv.Perm.one_apply] using
+      finiteRowPermutation_mul_row 1 x (by simp) (by simp) hx 1 i
+  have horth (i : Fin n) : star C * x i = 0 := by
+    have hr : (C * star C) * x i = 0 := by
+      rw [hCr, sub_mul, one_mul, hPx, sub_self]
+    have hh := congrArg (fun z => star C * z) hr
+    simpa only [← mul_assoc, hC, one_mul, mul_zero] using hh
+  let r : Fin (n + 1) → E := Fin.cons C x
+  refine ⟨r, fun i => rfl, ?_, ?_⟩
+  · intro i j
+    refine Fin.cases ?_ (fun i => ?_) i <;> refine Fin.cases ?_ (fun j => ?_) j
+    · simpa only [r, Fin.cons_zero, ite_true] using hC
+    · simp only [r, Fin.cons_zero, Fin.cons_succ, horth, (Fin.succ_ne_zero j).symm, ite_false]
+    · have hh := congrArg star (horth i)
+      simpa only [r, Fin.cons_zero, Fin.cons_succ, star_mul, star_star, star_zero,
+        Fin.succ_ne_zero, ite_false] using hh
+    · simpa only [r, Fin.cons_succ, Fin.succ_inj] using hx i j
+  · rw [Fin.sum_univ_succ]
+    simp only [r, Fin.cons_zero, Fin.cons_succ, hCr]
+    abel
+
+/-- A countable orthogonal row in a zero-unit algebra has an exact binary
+encoding of each prescribed finite prefix. The next row element is the spare. -/
+lemma exists_zero_unit_binary_encoding
+    (x : ℕ → E)
+    (hx : ∀ i j, star (x i) * x j = if i = j then 1 else 0)
+    (a b : E) (ha : star a * a = 1) (hb : star b * b = 1)
+    (hab : star a * b = 0) (hsum : a * star a + b * star b = 1) (m : ℕ) :
+    ∃ A B : E, star A * A = 1 ∧ star B * B = 1 ∧ star A * B = 0 ∧
+      A * star A + B * star B = 1 ∧ ∀ i ≤ m, A ^ i * B = x i := by
+  have fill (n : ℕ) : ∃ r : Fin (n + 1) → E,
+      (∀ i : Fin n, r i.succ = x i) ∧
+      (∀ i j, star (r i) * r j = if i = j then 1 else 0) ∧
+      (∑ i, r i * star (r i)) = 1 := by
+    refine finite_zero_unit_full_row (fun i : Fin n => x i) (x n) a b
+      ?_ ?_ ?_ ha hb hab hsum
+    · intro i j
+      simpa only [Fin.ext_iff] using hx i j
+    · simpa only [ite_true] using hx n n
+    · intro i
+      have hne : n ≠ (i : ℕ) := Nat.ne_of_gt i.isLt
+      simpa only [hne, ite_false] using hx n i
+  obtain ⟨r, hrleaf, hr, hrs⟩ := fill m
+  obtain ⟨R, hRleaf, hR, hRs⟩ := fill (m + 1)
+  obtain ⟨A, B, hA, hB, hAB, hsum', hB0, hstep⟩ :=
+    successive_full_rows_binary m r R hr hR hrs hRs
+  have hBx : B = x 0 := hB0.trans (hRleaf 0)
+  refine ⟨A, B, hA, hB, hAB, hsum', ?_⟩
+  intro i
+  induction i with
+  | zero => intro _; simpa only [pow_zero, one_mul] using hBx
+  | succ i ih =>
+    intro hi
+    rw [pow_succ', mul_assoc, ih (by omega)]
+    have h := hstep (⟨i, by omega⟩ : Fin m)
+    rw [hrleaf, hRleaf] at h
+    exact h
+
+/-- The same explicit filler in a supported corner with its actual unit
+`q`. No relation between `q` and the ambient identity is needed. -/
+lemma relative_zero_unit_completion {n : ℕ}
+    (q : E) (hq : star q = q) (hqq : q * q = q)
+    (x : Fin n → E) (y a b : E)
+    (hxs : ∀ i, q * x i = x i ∧ x i * q = x i)
+    (hys : q * y = y ∧ y * q = y)
+    (hx : ∀ i j, star (x i) * x j = if i = j then q else 0)
+    (hy : star y * y = q) (hyx : ∀ i, star y * x i = 0)
+    (ha : star a * a = q) (hb : star b * b = q) (hab : star a * b = 0)
+    (hsum : a * star a + b * star b = q) :
+    ∃ C : E, q * C = C ∧ C * q = C ∧ star C * C = q ∧
+      C * star C = q - ∑ i, x i * star (x i) := by
+  obtain ⟨hqa, haq, hqb, hbq⟩ := relativeCuntzPair_support q a b hq hqq ha hb hab hsum
+  let x' : Fin n → ProjectionCorner q hq hqq := fun i =>
+    projectionCornerElement q hq hqq (x i) (hxs i)
+  let y' : ProjectionCorner q hq hqq := projectionCornerElement q hq hqq y hys
+  let a' : ProjectionCorner q hq hqq := projectionCornerElement q hq hqq a ⟨hqa, haq⟩
+  let b' : ProjectionCorner q hq hqq := projectionCornerElement q hq hqq b ⟨hqb, hbq⟩
+  have hx' : ∀ i j, star (x' i) * x' j = if i = j then 1 else 0 :=
+    projectionCornerElement_gram q hq hqq x hxs hx
+  have hy' : star y' * y' = 1 := Subtype.ext hy
+  have hyx' (i : Fin n) : star y' * x' i = 0 := Subtype.ext (hyx i)
+  have ha' : star a' * a' = 1 := Subtype.ext ha
+  have hb' : star b' * b' = 1 := Subtype.ext hb
+  have hab' : star a' * b' = 0 := Subtype.ext hab
+  have hsum' : a' * star a' + b' * star b' = 1 := Subtype.ext hsum
+  obtain ⟨C, hC, hCC⟩ := finite_zero_unit_completion_from_binary x' y' a' b'
+    hx' hy' hyx' ha' hb' hab' hsum'
+  refine ⟨C, C.property.1, C.property.2,
+    congrArg (fun z : ProjectionCorner q hq hqq => (z : E)) hC, ?_⟩
+  have h := congrArg (projectionCornerInclusion q hq hqq) hCC
+  simp only [map_sub, map_sum, map_mul, map_star, projectionCornerInclusion_one] at h
+  exact h
+
+/-- Exact finite binary encoding in the given corner. The countable
+proper row supplies its own next unused isometry at every finite stage. -/
+lemma exists_relative_zero_unit_binary_encoding
+    (q : E) (hq : star q = q) (hqq : q * q = q)
+    (x : ℕ → E) (a b : E)
+    (hxs : ∀ i, q * x i = x i ∧ x i * q = x i)
+    (hx : ∀ i j, star (x i) * x j = if i = j then q else 0)
+    (ha : star a * a = q) (hb : star b * b = q) (hab : star a * b = 0)
+    (hsum : a * star a + b * star b = q) (m : ℕ) :
+    ∃ A B : E, q * A = A ∧ A * q = A ∧ q * B = B ∧ B * q = B ∧
+      star A * A = q ∧ star B * B = q ∧ star A * B = 0 ∧
+      A * star A + B * star B = q ∧ ∀ i ≤ m, A ^ i * B = x i := by
+  obtain ⟨hqa, haq, hqb, hbq⟩ := relativeCuntzPair_support q a b hq hqq ha hb hab hsum
+  let x' : ℕ → ProjectionCorner q hq hqq := fun i =>
+    projectionCornerElement q hq hqq (x i) (hxs i)
+  let a' : ProjectionCorner q hq hqq := projectionCornerElement q hq hqq a ⟨hqa, haq⟩
+  let b' : ProjectionCorner q hq hqq := projectionCornerElement q hq hqq b ⟨hqb, hbq⟩
+  have hx' (i j : ℕ) : star (x' i) * x' j = if i = j then 1 else 0 := by
+    by_cases hij : i = j
+    · rw [ite_eq_left hij]
+      apply Subtype.ext
+      change star (x i) * x j = q
+      simpa only [ite_eq_left hij] using hx i j
+    · rw [ite_eq_right hij]
+      apply Subtype.ext
+      change star (x i) * x j = 0
+      simpa only [ite_eq_right hij] using hx i j
+  obtain ⟨A, B, hA, hB, hAB, hsum', hencode⟩ := exists_zero_unit_binary_encoding x' hx' a' b'
+    (Subtype.ext ha) (Subtype.ext hb) (Subtype.ext hab) (Subtype.ext hsum) m
+  refine ⟨A, B, A.property.1, A.property.2, B.property.1, B.property.2,
+    congrArg (fun z : ProjectionCorner q hq hqq => (z : E)) hA,
+    congrArg (fun z : ProjectionCorner q hq hqq => (z : E)) hB,
+    congrArg (fun z : ProjectionCorner q hq hqq => (z : E)) hAB,
+    congrArg (fun z : ProjectionCorner q hq hqq => (z : E)) hsum', ?_⟩
+  have hpow (i : ℕ) : ((A ^ i * B : ProjectionCorner q hq hqq) : E) =
+      (A : E) ^ i * (B : E) := by
+    induction i with
+    | zero => simp only [pow_zero, one_mul]
+    | succ i ih =>
+      rw [pow_succ', mul_assoc, pow_succ', mul_assoc]
+      change (A : E) * ((A ^ i * B : ProjectionCorner q hq hqq) : E) = _
+      rw [ih]
+  intro i hi
+  have h := congrArg (fun z : ProjectionCorner q hq hqq => (z : E)) (hencode i hi)
+  rw [hpow] at h
+  exact h
+
+/-- On elements commuting with the initial projection, the filler has
+an exact two-corner formula. This records the term that must be controlled
+by the canonical-shift implementer. -/
+lemma coisometry_range_filler_conjugation (A y x : E)
+    (hA : A * star A = 1) (hx : Commute (star A * A) x) :
+    let C := 1 - star A * A + y * A
+    C * x * star C = (1 - star A * A) * x + y * (A * x * star A) * star y := by
+  intro C
+  let p := star A * A
+  let e := 1 - p
+  have hp : star p = p := by simp only [p, star_mul, star_star]
+  have hpp : p * p = p := by
+    change (star A * A) * (star A * A) = star A * A
+    calc
+      _ = star A * (A * star A) * A := by noncomm_ring
+      _ = _ := by rw [hA, mul_one]
+  have he : star e = e := by simp only [e, star_sub, star_one, hp]
+  have hee : e * e = e := by dsimp only [e]; noncomm_ring [hpp]
+  have hex : Commute e x := (Commute.one_left x).sub_left hx
+  have hAe : A * e = 0 := by
+    have hAp : A * p = A := by
+      change A * (star A * A) = A
+      rw [← mul_assoc, hA, one_mul]
+    dsimp only [e]
+    rw [mul_sub, mul_one, hAp, sub_self]
+  have hestar : e * star A = 0 := by
+    simpa only [star_mul, he, star_zero] using congrArg star hAe
+  have hexe : e * x * e = e * x := by
+    rw [hex.eq, mul_assoc, hee, ← hex.eq]
+  have hexA : e * x * star A = 0 := by
+    rw [hex.eq, mul_assoc, hestar, mul_zero]
+  have hAxe : A * x * e = 0 := by
+    rw [mul_assoc, ← hex.eq, ← mul_assoc, hAe, zero_mul]
+  change (e + y * A) * x * star (e + y * A) = e * x + y * (A * x * star A) * star y
+  rw [star_add, star_mul, he]
+  calc
+    _ = e * x * e + (e * x * star A) * star y +
+        y * (A * x * e) + y * (A * x * star A) * star y := by noncomm_ring
+    _ = _ := by rw [hexe, hexA, hAxe]; simp only [zero_mul, mul_zero, add_zero]
+
+/-- The concrete binary shift filler accepts any unitary inserted before
+the coisometry. Its final projection is independent of that insertion. -/
+lemma binary_shift_shrink_products (r a : Fin 2 → E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (ha : ∀ i j, star (a i) * a j = if i = j then 1 else 0)
+    (has : (∑ i, a i * star (a i)) = 1) (u : unitary E) :
+    let v := (u : E) * finiteCuntzTransfer r a 1
+    let C := 1 - star v * v + r 1 * v
+    star C * C = 1 ∧ C * star C = 1 - r 0 * star (r 0) := by
+  intro v C
+  let A := finiteCuntzTransfer r a 1
+  have hAs : star A = finiteCuntzTransfer a r 1 := by
+    simpa only [A, star_one] using finiteCuntzTransfer_star r a 1
+  have hAA : A * star A = 1 := by
+    have hh := finiteCuntzTransfer_star_mul a r hr 1
+    rw [← hAs, star_star] at hh
+    simpa only [star_one, one_mul, mul_one, has] using hh
+  have hAp : star A * A = ∑ i, r i * star (r i) := by
+    simpa only [A, star_one, one_mul, mul_one] using
+      finiteCuntzTransfer_star_mul r a ha 1
+  have hvv : v * star v = 1 := by
+    change ((u : E) * A) * star ((u : E) * A) = 1
+    rw [star_mul]
+    calc
+      _ = (u : E) * (A * star A) * star (u : E) := by noncomm_ring
+      _ = 1 := by rw [hAA, mul_one, u.property.2]
+  have hvp : star v * v = ∑ i, r i * star (r i) := by
+    change star ((u : E) * A) * ((u : E) * A) = _
+    rw [star_mul]
+    calc
+      _ = star A * (star (u : E) * (u : E)) * A := by noncomm_ring
+      _ = _ := by rw [u.property.1, mul_one, hAp]
+  have hv1 : (star v * v) * r 1 = r 1 := by
+    rw [hvp]
+    simpa only [finiteRowPermutation, Equiv.Perm.one_apply] using
+      finiteRowPermutation_mul_row 1 r (by simp) (by simp) hr 1 1
+  obtain ⟨hC, hCC⟩ := coisometry_range_filler v (r 1) hvv
+    (by simpa only [ite_true] using hr 1 1) hv1
+  refine ⟨hC, ?_⟩
+  rw [hCC, hvp, Fin.sum_univ_two]
+  abel
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OInfinity/ZeroUnitRows.lean

@@ -0,0 +1,138 @@
+import OAI.Analysis.OInfinity.ZeroUnitComparison
+
+namespace OAI
+
+/-! # Finite proper-row comparison through the zero-unit buffer
+
+Only one unused row element is needed for the finite binary encoding.
+The unit and complementary isometries remain explicit throughout.
+-/
+
+noncomputable section
+open scoped CStarAlgebra
+
+namespace WeakPureInfiniteness
+
+variable {E : Type*} [CStarAlgebra E]
+
+/-- The binary encoding construction needs only the tested finite prefix
+and its next unused isometry, rather than a countable row extension. -/
+lemma exists_finite_zero_unit_binary_encoding (n : ℕ)
+    (x : Fin (n + 2) → E)
+    (hx : ∀ i j, star (x i) * x j = if i = j then 1 else 0)
+    (a b : E) (ha : star a * a = 1) (hb : star b * b = 1)
+    (hab : star a * b = 0) (hsum : a * star a + b * star b = 1) :
+    ∃ A B : E, star A * A = 1 ∧ star B * B = 1 ∧ star A * B = 0 ∧
+      A * star A + B * star B = 1 ∧
+      ∀ i : Fin (n + 1), A ^ (i : ℕ) * B = x i.castSucc := by
+  have fill (l : ℕ) (hl : l ≤ n + 1) :
+      ∃ r : Fin (l + 1) → E,
+        (∀ i : Fin l, r i.succ = x ⟨i, by omega⟩) ∧
+        (∀ i j, star (r i) * r j = if i = j then 1 else 0) ∧
+        (∑ i, r i * star (r i)) = 1 := by
+    refine finite_zero_unit_full_row (fun i : Fin l => x ⟨i, by omega⟩)
+      (x ⟨l, by omega⟩) a b ?_ ?_ ?_ ha hb hab hsum
+    · intro i j
+      simpa only [Fin.mk.injEq, Fin.ext_iff] using hx ⟨i, by omega⟩ ⟨j, by omega⟩
+    · simpa only [ite_true] using hx ⟨l, by omega⟩ ⟨l, by omega⟩
+    · intro i
+      have hne : (⟨l, by omega⟩ : Fin (n + 2)) ≠ ⟨i, by omega⟩ := by
+        intro h
+        have he := congrArg Fin.val h
+        change l = (i : ℕ) at he
+        have hi := i.isLt
+        omega
+      simpa only [ite_eq_right hne] using hx ⟨l, by omega⟩ ⟨i, by omega⟩
+  obtain ⟨r, hrleaf, hr, hrs⟩ := fill n (by omega)
+  obtain ⟨R, hRleaf, hR, hRs⟩ := fill (n + 1) (by omega)
+  obtain ⟨A, B, hA, hB, hAB, hsum', hB0, hstep⟩ :=
+    successive_full_rows_binary n r R hr hR hrs hRs
+  have hencode (i : ℕ) (hi : i ≤ n) : A ^ i * B = x ⟨i, by omega⟩ := by
+    induction i with
+    | zero => simpa only [pow_zero, one_mul, Fin.val_zero] using hB0.trans (hRleaf 0)
+    | succ i ih =>
+      rw [pow_succ', mul_assoc, ih (by omega)]
+      have h := hstep (⟨i, by omega⟩ : Fin n)
+      rw [hrleaf, hRleaf] at h
+      exact h
+  refine ⟨A, B, hA, hB, hAB, hsum', fun i => ?_⟩
+  exact hencode i (by omega)
+
+/-- Finite encoding in an actual projection corner. In particular this
+applies to a proper prefix of the finite coisometric vacuum-split row. -/
+lemma exists_relative_finite_zero_unit_binary_encoding (n : ℕ)
+    (q : E) (hq : star q = q) (hqq : q * q = q)
+    (x : Fin (n + 2) → E) (a b : E)
+    (hxs : ∀ i, q * x i = x i ∧ x i * q = x i)
+    (hx : ∀ i j, star (x i) * x j = if i = j then q else 0)
+    (ha : star a * a = q) (hb : star b * b = q) (hab : star a * b = 0)
+    (hsum : a * star a + b * star b = q) :
+    ∃ A B : E, q * A = A ∧ A * q = A ∧ q * B = B ∧ B * q = B ∧
+      star A * A = q ∧ star B * B = q ∧ star A * B = 0 ∧
+      A * star A + B * star B = q ∧
+      ∀ i : Fin (n + 1), A ^ (i : ℕ) * B = x i.castSucc := by
+  obtain ⟨hqa, haq, hqb, hbq⟩ := relativeCuntzPair_support q a b hq hqq ha hb hab hsum
+  let x' : Fin (n + 2) → ProjectionCorner q hq hqq := fun i =>
+    projectionCornerElement q hq hqq (x i) (hxs i)
+  let a' : ProjectionCorner q hq hqq := projectionCornerElement q hq hqq a ⟨hqa, haq⟩
+  let b' : ProjectionCorner q hq hqq := projectionCornerElement q hq hqq b ⟨hqb, hbq⟩
+  have hx' : ∀ i j, star (x' i) * x' j = if i = j then 1 else 0 :=
+    projectionCornerElement_gram q hq hqq x hxs hx
+  obtain ⟨A, B, hA, hB, hAB, hsum', he⟩ := exists_finite_zero_unit_binary_encoding n x' hx'
+    a' b' (Subtype.ext ha) (Subtype.ext hb) (Subtype.ext hab) (Subtype.ext hsum)
+  refine ⟨A, B, A.property.1, A.property.2, B.property.1, B.property.2,
+    congrArg (fun z : ProjectionCorner q hq hqq => (z : E)) hA,
+    congrArg (fun z : ProjectionCorner q hq hqq => (z : E)) hB,
+    congrArg (fun z : ProjectionCorner q hq hqq => (z : E)) hAB,
+    congrArg (fun z : ProjectionCorner q hq hqq => (z : E)) hsum', fun i => ?_⟩
+  let f := projectionCornerInclusion q hq hqq
+  have hh := congrArg f (he i)
+  rw [nonunital_map_pow_mul] at hh
+  exact hh
+
+/-- A finite proper row in the buffer commutant has a connected ambient
+comparison with the corresponding negative buffer prefix. Its initial unit
+is carried to the buffer unit exactly. -/
+lemma exists_finite_zeroUnit_buffer_comparison [Nontrivial E]
+    (r : ℕ → E)
+    (hr : ∀ i j, star (r i) * r j = if i = j then 1 else 0)
+    (q w z : StarSubalgebra.centralizer ℂ (Set.range r))
+    (hq : star q = q) (hqq : q * q = q) (hq0 : q ≠ 0)
+    (hw : star w * w = 1) (hww : w * star w = 1 - q)
+    (hz : star z * z = 1) (hqz : q * z = z)
+    (n : ℕ) (x : Fin (n + 2) → StarSubalgebra.centralizer ℂ (Set.range r))
+    (hxs : ∀ i, q * x i = x i ∧ x i * q = x i)
+    (hx : ∀ i j, star (x i) * x j = if i = j then q else 0)
+    (a b : StarSubalgebra.centralizer ℂ (Set.range r))
+    (ha : star a * a = q) (hb : star b * b = q) (hab : star a * b = 0)
+    (hsum : a * star a + b * star b = q)
+    (ε : ℝ) (hε : 0 < ε) :
+    ∃ u : unitary E, Joined (1 : unitary E) u ∧
+      (u : E) * (q : E) * star (u : E) = canonicalTailProjection r 1 ∧
+      ∀ i : Fin (n + 1), ‖(u : E) * (x i.castSucc : E) * star (u : E) -
+        canonicalNegativeRow r i‖ < ε := by
+  let C := StarSubalgebra.centralizer ℂ (Set.range r)
+  let : IsClosed (C : Set E) := Set.isClosed_centralizer _
+  obtain ⟨A, B, _hAl, _hAr, _hBl, _hBr, hA, hB, hAB, hsum', he⟩ :=
+    exists_relative_finite_zero_unit_binary_encoding n q hq hqq x a b hxs hx ha hb hab hsum
+  let c : Fin 2 → C := ![A, B]
+  have hBA : star B * A = 0 := by
+    simpa only [star_mul, star_star, star_zero] using congrArg star hAB
+  have hc (i j : Fin 2) : star (c i) * c j = if i = j then q else 0 := by
+    fin_cases i <;> fin_cases j <;> simp [c, hA, hB, hAB, hBA]
+  have hcs : (∑ i, c i * star (c i)) = q := by
+    simpa only [Fin.sum_univ_two, c, Matrix.cons_val_zero, Matrix.cons_val_one] using hsum'
+  obtain ⟨u, hu, huq, huclose⟩ := exists_zeroUnit_buffer_comparison_with_unit
+    r hr q w z hq hqq hq0 hw hww hz hqz c hc hcs n ε hε
+  refine ⟨u, hu, huq, fun i => ?_⟩
+  have heE : (A : E) ^ (i : ℕ) * (B : E) = (x i.castSucc : E) := by
+    have hh := congrArg C.subtype (he i)
+    simpa only [map_pow, map_mul, StarSubalgebra.subtype_apply] using hh
+  have hh := huclose i (by omega)
+  simpa only [c, Matrix.cons_val_zero, Matrix.cons_val_one, heE] using hh
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/AntiunitaryCPConjugation.lean

@@ -0,0 +1,116 @@
+import OAI.Analysis.ModularRecovery.TomitaResolvent
+import OAI.Analysis.Nuclearity.CPWeakOperatorUltralimit
+
+namespace OAI
+
+/-! Conjugating an operator-valued completely positive map on both sides
+by an involutive antiunitary preserves complete positivity. This is the
+operator calculation needed to transfer a commutant expectation across
+Tomita conjugation. -/
+
+noncomputable section
+open scoped InnerProductSpace CStarAlgebra ComplexOrder ComplexConjugate
+
+namespace WeakPureInfiniteness
+
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+def antiunitaryConjugate (J : H ≃ₗᵢ⋆[ℂ] H) (T : H →L[ℂ] H) : H →L[ℂ] H where
+  toFun x := J (T (J x))
+  map_add' _ _ := by simp only [map_add]
+  map_smul' c x := by
+    simp only [map_smulₛₗ, starRingEnd_self_apply, RingHom.id_apply]
+  cont := J.continuous.comp (T.continuous.comp J.continuous)
+
+omit [CompleteSpace H] in
+@[simp] lemma antiunitaryConjugate_apply (J : H ≃ₗᵢ⋆[ℂ] H) (T : H →L[ℂ] H) (x : H) :
+    antiunitaryConjugate J T x = J (T (J x)) := rfl
+
+omit [CompleteSpace H] in
+@[simp] lemma antiunitaryConjugate_add (J : H ≃ₗᵢ⋆[ℂ] H) (T U : H →L[ℂ] H) :
+    antiunitaryConjugate J (T + U) = antiunitaryConjugate J T + antiunitaryConjugate J U := by
+  ext x
+  simp only [antiunitaryConjugate_apply, add_apply, map_add]
+
+omit [CompleteSpace H] in
+@[simp] lemma antiunitaryConjugate_smul (J : H ≃ₗᵢ⋆[ℂ] H) (c : ℂ) (T : H →L[ℂ] H) :
+    antiunitaryConjugate J (c • T) = star c • antiunitaryConjugate J T := by
+  ext x
+  simp only [antiunitaryConjugate_apply, smul_apply,
+    map_smulₛₗ, starRingEnd_apply]
+
+omit [CompleteSpace H] in
+lemma antiunitaryConjugate_involutive (J : H ≃ₗᵢ⋆[ℂ] H) (hJ : Function.Involutive J)
+    (T : H →L[ℂ] H) : antiunitaryConjugate J (antiunitaryConjugate J T) = T := by
+  ext x
+  simp only [antiunitaryConjugate_apply]
+  rw [hJ x, hJ (T x)]
+
+omit [CompleteSpace H] in
+lemma antiunitaryConjugate_norm_le (J : H ≃ₗᵢ⋆[ℂ] H) (T : H →L[ℂ] H) :
+    ‖antiunitaryConjugate J T‖ ≤ ‖T‖ := by
+  apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg T)
+  intro x
+  simpa only [antiunitaryConjugate_apply, J.norm_map] using T.le_opNorm (J x)
+
+def antiunitaryMatrix (J : H ≃ₗᵢ⋆[ℂ] H) {n : Type*}
+    (X : CStarMatrix n n (H →L[ℂ] H)) : CStarMatrix n n (H →L[ℂ] H) :=
+  CStarMatrix.ofMatrix (fun i j => antiunitaryConjugate J (X i j))
+
+lemma antiunitaryMatrix_nonneg (J : H ≃ₗᵢ⋆[ℂ] H) (hJ : Function.Involutive J)
+    {n : Type*} [Fintype n] (X : CStarMatrix n n (H →L[ℂ] H)) (hX : 0 ≤ X) :
+    0 ≤ antiunitaryMatrix J X := by
+  apply (NonUnitalStarAlgHom.map_le_map_iff
+    (matrixOperatorHom (n := n) (H := H)) matrixOperator_injective).mp
+  rw [map_zero]
+  apply ContinuousLinearMap.nonneg_iff_isPositive.mpr
+  rw [ContinuousLinearMap.isPositive_iff_complex]
+  intro x
+  let y : PiLp 2 (fun _ : n => H) := WithLp.toLp 2 (fun i => J (x i))
+  have he : inner ℂ (matrixOperator (antiunitaryMatrix J X) x) x =
+      star (inner ℂ (matrixOperator X y) y) := by
+    simp only [PiLp.inner_apply, matrixOperator_apply, sum_inner, star_sum]
+    apply Finset.sum_congr rfl
+    intro i _
+    apply Finset.sum_congr rfl
+    intro j _
+    change inner ℂ (J (X i j (J (x j)))) (x i) =
+      star (inner ℂ (X i j (J (x j))) (J (x i)))
+    conv_lhs => rw [← hJ (x i)]
+    exact BoundedRecovery.antiunitary_inner J _ _
+  have hp := (ContinuousLinearMap.nonneg_iff_isPositive.mp
+    (map_nonneg (matrixOperatorHom (n := n) (H := H)) hX)).inner_nonneg_left y
+  have hn : 0 ≤ inner ℂ (matrixOperator (antiunitaryMatrix J X) x) x := by
+    rw [he]
+    exact star_nonneg_iff.mpr hp
+  exact ⟨Complex.ext rfl hn.2, hn.1⟩
+
+def antiunitaryCPConjugate (J : H ≃ₗᵢ⋆[ℂ] H)
+    (P : (H →L[ℂ] H) →L[ℂ] (H →L[ℂ] H)) :
+    (H →L[ℂ] H) →L[ℂ] (H →L[ℂ] H) :=
+  LinearMap.mkContinuous
+    { toFun := fun T => antiunitaryConjugate J (P (antiunitaryConjugate J T))
+      map_add' := by intros; simp only [antiunitaryConjugate_add, map_add]
+      map_smul' := by intros; simp only [antiunitaryConjugate_smul, map_smul, star_star,
+        RingHom.id_apply] }
+    ‖P‖ (fun T => (antiunitaryConjugate_norm_le J _).trans
+      ((P.le_opNorm _).trans (mul_le_mul_of_nonneg_left
+        (antiunitaryConjugate_norm_le J T) (norm_nonneg P))))
+
+lemma antiunitaryCPConjugate_norm_le (J : H ≃ₗᵢ⋆[ℂ] H)
+    (P : (H →L[ℂ] H) →L[ℂ] (H →L[ℂ] H)) :
+    ‖antiunitaryCPConjugate J P‖ ≤ ‖P‖ :=
+  LinearMap.mkContinuous_norm_le _ (norm_nonneg P) _
+
+lemma antiunitaryCPConjugate_cp (J : H ≃ₗᵢ⋆[ℂ] H) (hJ : Function.Involutive J)
+    (P : (H →L[ℂ] H) →L[ℂ] (H →L[ℂ] H)) (hP : CompletelyPositive P) :
+    CompletelyPositive (antiunitaryCPConjugate J P) := by
+  intro n X hX
+  exact antiunitaryMatrix_nonneg J hJ (matrixLinearMap P (antiunitaryMatrix J X))
+    (hP n _ (antiunitaryMatrix_nonneg J hJ X hX))
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/AntiunitaryOperatorIdentities.lean

@@ -0,0 +1,52 @@
+import OAI.Analysis.OperatorAlgebra.AntiunitaryCPConjugation
+
+namespace OAI
+
+/-! Multiplication and adjoints under an actual involutive antiunitary. -/
+noncomputable section
+open scoped InnerProductSpace ComplexConjugate
+namespace WeakPureInfiniteness
+
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+omit [CompleteSpace H] in
+lemma antiunitaryConjugate_mul (J : H ≃ₗᵢ⋆[ℂ] H) (hJ : Function.Involutive J)
+    (a b : H →L[ℂ] H) :
+    antiunitaryConjugate J (a * b) = antiunitaryConjugate J a * antiunitaryConjugate J b := by
+  apply ContinuousLinearMap.ext
+  intro x
+  simp only [antiunitaryConjugate_apply, mul_apply_eq_comp]
+  rw [hJ (b (J x))]
+
+lemma antiunitaryConjugate_star (J : H ≃ₗᵢ⋆[ℂ] H) (hJ : Function.Involutive J)
+    (a : H →L[ℂ] H) :
+    antiunitaryConjugate J (star a) = star (antiunitaryConjugate J a) := by
+  apply (ContinuousLinearMap.eq_adjoint_iff _ _).mpr
+  intro x y
+  change inner ℂ (J (star a (J x))) y = inner ℂ x (J (a (J y)))
+  calc
+    _ = star (inner ℂ (star a (J x)) (J y)) := by
+      conv_lhs => rw [← hJ y]
+      exact BoundedRecovery.antiunitary_inner J _ _
+    _ = star (inner ℂ (J x) (a (J y))) :=
+      congrArg star (ContinuousLinearMap.adjoint_inner_left a (J y) (J x))
+    _ = _ := by
+      have h := BoundedRecovery.antiunitary_inner J (J x) (a (J y))
+      simpa only [hJ x] using h.symm
+
+lemma antiunitaryConjugate_isStarProjection (J : H ≃ₗᵢ⋆[ℂ] H)
+    (hJ : Function.Involutive J) (p : H →L[ℂ] H) (hp : IsStarProjection p) :
+    IsStarProjection (antiunitaryConjugate J p) where
+  isSelfAdjoint := by
+    change star (antiunitaryConjugate J p) = antiunitaryConjugate J p
+    rw [← antiunitaryConjugate_star J hJ, hp.isSelfAdjoint.star_eq]
+  isIdempotentElem := by
+    change antiunitaryConjugate J p * antiunitaryConjugate J p = antiunitaryConjugate J p
+    rw [← antiunitaryConjugate_mul J hJ]
+    exact congrArg (antiunitaryConjugate J) hp.isIdempotentElem
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/BicommutantStrongStar.lean

@@ -0,0 +1,93 @@
+import OAI.Analysis.IrrationalRotation.Operators.BicommutantDensity
+
+namespace OAI
+
+/-! Finite simultaneous strong approximation of an operator and its adjoint.
+Only the algebraic star subalgebra is used; no norm bound is asserted. -/
+
+noncomputable section
+open scoped BigOperators InnerProductSpace
+
+namespace WeakPureInfiniteness
+open Invariant233.BicommutantDensity
+
+variable {H I : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+  [CompleteSpace H] [Fintype I]
+
+private def pairedOrbit (A : StarSubalgebra ℂ (H →L[ℂ] H)) (x y : I → H) :
+    A →ₗ[ℝ] PiLp 2 (fun _ : I ⊕ I => H) where
+  toFun a := WithLp.toLp 2 (Sum.elim (fun i => (a : H →L[ℂ] H) (x i))
+    (fun i => (star (a : H →L[ℂ] H)) (y i)))
+  map_add' a b := by ext i; cases i <;> simp
+  map_smul' t a := by
+    ext i
+    cases i <;> simp [StarModule.star_smul]
+
+theorem pairedOrbit_mem_closure
+    (A : StarSubalgebra ℂ (H →L[ℂ] H)) {T : H →L[ℂ] H}
+    (hT : T ∈ Set.centralizer (Set.centralizer (A : Set (H →L[ℂ] H))))
+    (x y : I → H) :
+    WithLp.toLp 2 (Sum.elim (fun i => T (x i)) (fun i => star T (y i))) ∈
+      closure (Set.range (fun a : A => pairedOrbit A x y a)) := by
+  classical
+  let : InnerProductSpace ℝ (PiLp 2 (fun _ : I ⊕ I => H)) :=
+    InnerProductSpace.rclikeToReal ℂ _
+  let R := (pairedOrbit A x y).range
+  change _ ∈ R.topologicalClosure
+  rw [← R.orthogonal_orthogonal_eq_closure]
+  apply (Rᗮ.mem_orthogonal _).mpr
+  intro η hη
+  let ζ : PiLp 2 (fun _ : I ⊕ I => H) :=
+    WithLp.toLp 2 (Sum.elim x (fun i => η (.inr i)))
+  let g : PiLp 2 (fun _ : I ⊕ I => H) → ℝ := fun z =>
+    ∑ i, (inner ℂ (η (.inl i)) (z (.inl i))).re +
+    ∑ i, (inner ℂ (z (.inr i)) (y i)).re
+  have hg : Continuous g := by dsimp [g]; fun_prop
+  have hadj (a : H →L[ℂ] H) (i : I) :
+      inner ℂ (η (.inr i)) (star a (y i)) = inner ℂ (a (η (.inr i))) (y i) := by
+    rw [ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_right]
+  have hzero (a : A) : g (amplify (I ⊕ I) (a : H →L[ℂ] H) ζ) = 0 := by
+    have hz := (R.mem_orthogonal' η).mp hη (pairedOrbit A x y a) ⟨a, rfl⟩
+    rw [real_inner_eq_re_inner ℂ, PiLp.inner_apply] at hz
+    simpa [g, ζ, pairedOrbit, Fintype.sum_sum_type, Complex.re_sum, hadj] using hz
+  have hcl : amplify (I ⊕ I) T ζ ∈
+      closure (Set.range (fun a : A => amplify (I ⊕ I) (a : H →L[ℂ] H) ζ)) := by
+    apply Metric.mem_closure_iff.mpr
+    intro ε hε
+    obtain ⟨a, ha, hclose⟩ := exists_amplified_approximation A hT ζ hε
+    exact ⟨_, ⟨⟨a, ha⟩, rfl⟩, by simpa [dist_eq_norm, norm_sub_rev] using hclose⟩
+  have hclosed : IsClosed {z : PiLp 2 (fun _ : I ⊕ I => H) | g z = 0} :=
+    isClosed_eq hg continuous_const
+  have ht : g (amplify (I ⊕ I) T ζ) = 0 :=
+    hclosed.closure_subset_iff.mpr (by rintro _ ⟨a, rfl⟩; exact hzero a) hcl
+  rw [real_inner_eq_re_inner ℂ, PiLp.inner_apply]
+  simpa [g, ζ, Fintype.sum_sum_type, Complex.re_sum, hadj] using ht
+
+theorem exists_finite_strongStar_approximation
+    (A : StarSubalgebra ℂ (H →L[ℂ] H)) {T : H →L[ℂ] H}
+    (hT : T ∈ Set.centralizer (Set.centralizer (A : Set (H →L[ℂ] H))))
+    (x y : I → H) {ε : ℝ} (hε : 0 < ε) :
+    ∃ a : H →L[ℂ] H, a ∈ A ∧
+      (∀ i, ‖a (x i) - T (x i)‖ < ε) ∧
+      (∀ i, ‖star a (y i) - star T (y i)‖ < ε) := by
+  obtain ⟨z, ⟨a, rfl⟩, hclose⟩ := Metric.mem_closure_iff.mp
+    (pairedOrbit_mem_closure A hT x y) ε hε
+  rw [dist_eq_norm] at hclose
+  rw [norm_sub_rev] at hclose
+  refine ⟨a, a.property, ?_, ?_⟩
+  · intro i
+    have h := PiLp.norm_apply_le
+      (pairedOrbit A x y a - WithLp.toLp 2
+        (Sum.elim (fun i => T (x i)) (fun i => star T (y i)))) (.inl i)
+    exact h.trans_lt hclose
+  · intro i
+    have h := PiLp.norm_apply_le
+      (pairedOrbit A x y a - WithLp.toLp 2
+        (Sum.elim (fun i => T (x i)) (fun i => star T (y i)))) (.inr i)
+    exact h.trans_lt hclose
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/CanonicalLpOperations.lean

@@ -0,0 +1,48 @@
+import OAI.Analysis.OperatorAlgebra.LpOperatorStructure
+import OAI.Analysis.OperatorAlgebra.LpOperatorTensorBound
+
+namespace OAI
+
+/-! Algebraic and norm identities for the canonical L² operator conversion. -/
+noncomputable section
+open MeasureTheory
+namespace WeakPureInfiniteness
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+
+lemma canonicalLpOperator_norm (T : HilbertOperatorSpace (Lp H 2 (volume : Measure ℝ))) :
+    ‖canonicalLpOperator T‖ = ‖T‖ := rfl
+
+lemma norm_le_canonicalLpOperator
+    (T : Lp H 2 (volume : Measure ℝ) →L[ℂ] Lp H 2 (volume : Measure ℝ))
+    {c : ℝ} (h : c ≤ ‖T‖) : c ≤ ‖canonicalLpOperator T‖ :=
+  h.trans_eq (canonicalLpOperator_norm T).symm
+
+lemma canonicalLpOperator_sum {I : Type*} [Fintype I]
+    (T : I → HilbertOperatorSpace (Lp H 2 (volume : Measure ℝ))) :
+    canonicalLpOperator (∑ i, T i) = ∑ i, canonicalLpOperator (T i) := by
+  classical
+  apply ContinuousLinearMap.ext
+  intro x
+  simp only [canonicalLpOperator_apply, sum_apply]
+
+lemma canonicalLpOperator_tensor_bound [CompleteSpace H] {I : Type*} [Fintype I]
+    (l r a b : I → HilbertOperatorSpace (Lp H 2 (volume : Measure ℝ)))
+    (h : hilbertOperatorTensorBound l r a b) :
+    ‖∑ i, canonicalLpOperator (l i) * canonicalLpOperator (r i)‖ ≤
+      ‖∑ i, minimalElementary (canonicalLpOperator (a i))
+        (MulOpposite.op (canonicalLpOperator (b i)))‖ := by
+  simpa only [canonicalLpOperator_eq] using lp_operator_tensor_bound l r a b h
+
+lemma canonicalLpOperator_sum_bound [CompleteSpace H] {I : Type*} [Fintype I]
+    (l r a b : I → Lp H 2 (volume : Measure ℝ) →L[ℂ] Lp H 2 (volume : Measure ℝ))
+    (h : ‖canonicalLpOperator (∑ i, l i * r i)‖ ≤
+      ‖∑ i, minimalElementary (canonicalLpOperator (a i))
+        (MulOpposite.op (canonicalLpOperator (b i)))‖) :
+    ‖∑ i, l i * r i‖ ≤ ‖∑ i, minimalElementary (a i) (MulOpposite.op (b i))‖ := by
+  simpa only [canonicalLpOperator_eq] using h
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/ComplexSymmetricMean.lean

@@ -0,0 +1,118 @@
+import OAI.Analysis.ModularRecovery.Mean
+
+namespace OAI
+
+/-! The complex linear version of the proved symmetric-interval mean.
+It is positive, normalized and translation invariant for a free ultrafilter. -/
+
+noncomputable section
+open Filter
+open scoped ComplexOrder
+
+namespace WeakPureInfiniteness
+open BoundedRecovery
+
+private def meanRealPart (f : BoundedContinuousFunction ℝ ℂ) :
+    BoundedContinuousFunction ℝ ℝ := Complex.reCLM.compLeftContinuousBounded ℝ f
+
+private def meanImagPart (f : BoundedContinuousFunction ℝ ℂ) :
+    BoundedContinuousFunction ℝ ℝ := Complex.imCLM.compLeftContinuousBounded ℝ f
+
+def complexSymmetricMean (ω : Ultrafilter ℕ) (f : BoundedContinuousFunction ℝ ℂ) : ℂ :=
+  (fixedMean ω (meanRealPart f) : ℂ) + (fixedMean ω (meanImagPart f) : ℂ) * Complex.I
+
+lemma complexSymmetricMean_add (ω : Ultrafilter ℕ)
+    (f g : BoundedContinuousFunction ℝ ℂ) :
+    complexSymmetricMean ω (f + g) = complexSymmetricMean ω f + complexSymmetricMean ω g := by
+  have hr : meanRealPart (f + g) = meanRealPart f + meanRealPart g := by ext t; simp [meanRealPart]
+  have hi : meanImagPart (f + g) = meanImagPart f + meanImagPart g := by ext t; simp [meanImagPart]
+  unfold complexSymmetricMean
+  rw [hr, hi]
+  change ((meanCLM ω) (meanRealPart f + meanRealPart g) : ℂ) +
+    ((meanCLM ω) (meanImagPart f + meanImagPart g) : ℂ) * Complex.I = _
+  rw [map_add, map_add]
+  simp only [Complex.ofReal_add, meanCLM_apply]
+  ring
+
+lemma complexSymmetricMean_smul (ω : Ultrafilter ℕ)
+    (c : ℂ) (f : BoundedContinuousFunction ℝ ℂ) :
+    complexSymmetricMean ω (c • f) = c * complexSymmetricMean ω f := by
+  have hr : meanRealPart (c • f) = c.re • meanRealPart f - c.im • meanImagPart f := by
+    ext t
+    simp [meanRealPart, meanImagPart, Complex.mul_re]
+  have hi : meanImagPart (c • f) = c.re • meanImagPart f + c.im • meanRealPart f := by
+    ext t
+    simp [meanRealPart, meanImagPart, Complex.mul_im]
+  unfold complexSymmetricMean
+  rw [hr, hi]
+  change ((meanCLM ω) (c.re • meanRealPart f - c.im • meanImagPart f) : ℂ) +
+    ((meanCLM ω) (c.re • meanImagPart f + c.im • meanRealPart f) : ℂ) * Complex.I = _
+  rw [map_sub, map_add, map_smul, map_smul, map_smul, map_smul]
+  apply Complex.ext <;> simp [Complex.mul_re, Complex.mul_im]
+
+lemma complexSymmetricMean_norm_le (ω : Ultrafilter ℕ)
+    (f : BoundedContinuousFunction ℝ ℂ) : ‖complexSymmetricMean ω f‖ ≤ 2 * ‖f‖ := by
+  have hr : ‖meanRealPart f‖ ≤ ‖f‖ := by
+    apply (BoundedContinuousFunction.norm_le (norm_nonneg f)).mpr
+    intro t
+    exact (Complex.abs_re_le_norm (f t)).trans (f.norm_coe_le_norm t)
+  have hi : ‖meanImagPart f‖ ≤ ‖f‖ := by
+    apply (BoundedContinuousFunction.norm_le (norm_nonneg f)).mpr
+    intro t
+    exact (Complex.abs_im_le_norm (f t)).trans (f.norm_coe_le_norm t)
+  calc
+    _ ≤ ‖(fixedMean ω (meanRealPart f) : ℂ)‖ +
+        ‖(fixedMean ω (meanImagPart f) : ℂ) * Complex.I‖ := norm_add_le _ _
+    _ = ‖fixedMean ω (meanRealPart f)‖ + ‖fixedMean ω (meanImagPart f)‖ := by simp
+    _ ≤ ‖f‖ + ‖f‖ := add_le_add ((norm_fixedMean_le ω _).trans hr) ((norm_fixedMean_le ω _).trans hi)
+    _ = _ := by ring
+
+def complexSymmetricMeanCLM (ω : Ultrafilter ℕ) : BoundedContinuousFunction ℝ ℂ →L[ℂ] ℂ :=
+  LinearMap.mkContinuous
+    { toFun := complexSymmetricMean ω
+      map_add' := complexSymmetricMean_add ω
+      map_smul' := complexSymmetricMean_smul ω }
+    2 (complexSymmetricMean_norm_le ω)
+
+lemma complexSymmetricMean_const (ω : Ultrafilter ℕ) (hω : (ω : Filter ℕ) ≤ atTop) (c : ℂ) :
+    complexSymmetricMean ω (BoundedContinuousFunction.const ℝ c) = c := by
+  have hr : meanRealPart (BoundedContinuousFunction.const ℝ c) =
+      BoundedContinuousFunction.const ℝ c.re := rfl
+  have hi : meanImagPart (BoundedContinuousFunction.const ℝ c) =
+      BoundedContinuousFunction.const ℝ c.im := rfl
+  simp only [complexSymmetricMean, hr, hi, BoundedContinuousFunction.const_apply,
+    fixedMean_const ω hω, Complex.re_add_im]
+
+def complexTranslateBCF (f : BoundedContinuousFunction ℝ ℂ) (s : ℝ) :
+    BoundedContinuousFunction ℝ ℂ :=
+  f.compContinuous ⟨fun t => t + s, continuous_id.add continuous_const⟩
+
+lemma complexSymmetricMean_translate (ω : Ultrafilter ℕ) (hω : (ω : Filter ℕ) ≤ atTop)
+    (f : BoundedContinuousFunction ℝ ℂ) (s : ℝ) :
+    complexSymmetricMean ω (complexTranslateBCF f s) = complexSymmetricMean ω f := by
+  have hr : meanRealPart (complexTranslateBCF f s) = translateBCF (meanRealPart f) s := rfl
+  have hi : meanImagPart (complexTranslateBCF f s) = translateBCF (meanImagPart f) s := rfl
+  simp only [complexSymmetricMean, hr, hi, fixedMean_translate ω hω]
+
+lemma complexSymmetricMean_nonneg (ω : Ultrafilter ℕ) (hω : (ω : Filter ℕ) ≤ atTop)
+    (f : BoundedContinuousFunction ℝ ℂ) (hf : ∀ t, 0 ≤ f t) :
+    0 ≤ complexSymmetricMean ω f := by
+  have hi : meanImagPart f = 0 := by
+    ext t
+    exact (Complex.le_def.mp (hf t)).2.symm
+  have hr : 0 ≤ fixedMean ω (meanRealPart f) := by
+    have h := fixedMean_mono ω (BoundedContinuousFunction.const ℝ 0) (meanRealPart f)
+      (fun t => (Complex.le_def.mp (hf t)).1)
+    change fixedMean ω (fun _ : ℝ => 0) ≤ _ at h
+    rw [fixedMean_const ω hω] at h
+    exact h
+  simp only [complexSymmetricMean, hi]
+  have hz : fixedMean ω (0 : BoundedContinuousFunction ℝ ℝ) = 0 := (meanCLM ω).map_zero
+  rw [hz, Complex.ofReal_zero, zero_mul, add_zero]
+  exact_mod_cast hr
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/ContinuousLpFieldNorm.lean

@@ -0,0 +1,82 @@
+import OAI.Analysis.ModularTheory.LpFaithful
+
+namespace OAI
+
+/-! A continuous operator field is bounded pointwise by its represented L2
+operator. The proof tests a constant vector on a small positive-measure interval. -/
+noncomputable section
+open MeasureTheory Set
+open scoped Topology ENNReal
+namespace WeakPureInfiniteness
+
+variable {H : Type*} [NormedAddCommGroup H] [NormedSpace ℂ H]
+
+lemma continuousLpField_apply_norm_le
+    (T : Lp H 2 (volume : Measure ℝ) →L[ℂ] Lp H 2 (volume : Measure ℝ))
+    (F : ℝ → H →L[ℂ] H)
+    (hF : ∀ f, T f =ᵐ[volume] fun t => F t (f t))
+    (t₀ : ℝ) (x : H) (hc : ContinuousAt (fun t => F t x) t₀) :
+    ‖F t₀ x‖ ≤ ‖T‖ * ‖x‖ := by
+  by_contra hn
+  have hn' : ‖T‖ * ‖x‖ < ‖F t₀ x‖ := lt_of_not_ge hn
+  let c := (‖T‖ * ‖x‖ + ‖F t₀ x‖) / 2
+  have hc₁ : ‖T‖ * ‖x‖ < c := by dsimp [c]; linarith
+  have hc₂ : c < ‖F t₀ x‖ := by dsimp [c]; linarith
+  have hc₀ : 0 ≤ c := (mul_nonneg (norm_nonneg _) (norm_nonneg _)).trans hc₁.le
+  obtain ⟨δ, hδ, hd⟩ := Metric.continuousAt_iff.mp hc.norm
+    (‖F t₀ x‖ - c) (sub_pos.mpr hc₂)
+  let l := t₀ - δ / 2
+  let r := t₀ + δ / 2
+  have hlr : l < r := by dsimp [l, r]; linarith
+  have hs : MeasurableSet (Ioo l r) := measurableSet_Ioo
+  have hm : volume (Ioo l r) ≠ ⊤ := by simp
+  let f : Lp H 2 (volume : Measure ℝ) := indicatorConstLp 2 hs hm x
+  let g : Lp ℝ 2 (volume : Measure ℝ) := indicatorConstLp 2 hs hm c
+  have he : ‖g‖ ≤ ‖T f‖ := by
+    apply Lp.norm_le_norm_of_ae_le
+    filter_upwards [hF f,
+      indicatorConstLp_coeFn (p := 2) (hs := hs) (hμs := hm) (c := x),
+      indicatorConstLp_coeFn (p := 2) (hs := hs) (hμs := hm) (c := c)]
+      with t hT hf hg
+    change ‖g t‖ ≤ ‖T f t‖
+    rw [hg]
+    by_cases ht : t ∈ Ioo l r
+    · rw [indicator_of_mem ht, Real.norm_eq_abs, abs_of_nonneg hc₀, hT]
+      have hft : f t = x := hf.trans (indicator_of_mem ht _)
+      rw [hft]
+      have htδ : dist t t₀ < δ := by
+        rw [Real.dist_eq, abs_lt]
+        dsimp [l, r] at ht
+        constructor <;> linarith [ht.1, ht.2]
+      have hnorm := hd htδ
+      rw [Real.dist_eq] at hnorm
+      have hbelow := (abs_lt.mp hnorm).1
+      linarith
+    · rw [indicator_of_notMem ht, norm_zero]
+      exact norm_nonneg _
+  have he' := he.trans (T.le_opNorm f)
+  have hr : 0 < volume.real (Ioo l r) := by
+    rw [Real.volume_real_Ioo_of_le hlr.le]
+    exact sub_pos.mpr hlr
+  have hw : 0 < volume.real (Ioo l r) ^ (1 / (2 : ℝ≥0∞).toReal) :=
+    Real.rpow_pos_of_pos hr _
+  change ‖indicatorConstLp 2 hs hm c‖ ≤ ‖T‖ * ‖indicatorConstLp 2 hs hm x‖ at he'
+  rw [norm_indicatorConstLp (by norm_num) (by norm_num),
+    norm_indicatorConstLp (by norm_num) (by norm_num), Real.norm_eq_abs,
+    abs_of_nonneg hc₀, ← mul_assoc] at he'
+  exact (not_le_of_gt hc₁) ((mul_le_mul_iff_left₀ hw).mp he')
+
+lemma continuousLpField_norm_le
+    (T : Lp H 2 (volume : Measure ℝ) →L[ℂ] Lp H 2 (volume : Measure ℝ))
+    (F : ℝ → H →L[ℂ] H)
+    (hF : ∀ f, T f =ᵐ[volume] fun t => F t (f t))
+    (t₀ : ℝ) (hc : ∀ x, ContinuousAt (fun t => F t x) t₀) :
+    ‖F t₀‖ ≤ ‖T‖ :=
+  (F t₀).opNorm_le_bound (norm_nonneg T)
+    (fun x => continuousLpField_apply_norm_le T F hF t₀ x (hc x))
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/CyclicCoefficientApproximation.lean

@@ -0,0 +1,63 @@
+import OAI.Analysis.PureInfiniteness.NonunitalFunctionalRepresentation
+import OAI.Analysis.Nuclearity.UnitizedCoefficients
+
+namespace OAI
+
+/-! The finite cyclic-vector approximation in KR02 Lemma 7.18. The cyclic
+representation is on the unitization, so this applies to nonunital algebras
+without assuming cyclicity of their restricted representations. -/
+
+noncomputable section
+open scoped BigOperators InnerProductSpace Topology ComplexOrder
+
+namespace WeakPureInfiniteness
+
+variable {D H I J : Type*} [NonUnitalCStarAlgebra D]
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [Fintype I] [Fintype J]
+
+lemma finite_quadratic_coefficient_approximation
+    (π : Unitization ℂ D →⋆ₐ[ℂ] (H →L[ℂ] H)) (ξ : H)
+    (hcyc : DenseRange (fun a => π a ξ))
+    (L : J → I → I → H →L[ℂ] H) (k : I → H) (ε : ℝ) (hε : 0 < ε) :
+    ∃ a : I → Unitization ℂ D,
+      ‖(fun j => ∑ i, ∑ r, ⟪k i, L j i r (k r)⟫_ℂ) -
+        (fun j => ∑ i, ∑ r, ⟪π (a i) ξ, L j i r (π (a r) ξ)⟫_ℂ)‖ < ε := by
+  let Q : (I → H) → J → ℂ := fun z j => ∑ i, ∑ r, ⟪z i, L j i r (z r)⟫_ℂ
+  have hQ : Continuous Q := by
+    apply continuous_pi
+    intro j
+    fun_prop
+  have hQat : ContinuousAt Q k := hQ.continuousAt
+  obtain ⟨δ, hδ, hclose⟩ := Metric.continuousAt_iff.mp hQat ε hε
+  have hd : DenseRange (fun a : I → Unitization ℂ D => fun i => π (a i) ξ) :=
+    DenseRange.piMap (fun _ => hcyc)
+  obtain ⟨a, ha⟩ := Metric.denseRange_iff.mp hd k δ hδ
+  refine ⟨a, ?_⟩
+  have h := hclose (by simpa only [dist_comm] using ha)
+  simpa only [dist_eq_norm, norm_sub_rev, Q] using h
+
+lemma unitized_coefficient_representation
+    {B : Type*} [NonUnitalCStarAlgebra B]
+    (π : Unitization ℂ D →⋆ₐ[ℂ] (H →L[ℂ] H)) (ξ : H)
+    (T : B → D) (a : I → Unitization ℂ D) (c : I → B) (b : B)
+    (e : H →L[ℂ] H) (he : ∀ d, Commute (π d) e) :
+    ⟪ξ, π ((unitizedCoefficientEnlargement T a c b : D) : Unitization ℂ D) (e ξ)⟫_ℂ =
+      ∑ i, ∑ j, ⟪π (a i) ξ,
+        π ((T (star (c i) * b * c j) : D) : Unitization ℂ D) (e (π (a j) ξ))⟫_ℂ := by
+  rw [inr_unitizedCoefficientEnlargement]
+  simp only [map_sum, sum_apply, inner_sum, map_mul, map_star,
+    ContinuousLinearMap.star_eq_adjoint, mul_apply_eq_comp]
+  apply Finset.sum_congr rfl
+  intro i _
+  apply Finset.sum_congr rfl
+  intro j _
+  rw [ContinuousLinearMap.adjoint_inner_right]
+  congr 2
+  exact congrArg (fun f : H →L[ℂ] H => f ξ) (he (a j)).eq
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/CyclicGNSUnitary.lean

@@ -0,0 +1,86 @@
+import OAI.Analysis.OperatorAlgebra.CyclicStateNorm
+
+namespace OAI
+
+/-! The concrete cyclic vector realization of a positive functional is
+unitarily equivalent to its GNS space. -/
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder
+open UniformSpace
+
+namespace WeakPureInfiniteness
+
+variable {A H : Type*} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  (φ : A →ₚ[ℂ] ℂ) (π : A →⋆ₐ[ℂ] (H →L[ℂ] H)) (ξ : H)
+  (hφ : ∀ a, φ a = inner ℂ ξ (π a ξ))
+
+def cyclicPreGNSIsometry : φ.PreGNS →ₗᵢ[ℂ] H where
+  toFun x := π (φ.ofPreGNS x) ξ
+  map_add' x y := by simp only [map_add, add_apply]
+  map_smul' c x := by simp only [map_smul, smul_apply, RingHom.id_apply]
+  norm_map' x := by
+    change ‖π (φ.ofPreGNS x) ξ‖ = ‖x‖
+    have h := cyclic_vector_norm_eq_preGNS π (StarAlgHom.id ℂ A) φ ξ
+      (fun a => hφ a) (φ.ofPreGNS x)
+    change ‖π (φ.ofPreGNS x) ξ‖ = ‖φ.toPreGNS (φ.ofPreGNS x)‖ at h
+    simpa only [PositiveLinearMap.toPreGNS_ofPreGNS] using h
+
+def cyclicGNSIsometry : φ.GNS →ₗᵢ[ℂ] H :=
+  (cyclicPreGNSIsometry φ π ξ hφ).fromCompletion
+
+@[simp] lemma cyclicGNSIsometry_coe (x : φ.PreGNS) :
+    cyclicGNSIsometry φ π ξ hφ (x : φ.GNS) = π (φ.ofPreGNS x) ξ := by
+  rw [cyclicGNSIsometry, LinearIsometry.fromCompletion_apply_coe]
+  rfl
+
+@[simp] lemma cyclicGNSIsometry_vector (a : A) :
+    cyclicGNSIsometry φ π ξ hφ (φ.toPreGNS a : φ.GNS) = π a ξ := by
+  rw [cyclicGNSIsometry_coe, PositiveLinearMap.ofPreGNS_toPreGNS]
+
+theorem cyclicGNSIsometry_surjective (hξ : DenseRange (fun a => π a ξ)) :
+    Function.Surjective (cyclicGNSIsometry φ π ξ hφ) := by
+  let V := cyclicGNSIsometry φ π ξ hφ
+  have hc : IsClosed (Set.range V) := V.isometry.isClosedEmbedding.isClosed_range
+  have hr : Set.range (fun a => π a ξ) ⊆ Set.range V := by
+    rintro _ ⟨a, rfl⟩
+    exact ⟨(φ.toPreGNS a : φ.GNS), cyclicGNSIsometry_vector φ π ξ hφ a⟩
+  have hall : Set.univ ⊆ Set.range V := by
+    rw [← hξ.closure_range]
+    exact closure_minimal hr hc
+  intro x
+  exact hall (Set.mem_univ x)
+
+def cyclicGNSUnitary (hξ : DenseRange (fun a => π a ξ)) : φ.GNS ≃ₗᵢ[ℂ] H :=
+  LinearIsometryEquiv.ofSurjective (cyclicGNSIsometry φ π ξ hφ)
+    (cyclicGNSIsometry_surjective φ π ξ hφ hξ)
+
+theorem cyclicGNSIsometry_intertwines (a : A) (η : φ.GNS) :
+    cyclicGNSIsometry φ π ξ hφ (φ.gnsStarAlgHom a η) =
+      π a (cyclicGNSIsometry φ π ξ hφ η) := by
+  induction η using Completion.induction_on with
+  | hp => exact isClosed_eq (by fun_prop) (by fun_prop)
+  | ih x =>
+    change cyclicGNSIsometry φ π ξ hφ (φ.gnsNonUnitalStarAlgHom a x) = _
+    rw [PositiveLinearMap.gnsNonUnitalStarAlgHom_apply_coe,
+      cyclicGNSIsometry_coe, cyclicGNSIsometry_coe]
+    simp only [PositiveLinearMap.leftMulMapPreGNS_apply,
+      PositiveLinearMap.ofPreGNS_toPreGNS, map_mul, mul_apply_eq_comp]
+
+theorem cyclicGNSUnitary_conjugates (hξ : DenseRange (fun a => π a ξ)) (a : A) :
+    (cyclicGNSUnitary φ π ξ hφ hξ).conjStarAlgEquiv (φ.gnsStarAlgHom a) = π a := by
+  ext η
+  rw [LinearIsometryEquiv.conjStarAlgEquiv_apply_apply]
+  change cyclicGNSIsometry φ π ξ hφ
+    (φ.gnsStarAlgHom a ((cyclicGNSUnitary φ π ξ hφ hξ).symm η)) = π a η
+  rw [cyclicGNSIsometry_intertwines]
+  change π a ((cyclicGNSUnitary φ π ξ hφ hξ)
+    ((cyclicGNSUnitary φ π ξ hφ hξ).symm η)) = π a η
+  rw [LinearIsometryEquiv.apply_symm_apply]
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/CyclicSeparatingCompression.lean

@@ -0,0 +1,51 @@
+import OAI.Analysis.OperatorAlgebra.IntertwinerCompression
+import OAI.Analysis.OperatorAlgebra.IsometricCornerOperators
+import OAI.Analysis.ModularRecovery.TomitaFundamental
+
+namespace OAI
+
+/-! A separating vector remains separating on its cyclic subrepresentation.
+The proof compresses the actual commuting operators and uses their dense
+orbit, rather than assuming the compressed bicommutant is a normal image. -/
+noncomputable section
+open scoped Topology
+namespace WeakPureInfiniteness
+open BoundedRecovery
+
+variable {A H K : Type*} [CStarAlgebra A]
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+
+lemma separating_compression (π : A →⋆ₐ[ℂ] (H →L[ℂ] H))
+    (ρ : A →⋆ₐ[ℂ] (K →L[ℂ] K)) (W : K →ₗᵢ[ℂ] H)
+    (hW : ∀ a, W.toContinuousLinearMap.comp (ρ a) = (π a).comp W.toContinuousLinearMap)
+    (M : VonNeumannAlgebra H) (hπ : ∀ a, π a ∈ M) (ξ : K)
+    (hsep : ∀ T : H →L[ℂ] H, T ∈ M → T (W ξ) = 0 → T = 0)
+    (U : K →L[ℂ] K)
+    (hU : ∀ R : K →L[ℂ] K, (∀ a, Commute (ρ a) R) → Commute R U)
+    (hzero : U ξ = 0) : U = 0 := by
+  have hd := commutant_cyclic M (W ξ) hsep
+  have hv (x : H) : U (W.toContinuousLinearMap.adjoint x) = 0 := by
+    apply closure_minimal (s := (operatorOrbit M.commutant (W ξ) : Set H)) ?_
+      (isClosed_eq (U.continuous.comp W.toContinuousLinearMap.adjoint.continuous)
+        continuous_const) (hd x)
+    rintro _ ⟨T, hT, rfl⟩
+    have hTπ (a : A) : Commute (π a) T :=
+      VonNeumannAlgebra.mem_commutant_iff.mp hT (π a) (hπ a)
+    have hc := hU (isometricCornerCompress W T)
+      (fun a => intertwiner_compression_commutes ρ π W.toContinuousLinearMap hW T hTπ a)
+    have he := congrArg (fun V : K →L[ℂ] K => V ξ) hc.eq
+    change W.toContinuousLinearMap.adjoint (T (W (U ξ))) =
+      U (W.toContinuousLinearMap.adjoint (T (W ξ))) at he
+    rw [hzero, map_zero, map_zero, map_zero] at he
+    exact he.symm
+  apply ContinuousLinearMap.ext
+  intro x
+  have he := hv (W x)
+  rwa [isometricCorner_adjoint_apply] at he
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/CyclicStandardIntertwiner.lean

@@ -0,0 +1,93 @@
+import OAI.Analysis.PureInfiniteness.NormalizedSeparatingSequence
+import OAI.Analysis.OperatorAlgebra.GNSSeparableCyclic
+
+namespace OAI
+
+/-! The application-specific standard representation and bounded intertwiner
+for a tested vector of a representation of a separable C*-algebra. -/
+noncomputable section
+open TopologicalSpace
+open scoped ComplexOrder
+namespace WeakPureInfiniteness
+open BoundedRecovery KirchbergRordam.GenericRW.GroupedFactors
+
+universe u v
+variable {A : Type u} {H : Type v} [CStarAlgebra A]
+  [PartialOrder A] [StarOrderedRing A] [SeparableSpace A]
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+theorem exists_cyclic_standard_intertwiner
+    (π : A →⋆ₐ[ℂ] (H →L[ℂ] H)) (ξ : H) (hξ : ‖ξ‖ = 1) :
+    ∃ (K : ComplexHilbert.{u}) (S : StandardModularData K)
+      (ρ : A →⋆ₐ[ℂ] (K →L[ℂ] K)) (V : K →L[ℂ] H),
+      S.M = bicommutant ρ.range ∧ ‖V‖ ≤ 3 ∧ V S.xi = ξ ∧
+      ∀ a, V.comp (ρ a) = (π a).comp V := by
+  let f₀ := vectorPositiveFunctional π ξ
+  let K₀ := gnsHilbert f₀
+  let ρ₀ : A →⋆ₐ[ℂ] (K₀ →L[ℂ] K₀) := gnsBundledHom f₀
+  let ξ₀ : K₀ := gnsVector f₀ 1
+  let W₀ : K₀ →ₗᵢ[ℂ] H := cyclicBundledGNSIsometry f₀ π ξ
+    (vectorPositiveFunctional_apply π ξ)
+  have hW₀ : W₀ ξ₀ = ξ := cyclicBundledGNSIsometry_one f₀ π ξ _
+  have hξ₀ : ‖ξ₀‖ = 1 := by
+    rw [← W₀.norm_map ξ₀, hW₀, hξ]
+  let : SeparableSpace K₀ := gns_separable_of_cyclic f₀ π ξ
+    (vectorPositiveFunctional_apply π ξ)
+  let d : ℕ → K₀ := TopologicalSpace.denseSeq K₀
+  have hd : DenseRange d := TopologicalSpace.denseRange_denseSeq K₀
+  let Ω := separatingSequence ξ₀ d
+  let ω := normalizedSeparatingSequence ξ₀ d
+  let f₁ := vectorPositiveFunctional (sequenceAmplification ρ₀) ω
+  let K₁ := gnsHilbert f₁
+  let ρ₁ : A →⋆ₐ[ℂ] (K₁ →L[ℂ] K₁) := gnsBundledHom f₁
+  let W₁ : K₁ →ₗᵢ[ℂ] SequenceHilbert K₀ :=
+    cyclicBundledGNSIsometry f₁ (sequenceAmplification ρ₀) ω
+      (vectorPositiveFunctional_apply _ _)
+  let D := sequenceStandardGNSData ρ₀ ξ₀ hξ₀ d hd
+  let S : StandardModularData K₁ := D.toStandardModularData
+  let V : K₁ →L[ℂ] H := (‖Ω‖ : ℂ) •
+    (W₀.toContinuousLinearMap.comp
+      ((lp.evalCLM ℂ (fun _ : ℕ => K₀) 2 0).comp W₁.toContinuousLinearMap))
+  have hV (x : K₁) : V x = (‖Ω‖ : ℂ) • W₀ (W₁ x 0) := rfl
+  have hΩn : ‖Ω‖ ≤ 3 := by
+    have h := separatingSequence_norm_le ξ₀ d
+    change ‖Ω‖ ≤ ‖ξ₀‖ + 2 at h
+    rw [hξ₀] at h
+    norm_num at h ⊢
+    exact h
+  have hΩ : ‖Ω‖ ≠ 0 := norm_ne_zero_iff.mpr (separatingSequence_ne_zero ξ₀ hξ₀ d)
+  refine ⟨K₁, S, ρ₁, V, rfl, ?_, ?_, ?_⟩
+  · apply ContinuousLinearMap.opNorm_le_bound V (by norm_num)
+    intro x
+    rw [hV, norm_smul, Complex.norm_real, Real.norm_eq_abs,
+      abs_of_nonneg (norm_nonneg Ω), W₀.norm_map]
+    calc
+      ‖Ω‖ * ‖W₁ x 0‖ ≤ ‖Ω‖ * ‖W₁ x‖ :=
+        mul_le_mul_of_nonneg_left (lp.norm_apply_le_norm (by norm_num) _ _) (norm_nonneg _)
+      _ = ‖Ω‖ * ‖x‖ := by rw [W₁.norm_map]
+      _ ≤ 3 * ‖x‖ := mul_le_mul_of_nonneg_right hΩn (norm_nonneg _)
+  · change V (gnsVector f₁ 1) = ξ
+    rw [hV, cyclicBundledGNSIsometry_one]
+    change (‖Ω‖ : ℂ) • W₀ (((‖Ω‖⁻¹ : ℝ) : ℂ) • Ω 0) = ξ
+    rw [separatingSequence_zero, map_smul, smul_smul, ← Complex.ofReal_mul,
+      mul_inv_cancel₀ hΩ, Complex.ofReal_one, one_smul, hW₀]
+  · intro a
+    apply ContinuousLinearMap.ext
+    intro x
+    rw [ContinuousLinearMap.comp_apply, ContinuousLinearMap.comp_apply, hV, hV, map_smul]
+    congr 1
+    have h₁ := congrArg (fun T : K₁ →L[ℂ] SequenceHilbert K₀ => T x)
+      (cyclicBundledGNSIsometry_intertwines f₁ (sequenceAmplification ρ₀) ω
+        (vectorPositiveFunctional_apply _ _) a)
+    have h₀ := congrArg (fun T : K₀ →L[ℂ] H => T (W₁ x 0))
+      (cyclicBundledGNSIsometry_intertwines f₀ π ξ
+        (vectorPositiveFunctional_apply _ _) a)
+    change W₀ (W₁ (ρ₁ a x) 0) = π a (W₀ (W₁ x 0))
+    rw [show W₁ (ρ₁ a x) = sequenceAmplification ρ₀ a (W₁ x) from h₁]
+    exact h₀
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/CyclicStateNorm.lean

@@ -0,0 +1,60 @@
+import Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal
+import Mathlib.Analysis.InnerProductSpace.Adjoint
+import Mathlib.Tactic
+
+namespace OAI
+
+/-! A cyclic representation is bounded by any C*-representation carrying
+the same cyclic vector state. The source algebra need not carry a norm. -/
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder
+
+namespace WeakPureInfiniteness
+
+variable {A B H : Type*} [Ring A] [StarRing A] [Algebra ℂ A]
+  [CStarAlgebra B] [PartialOrder B] [StarOrderedRing B]
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+lemma cyclic_vector_norm_eq_preGNS (π : A →⋆ₐ[ℂ] (H →L[ℂ] H))
+    (q : A →⋆ₐ[ℂ] B) (φ : B →ₚ[ℂ] ℂ) (ξ : H)
+    (hφ : ∀ a, φ (q a) = inner ℂ ξ (π a ξ)) (b : A) :
+    ‖π b ξ‖ = ‖φ.toPreGNS (q b)‖ := by
+  rw [PositiveLinearMap.preGNS_norm_def,
+    PositiveLinearMap.ofPreGNS_toPreGNS, ← map_star q, ← map_mul q, hφ]
+  simp only [map_mul, map_star, mul_apply_eq_comp,
+    ContinuousLinearMap.star_eq_adjoint, ContinuousLinearMap.adjoint_inner_right,
+    ]
+  have hnorm : (inner ℂ (π b ξ) (π b ξ)).re = ‖π b ξ‖ ^ 2 :=
+    inner_self_eq_norm_sq (𝕜 := ℂ) (π b ξ)
+  rw [hnorm, Real.sqrt_sq (norm_nonneg _)]
+
+theorem cyclic_representation_norm_le (π : A →⋆ₐ[ℂ] (H →L[ℂ] H))
+    (q : A →⋆ₐ[ℂ] B) (φ : B →ₚ[ℂ] ℂ) (ξ : H)
+    (hξ : DenseRange (fun a => π a ξ))
+    (hφ : ∀ a, φ (q a) = inner ℂ ξ (π a ξ)) (a : A) :
+    ‖π a‖ ≤ ‖q a‖ := by
+  have hn := cyclic_vector_norm_eq_preGNS π q φ ξ hφ
+  have hmul : ‖φ.leftMulMapPreGNS (q a)‖ ≤ ‖q a‖ := by
+    unfold PositiveLinearMap.leftMulMapPreGNS
+    exact LinearMap.mkContinuous_norm_le _ (norm_nonneg _) _
+  refine (π a).opNorm_le_bound (norm_nonneg _) ?_
+  refine isClosed_property hξ (isClosed_le (by fun_prop) (by fun_prop)) ?_
+  intro b
+  calc
+    ‖π a (π b ξ)‖ = ‖π (a * b) ξ‖ := by rw [map_mul]; rfl
+    _ = ‖φ.toPreGNS (q (a * b))‖ := hn (a * b)
+    _ = ‖φ.leftMulMapPreGNS (q a) (φ.toPreGNS (q b))‖ := by
+      simp only [map_mul, PositiveLinearMap.leftMulMapPreGNS_apply,
+        PositiveLinearMap.ofPreGNS_toPreGNS]
+    _ ≤ ‖φ.leftMulMapPreGNS (q a)‖ * ‖φ.toPreGNS (q b)‖ :=
+      (φ.leftMulMapPreGNS (q a)).le_opNorm _
+    _ ≤ ‖q a‖ * ‖φ.toPreGNS (q b)‖ :=
+      mul_le_mul_of_nonneg_right hmul (norm_nonneg _)
+    _ = ‖q a‖ * ‖π b ξ‖ := by rw [hn b]
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/DensityQuadraticCompression.lean

@@ -0,0 +1,103 @@
+import OAI.Analysis.OperatorAlgebra.DensityRootTrace
+
+namespace OAI
+
+/-! Passing the density-root trace identity through a common finite
+support, without finite-dimensionality of the represented Hilbert space. -/
+
+noncomputable section
+open scoped TensorProduct InnerProductSpace
+
+namespace WeakPureInfiniteness
+
+variable {H E F K : Type*}
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]
+  [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F]
+  [NormedAddCommGroup K] [InnerProductSpace ℂ K] [CompleteSpace K]
+
+lemma tensorIsometry_compression (f : F →ₗᵢ[ℂ] H) (g : K →ₗᵢ[ℂ] E)
+    (A : H →L[ℂ] H) (B : E →L[ℂ] E) (z w : F ⊗[ℂ] K) :
+    inner ℂ (TensorProduct.mapIsometry f g z)
+      (TensorProduct.mapL A B (TensorProduct.mapIsometry f g w)) =
+    inner ℂ z (TensorProduct.mapL
+      (f.toContinuousLinearMap.adjoint ∘L A ∘L f.toContinuousLinearMap)
+      (g.toContinuousLinearMap.adjoint ∘L B ∘L g.toContinuousLinearMap) w) := by
+  induction z using TensorProduct.inductionOn with
+  | tmul x y =>
+      induction w using TensorProduct.inductionOn with
+      | tmul v t =>
+          simp only [TensorProduct.mapIsometry_apply, TensorProduct.map_tmul,
+            TensorProduct.mapL_tmul, TensorProduct.inner_tmul]
+          change inner ℂ (f x) (A (f v)) * inner ℂ (g y) (B (g t)) =
+            inner ℂ x (f.toContinuousLinearMap.adjoint (A (f v))) *
+              inner ℂ y (g.toContinuousLinearMap.adjoint (B (g t)))
+          rw [ContinuousLinearMap.adjoint_inner_right, ContinuousLinearMap.adjoint_inner_right]
+          rfl
+      | add w₁ w₂ h₁ h₂ =>
+          simpa only [map_add, inner_add_right (𝕜 := ℂ)] using congrArg₂ (· + ·) h₁ h₂
+  | add z₁ z₂ h₁ h₂ =>
+      simpa only [map_add, inner_add_left (𝕜 := ℂ)] using congrArg₂ (· + ·) h₁ h₂
+
+lemma finiteTensorDensity_compression (f : F →ₗᵢ[ℂ] H) (z : E ⊗[ℂ] F)
+    (A : H →L[ℂ] H) :
+    (finiteTensorDensity (TensorProduct.mapIsometry (LinearIsometry.id : E →ₗᵢ[ℂ] E) f z)).val A =
+      (finiteTensorDensity z).val (f.toContinuousLinearMap.adjoint ∘L A ∘L f.toContinuousLinearMap) := by
+  rw [finiteTensorDensity_apply, finiteTensorDensity_apply]
+  have h := tensorIsometry_compression (LinearIsometry.id : E →ₗᵢ[ℂ] E) f
+    (ContinuousLinearMap.id ℂ E) A z z
+  have hi : (LinearIsometry.id : E →ₗᵢ[ℂ] E).toContinuousLinearMap.adjoint ∘L
+      (ContinuousLinearMap.id ℂ E) ∘L (LinearIsometry.id : E →ₗᵢ[ℂ] E).toContinuousLinearMap =
+        ContinuousLinearMap.id ℂ E := by
+    change (ContinuousLinearMap.id ℂ E).adjoint ∘L (ContinuousLinearMap.id ℂ E) ∘L
+      (ContinuousLinearMap.id ℂ E) = ContinuousLinearMap.id ℂ E
+    rw [ContinuousLinearMap.adjoint_id]
+    simp only [ContinuousLinearMap.comp_id]
+  rw [hi] at h
+  exact h
+
+theorem densityRoot_left_quadratic (z : E ⊗[ℂ] H) (A : H →L[ℂ] H) :
+    inner ℂ (NuclearUltrapower.densityRoot z)
+      (densityLeftRepresentation A (NuclearUltrapower.densityRoot z)) =
+        (finiteTensorDensity z).val A := by
+  obtain ⟨F, hF, hFz⟩ := TensorProduct.exists_finite_submodule_right_of_setFinite
+    ({z} : Set (E ⊗[ℂ] H)) (Set.finite_singleton z)
+  let : FiniteDimensional ℂ F := hF
+  let : CompleteSpace F := FiniteDimensional.complete ℂ F
+  let : InnerProductSpace ℂ (StrongDual ℂ F) := NuclearUltrapower.strongDualInner
+  let : NormedAddCommGroup (F ⊗[ℂ] StrongDual ℂ F) :=
+    TensorProduct.instNormedAddCommGroup (𝕜 := ℂ) (E := F) (F := StrongDual ℂ F)
+  let : InnerProductSpace ℂ (F ⊗[ℂ] StrongDual ℂ F) :=
+    TensorProduct.instInnerProductSpace (𝕜 := ℂ) (E := F) (F := StrongDual ℂ F)
+  obtain ⟨w, hw⟩ := hFz (Set.mem_singleton z)
+  have hm : TensorProduct.mapIsometry (LinearIsometry.id : E →ₗᵢ[ℂ] E) F.subtypeₗᵢ w = z := hw
+  rw [← hm]
+  simp only [NuclearUltrapower.densityRoot_mapIsometry, densityLeft_coe,
+    UniformSpace.Completion.inner_coe (𝕜 := ℂ) (E := H ⊗[ℂ] StrongDual ℂ H)]
+  let f := F.subtypeₗᵢ
+  let g := NuclearUltrapower.dualIsometry f
+  let t := NuclearUltrapower.finiteOperatorTensor (CFC.sqrt (NuclearUltrapower.reducedDensity w))
+  change inner ℂ (TensorProduct.mapIsometry f g t)
+    (TensorProduct.mapL A (ContinuousLinearMap.id ℂ (StrongDual ℂ H))
+      (TensorProduct.mapIsometry f g t)) = _
+  rw [tensorIsometry_compression]
+  have hg : g.toContinuousLinearMap.adjoint ∘L (ContinuousLinearMap.id ℂ (StrongDual ℂ H)) ∘L
+      g.toContinuousLinearMap = ContinuousLinearMap.id ℂ (StrongDual ℂ F) := by
+    apply ContinuousLinearMap.ext
+    intro x
+    have hx := congrArg (fun T : StrongDual ℂ F →L[ℂ] StrongDual ℂ F => T x)
+      g.adjoint_comp_self
+    exact hx
+  rw [hg]
+  have ht := densityRoot_left_quadratic_finite w
+    (f.toContinuousLinearMap.adjoint ∘L A ∘L f.toContinuousLinearMap)
+  simp only [densityRoot_eq_finiteOperatorTensor, densityLeft_coe,
+    UniformSpace.Completion.inner_coe (𝕜 := ℂ) (E := F ⊗[ℂ] StrongDual ℂ F)] at ht
+  rw [ht]
+  exact (finiteTensorDensity_compression f w A).symm
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/DensityRootTrace.lean

@@ -0,0 +1,56 @@
+import OAI.Analysis.OperatorAlgebra.DensitySpatialRepresentation
+
+namespace OAI
+
+/-! The left spatial vector functional of a density root is the original
+finite positive functional. The finite-dimensional computation is the
+trace identity used before passage to a common finite support. -/
+
+noncomputable section
+open scoped InnerProductSpace TensorProduct ComplexOrder
+
+namespace WeakPureInfiniteness
+
+variable {H E : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+  [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]
+
+lemma finiteOperatorTensor_left [FiniteDimensional ℂ H] (A T : H →L[ℂ] H) :
+    TensorProduct.mapL A (ContinuousLinearMap.id ℂ (StrongDual ℂ H))
+      (NuclearUltrapower.finiteOperatorTensor T) =
+        NuclearUltrapower.finiteOperatorTensor (A * T) := by
+  classical
+  simp only [NuclearUltrapower.finiteOperatorTensor, map_sum, TensorProduct.mapL_tmul,
+    ContinuousLinearMap.id_apply, mul_apply_eq_comp]
+
+lemma densityRoot_eq_finiteOperatorTensor [FiniteDimensional ℂ H] (z : E ⊗[ℂ] H) :
+    NuclearUltrapower.densityRoot z =
+      (NuclearUltrapower.finiteOperatorTensor (CFC.sqrt (NuclearUltrapower.reducedDensity z)) :
+        NuclearUltrapower.HilbertSchmidt H) := by
+  apply NuclearUltrapower.hsOperator_injective
+  rw [NuclearUltrapower.hsOperator_densityRoot, NuclearUltrapower.hsOperator_coe,
+    NuclearUltrapower.tensorOperator_finiteOperatorTensor]
+
+lemma densityRoot_left_quadratic_finite [FiniteDimensional ℂ H]
+    (z : E ⊗[ℂ] H) (A : H →L[ℂ] H) :
+    inner ℂ (NuclearUltrapower.densityRoot z)
+      (densityLeftRepresentation A (NuclearUltrapower.densityRoot z)) =
+        (finiteTensorDensity z).val A := by
+  rw [densityRoot_eq_finiteOperatorTensor, densityLeft_coe,
+    UniformSpace.Completion.inner_coe (𝕜 := ℂ) (E := H ⊗[ℂ] StrongDual ℂ H), finiteOperatorTensor_left,
+    NuclearUltrapower.finiteOperatorTensor_inner,
+    (CFC.sqrt_nonneg (NuclearUltrapower.reducedDensity z)).isSelfAdjoint.star_eq]
+  let r := CFC.sqrt (NuclearUltrapower.reducedDensity z)
+  change LinearMap.trace ℂ H ((r * (A * r)).toLinearMap) = _
+  have hc : LinearMap.trace ℂ H ((r * (A * r)).toLinearMap) =
+      LinearMap.trace ℂ H (((A * r) * r).toLinearMap) :=
+    LinearMap.trace_mul_comm ℂ r.toLinearMap (A * r).toLinearMap
+  rw [hc, mul_assoc]
+  have hr : r * r = NuclearUltrapower.reducedDensity z :=
+    CFC.sqrt_mul_sqrt_self _ (NuclearUltrapower.reducedDensity_nonneg z)
+  rw [hr, NuclearUltrapower.trace_reducedDensity, finiteTensorDensity_apply]
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/DensitySpatialRepresentation.lean

@@ -0,0 +1,85 @@
+import OAI.Analysis.OperatorAlgebra.HilbertDualOperators
+import OAI.Analysis.OperatorAlgebra.HilbertSchmidtUnitaryActions
+
+namespace OAI
+
+/-! The left/right actions used by the finite-density argument are genuine
+spatial star representations on the Hilbert–Schmidt completion. -/
+
+noncomputable section
+open scoped TensorProduct InnerProductSpace
+
+namespace WeakPureInfiniteness
+
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+instance densityHSNormed : NormedAddCommGroup (NuclearUltrapower.HilbertSchmidt H) := inferInstance
+instance densityHSInner : InnerProductSpace ℂ (NuclearUltrapower.HilbertSchmidt H) := inferInstance
+instance densityHSComplete : CompleteSpace (NuclearUltrapower.HilbertSchmidt H) := inferInstance
+instance densityHSScalar : NormedSpace ℂ (NuclearUltrapower.HilbertSchmidt H) := inferInstance
+instance densityHSBounded : IsBoundedSMul ℂ (NuclearUltrapower.HilbertSchmidt H) :=
+  NormedSpace.toIsBoundedSMul
+instance densityHSContinuous : ContinuousSMul ℂ (NuclearUltrapower.HilbertSchmidt H) :=
+  IsBoundedSMul.continuousSMul
+
+def densityLeftRepresentation : (H →L[ℂ] H) →⋆ₐ[ℂ]
+    (NuclearUltrapower.HilbertSchmidt H →L[ℂ] NuclearUltrapower.HilbertSchmidt H) :=
+  Pureness.spatialLeftHom (K := StrongDual ℂ H) (StarAlgHom.id ℂ (H →L[ℂ] H))
+
+def densityRightRepresentation : (H →L[ℂ] H)ᵐᵒᵖ →⋆ₐ[ℂ]
+    (NuclearUltrapower.HilbertSchmidt H →L[ℂ] NuclearUltrapower.HilbertSchmidt H) :=
+  Pureness.spatialRightHom (H := H) hilbertDualRepresentation
+
+lemma densityLeftRight_commute (T S : H →L[ℂ] H) :
+    Commute (densityLeftRepresentation T) (densityRightRepresentation (MulOpposite.op S)) := by
+  unfold densityLeftRepresentation densityRightRepresentation
+  exact Pureness.spatialLeftRight_commute (StarAlgHom.id ℂ (H →L[ℂ] H))
+    (hilbertDualRepresentation (H := H)) T (MulOpposite.op S)
+
+lemma densityLeft_coe (T : H →L[ℂ] H) (z : H ⊗[ℂ] StrongDual ℂ H) :
+    densityLeftRepresentation T (z : NuclearUltrapower.HilbertSchmidt H) =
+      (TensorProduct.mapL T (ContinuousLinearMap.id ℂ (StrongDual ℂ H)) z :
+        NuclearUltrapower.HilbertSchmidt H) :=
+  UnitalTomsWinter.spatialTensorOp_coe T 1 z
+
+lemma densityLeft_unitary (U : H ≃ₗᵢ[ℂ] H) :
+    densityLeftRepresentation (U : H →L[ℂ] H) =
+      (hsLeftUnitary U : NuclearUltrapower.HilbertSchmidt H →L[ℂ] NuclearUltrapower.HilbertSchmidt H) := by
+  apply UnitalTomsWinter.spatialTensorOp_ext (H := H) (K := StrongDual ℂ H)
+  intro x f
+  change UnitalTomsWinter.spatialTensorOp (U : H →L[ℂ] H) 1
+    ((x ⊗ₜ[ℂ] f : H ⊗[ℂ] StrongDual ℂ H) : NuclearUltrapower.HilbertSchmidt H) = _
+  rw [UnitalTomsWinter.spatialTensorOp_coe]
+  change (TensorProduct.mapL (U : H →L[ℂ] H) (1 : StrongDual ℂ H →L[ℂ] StrongDual ℂ H) (x ⊗ₜ[ℂ] f) :
+    NuclearUltrapower.HilbertSchmidt H) = hsLeftUnitary U _
+  simp only [TensorProduct.mapL_tmul, one_apply_eq_self, hsLeftUnitary,
+    NuclearUltrapower.completionUnitary_coe, TensorProduct.congrIsometry_apply,
+    TensorProduct.congr_tmul]
+  rfl
+
+lemma densityRight_unitary (U : H ≃ₗᵢ[ℂ] H) :
+    densityRightRepresentation (MulOpposite.op (U : H →L[ℂ] H)) =
+      (hsRightUnitary U : NuclearUltrapower.HilbertSchmidt H →L[ℂ] NuclearUltrapower.HilbertSchmidt H) := by
+  apply UnitalTomsWinter.spatialTensorOp_ext (H := H) (K := StrongDual ℂ H)
+  intro x f
+  change UnitalTomsWinter.spatialTensorOp 1 (hilbertDualOperator (U : H →L[ℂ] H))
+    ((x ⊗ₜ[ℂ] f : H ⊗[ℂ] StrongDual ℂ H) : NuclearUltrapower.HilbertSchmidt H) = _
+  rw [UnitalTomsWinter.spatialTensorOp_coe]
+  change (TensorProduct.mapL (1 : H →L[ℂ] H) (hilbertDualOperator (U : H →L[ℂ] H)) (x ⊗ₜ[ℂ] f) :
+    NuclearUltrapower.HilbertSchmidt H) = hsRightUnitary U _
+  simp only [TensorProduct.mapL_tmul, one_apply_eq_self, hsRightUnitary,
+    NuclearUltrapower.completionUnitary_coe, TensorProduct.congrIsometry_apply,
+    TensorProduct.congr_tmul]
+  have hf : hilbertDualOperator (U : H →L[ℂ] H) f = NuclearUltrapower.dualUnitary U.symm f := by
+    ext y
+    rw [hilbertDualOperator_apply, NuclearUltrapower.dualUnitary_apply]
+    rfl
+  change ((x ⊗ₜ[ℂ] hilbertDualOperator (U : H →L[ℂ] H) f : H ⊗[ℂ] StrongDual ℂ H) :
+    NuclearUltrapower.HilbertSchmidt H) = (x ⊗ₜ[ℂ] NuclearUltrapower.dualUnitary U.symm f)
+  rw [hf]
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/DensityUnitaryCoefficients.lean

@@ -0,0 +1,65 @@
+import OAI.Analysis.OperatorAlgebra.DensitySpatialRepresentation
+import OAI.Analysis.Nuclearity.SpatialCoefficientEstimate
+
+namespace OAI
+
+/-! Pointwise unitary identities for the spatial Hilbert–Schmidt action. -/
+
+noncomputable section
+open scoped InnerProductSpace
+namespace WeakPureInfiniteness
+
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+lemma densityLeft_unitary_apply (U : H ≃ₗᵢ[ℂ] H)
+    (z : NuclearUltrapower.HilbertSchmidt H) :
+    densityLeftRepresentation (U : H →L[ℂ] H) z = hsLeftUnitary U z := by
+  exact congrArg (fun V : NuclearUltrapower.HilbertSchmidt H →L[ℂ]
+    NuclearUltrapower.HilbertSchmidt H => V z) (densityLeft_unitary U)
+
+lemma densityRight_unitary_apply (U : H ≃ₗᵢ[ℂ] H)
+    (z : NuclearUltrapower.HilbertSchmidt H) :
+    densityRightRepresentation (MulOpposite.op (U : H →L[ℂ] H)) z = hsRightUnitary U z := by
+  exact congrArg (fun V : NuclearUltrapower.HilbertSchmidt H →L[ℂ]
+    NuclearUltrapower.HilbertSchmidt H => V z) (densityRight_unitary U)
+
+lemma densityLeft_unitary_product_apply (T : H →L[ℂ] H) (U : H ≃ₗᵢ[ℂ] H)
+    (z : NuclearUltrapower.HilbertSchmidt H) :
+    (densityLeftRepresentation T * densityLeftRepresentation (U : H →L[ℂ] H)) z =
+      densityLeftRepresentation (T * (U : H →L[ℂ] H)) z :=
+  congrArg (fun V : NuclearUltrapower.HilbertSchmidt H →L[ℂ]
+    NuclearUltrapower.HilbertSchmidt H => V z)
+      (map_mul (densityLeftRepresentation (H := H)) T (U : H →L[ℂ] H)).symm
+
+lemma density_unitary_defect_norm (U : H ≃ₗᵢ[ℂ] H)
+    (z : NuclearUltrapower.HilbertSchmidt H) :
+    ‖densityRightRepresentation (MulOpposite.op (U : H →L[ℂ] H)) z -
+      densityLeftRepresentation (U : H →L[ℂ] H) z‖ =
+      ‖hsLeftUnitary U z - hsRightUnitary U z‖ := by
+  rw [densityRight_unitary_apply, densityLeft_unitary_apply, norm_sub_rev]
+
+lemma density_unitary_product_coefficient (T : H →L[ℂ] H) (U : H ≃ₗᵢ[ℂ] H)
+    (z : NuclearUltrapower.HilbertSchmidt H) :
+    inner ℂ z ((densityLeftRepresentation T *
+      densityLeftRepresentation (U : H →L[ℂ] H)) z) =
+      inner ℂ z (densityLeftRepresentation (T * (U : H →L[ℂ] H)) z) :=
+  congrArg (inner ℂ z) (densityLeft_unitary_product_apply T U z)
+
+lemma density_unitary_product_error (T : H →L[ℂ] H) (U : H ≃ₗᵢ[ℂ] H)
+    (z : NuclearUltrapower.HilbertSchmidt H) (hzn : ‖z‖ = 1) (α : ℂ) :
+    ‖inner ℂ z ((densityLeftRepresentation T *
+      densityRightRepresentation (MulOpposite.op (U : H →L[ℂ] H))) z) - α‖ ≤
+      ‖densityLeftRepresentation T‖ * ‖hsLeftUnitary U z - hsRightUnitary U z‖ +
+      ‖inner ℂ z (densityLeftRepresentation (T * (U : H →L[ℂ] H)) z) - α‖ := by
+  have hb := norm_product_coefficient_error_le
+    (H := NuclearUltrapower.HilbertSchmidt H) z hzn
+    (densityLeftRepresentation (H := H) T)
+    (densityRightRepresentation (H := H) (MulOpposite.op (U : H →L[ℂ] H)))
+    (densityLeftRepresentation (H := H) (U : H →L[ℂ] H)) α
+  exact hb.trans_eq (by rw [density_unitary_defect_norm, density_unitary_product_coefficient])
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/ExpectationDensityRoots.lean

@@ -0,0 +1,72 @@
+import OAI.Analysis.OperatorAlgebra.FiniteVectorDensityTensor
+import OAI.Analysis.OperatorAlgebra.ExpectationFiniteDensity
+
+namespace OAI
+
+/-! Application of the hypertrace separation and Powers–Størmer estimates
+to an actual completely positive expectation. -/
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder
+
+namespace WeakPureInfiniteness
+
+open scoped TensorProduct
+
+theorem densityRoot_finite_support {E H : Type*} [NormedAddCommGroup E]
+    [InnerProductSpace ℂ E] [CompleteSpace E] [NormedAddCommGroup H]
+    [InnerProductSpace ℂ H] [CompleteSpace H] (z : E ⊗[ℂ] H) :
+    ∃ F : Submodule ℂ H, FiniteDimensional ℂ F ∧
+      ∀ x, NuclearUltrapower.hsOperator (NuclearUltrapower.densityRoot z) x ∈ F := by
+  obtain ⟨F, hF, hFz⟩ := TensorProduct.exists_finite_submodule_right_of_setFinite
+    ({z} : Set (E ⊗[ℂ] H)) (Set.finite_singleton z)
+  let : FiniteDimensional ℂ F := hF
+  obtain ⟨w, hw⟩ := hFz (Set.mem_singleton z)
+  have hm : TensorProduct.mapIsometry (LinearIsometry.id : E →ₗᵢ[ℂ] E) F.subtypeₗᵢ w = z := hw
+  refine ⟨F, hF, ?_⟩
+  intro x
+  rw [← hm, NuclearUltrapower.densityRoot_mapIsometry, NuclearUltrapower.hsOperator_coe,
+    NuclearUltrapower.tensorOperator_liftOperatorTensor]
+  exact Subtype.property _
+
+variable {H I J : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+  [CompleteSpace H] [Fintype I] [Fintype J]
+
+/-- A finite tracial expectation supplies positive finite-rank density roots
+of norm at most one, approximately invariant under the prescribed unitaries. -/
+theorem expectation_finite_density_roots (M : VonNeumannAlgebra H)
+    [PartialOrder M.toStarSubalgebra] [StarOrderedRing M.toStarSubalgebra]
+    (τ : Pureness.TracialState M.toStarSubalgebra)
+    (E : (H →L[ℂ] H) →L[ℂ] (H →L[ℂ] H))
+    (hE : CompletelyPositive E) (hEr : ∀ T, E T ∈ M)
+    (hEf : ∀ T, T ∈ M → E T = T)
+    (a : I → selfAdjoint M.toStarSubalgebra) (u : J → unitary M.toStarSubalgebra)
+    {ε : ℝ} (hε : 0 < ε) :
+    ∃ (n : ℕ) (w : Fin n → ℝ) (x : Fin n → H),
+      (∀ k, 0 ≤ w k) ∧ (∑ k, w k = 1) ∧ (∀ k, ‖x k‖ ≤ 1) ∧
+      (∀ i, |(τ.functional (a i)).re -
+        ∑ k, w k * (inner ℂ (x k) (((a i : M.toStarSubalgebra) : H →L[ℂ] H) (x k))).re| < ε) ∧
+      let z := NuclearUltrapower.densityRoot (finiteVectorDensityTensor w x)
+      ‖z‖ ≤ 1 ∧ 0 ≤ NuclearUltrapower.hsOperator z ∧
+        (∃ F : Submodule ℂ H, FiniteDimensional ℂ F ∧
+          ∀ y, NuclearUltrapower.hsOperator z y ∈ F) ∧
+        ∀ j, ‖NuclearUltrapower.hsConjugation
+          (subalgebraUnitaryIsometry M.toStarSubalgebra (u j)) z - z‖ ^ 2 < ε := by
+  obtain ⟨n, w, x, hw, hws, hx, ha, hu⟩ :=
+    expectation_finite_density M τ E hE hEr hEf a u hε
+  refine ⟨n, w, x, hw, hws, hx, ha, ?_⟩
+  dsimp only
+  refine ⟨?_, ?_, densityRoot_finite_support _, ?_⟩
+  · rw [NuclearUltrapower.densityRoot_norm]
+    exact finiteVectorDensityTensor_norm_le_one w hw hws x hx
+  · rw [NuclearUltrapower.hsOperator_densityRoot]
+    exact CFC.sqrt_nonneg _
+  · intro j
+    exact (finiteVectorDensity_root_central w hw x
+      (subalgebraUnitaryIsometry M.toStarSubalgebra (u j))).trans_lt (hu j)
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/ExpectationFiniteDensity.lean

@@ -0,0 +1,73 @@
+import OAI.Analysis.OperatorAlgebra.HypertraceFiniteDensity
+import OAI.Analysis.OperatorAlgebra.ExpectationHypertrace
+
+namespace OAI
+
+/-! The constructed conditional expectation supplies the finite hypertrace
+witness. All conjugations below are the actual unitaries of the represented
+algebra, and the errors are measured in the norm of vector functionals. -/
+
+noncomputable section
+open scoped InnerProductSpace ComplexOrder
+
+namespace WeakPureInfiniteness
+
+variable {H I J : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+def subalgebraUnitaryIsometry (M : StarSubalgebra ℂ (H →L[ℂ] H)) (u : unitary M) : H ≃ₗᵢ[ℂ] H :=
+  Unitary.linearIsometryEquiv (Unitary.map (StarMonoidHom.ofClass M.subtype) u)
+
+lemma conjugatedOperator_subalgebraUnitary (M : StarSubalgebra ℂ (H →L[ℂ] H))
+    (u : unitary M) (T : H →L[ℂ] H) :
+    conjugatedOperator (subalgebraUnitaryIsometry M u) T =
+      star ((u : M) : H →L[ℂ] H) * T * ((u : M) : H →L[ℂ] H) := by
+  ext x
+  rfl
+
+lemma hypertrace_subalgebraUnitary_invariant (M : StarSubalgebra ℂ (H →L[ℂ] H))
+    (φ : (H →L[ℂ] H) →ₚ[ℂ] ℂ)
+    (hc : ∀ (a : M) (T : H →L[ℂ] H), φ ((a : H →L[ℂ] H) * T) = φ (T * (a : H →L[ℂ] H)))
+    (u : unitary M) (T : H →L[ℂ] H) :
+    φ (conjugatedOperator (subalgebraUnitaryIsometry M u) T) = φ T := by
+  let v := Unitary.map (StarMonoidHom.ofClass M.subtype) u
+  rw [conjugatedOperator_subalgebraUnitary]
+  change φ (star (v : H →L[ℂ] H) * T * (v : H →L[ℂ] H)) = φ T
+  rw [mul_assoc]
+  have hh := hc (star (u : M)) (T * (v : H →L[ℂ] H))
+  change φ (star (v : H →L[ℂ] H) * (T * (v : H →L[ℂ] H))) =
+    φ ((T * (v : H →L[ℂ] H)) * star (v : H →L[ℂ] H)) at hh
+  rw [hh, mul_assoc, Unitary.mul_star_self_of_mem v.property, mul_one]
+
+variable [Fintype I] [Fintype J]
+
+/-- Finite normal positive approximations with norm-small unitary defects,
+obtained from the actual expectation and a tracial state. -/
+theorem expectation_finite_density (M : VonNeumannAlgebra H)
+    [PartialOrder M.toStarSubalgebra] [StarOrderedRing M.toStarSubalgebra]
+    (τ : Pureness.TracialState M.toStarSubalgebra)
+    (E : (H →L[ℂ] H) →L[ℂ] (H →L[ℂ] H))
+    (hE : CompletelyPositive E) (hEr : ∀ T, E T ∈ M)
+    (hEf : ∀ T, T ∈ M → E T = T)
+    (a : I → selfAdjoint M.toStarSubalgebra) (u : J → unitary M.toStarSubalgebra)
+    {ε : ℝ} (hε : 0 < ε) :
+    ∃ (n : ℕ) (w : Fin n → ℝ) (x : Fin n → H),
+      (∀ k, 0 ≤ w k) ∧ (∑ k, w k = 1) ∧ (∀ k, ‖x k‖ ≤ 1) ∧
+      (∀ i, |(τ.functional (a i)).re -
+        ∑ k, w k * (inner ℂ (x k) (((a i : M.toStarSubalgebra) : H →L[ℂ] H) (x k))).re| < ε) ∧
+      ∀ j, ‖finitePredualUnitary (subalgebraUnitaryIsometry M.toStarSubalgebra (u j))
+        (finiteVectorDensity w x) - finiteVectorDensity w x‖ < ε := by
+  obtain ⟨φ, hφ, hφa, hc⟩ := expectation_hypertrace M τ E hE hEr hEf
+  have ha (i : I) : IsSelfAdjoint ((a i : M.toStarSubalgebra) : H →L[ℂ] H) :=
+    (a i).property.map M.toStarSubalgebra.subtype
+  have hu (j : J) (T : H →L[ℂ] H) :
+      φ (conjugatedOperator (subalgebraUnitaryIsometry M.toStarSubalgebra (u j)) T) = φ T :=
+    hypertrace_subalgebraUnitary_invariant M.toStarSubalgebra φ hc (u j) T
+  simpa only [hφa] using hypertrace_finite_density
+    (fun i => ((a i : M.toStarSubalgebra) : H →L[ℂ] H)) ha
+    (fun j => subalgebraUnitaryIsometry M.toStarSubalgebra (u j)) φ hφ hu hε
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/ExpectationHypertrace.lean

@@ -0,0 +1,58 @@
+import OAI.Analysis.ModularTheory.CommutantExpectation
+import OAI.Analysis.Nuclearity.CPFaithfulRestriction
+import OAI.Analysis.TracialSplitting.ChallengeDefinitions
+
+namespace OAI
+
+/-! The finite part of the injectivity argument starts with a hypertrace.
+Composing a tracial state with the actual cpc expectation gives that
+hypertrace, since the multiplicative-domain calculation is bimodular. -/
+
+noncomputable section
+open scoped CStarAlgebra ComplexOrder
+
+namespace WeakPureInfiniteness
+
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+theorem expectation_hypertrace (M : VonNeumannAlgebra H)
+    [PartialOrder M.toStarSubalgebra] [StarOrderedRing M.toStarSubalgebra]
+    (τ : Pureness.TracialState M.toStarSubalgebra)
+    (E : (H →L[ℂ] H) →L[ℂ] (H →L[ℂ] H))
+    (hE : CompletelyPositive E) (hEr : ∀ T, E T ∈ M)
+    (hEf : ∀ T, T ∈ M → E T = T) :
+    ∃ φ : (H →L[ℂ] H) →ₚ[ℂ] ℂ, φ 1 = 1 ∧
+      (∀ a : M.toStarSubalgebra, φ a = τ.functional a) ∧
+      ∀ (a : M.toStarSubalgebra) (T : H →L[ℂ] H),
+        φ ((a : H →L[ℂ] H) * T) = φ (T * (a : H →L[ℂ] H)) := by
+  let ι := M.toStarSubalgebra.subtype
+  let F : (H →L[ℂ] H) →L[ℂ] M.toStarSubalgebra :=
+    E.codRestrict M.toStarSubalgebra.toSubalgebra.toSubmodule hEr
+  have hF : CompletelyPositive F := by
+    apply completelyPositive_of_faithful_postcomp F ι.toNonUnitalStarAlgHom Subtype.val_injective
+    exact hE
+  have he (a : M.toStarSubalgebra) : F (ι a) = a := by
+    apply Subtype.ext
+    exact hEf _ a.property
+  let φ : (H →L[ℂ] H) →ₚ[ℂ] ℂ :=
+    PositiveLinearMap.mk₀ (τ.functional.toLinearMap.comp F.toLinearMap)
+      (fun T hT => τ.functional.map_nonneg (completelyPositive_map_nonneg hF hT))
+  refine ⟨φ, ?_, ?_, ?_⟩
+  · change τ.functional (F 1) = 1
+    have h1 : F 1 = 1 := by simpa only [map_one] using he 1
+    rw [h1, τ.normalized]
+  · intro a
+    change τ.functional (F (ι a)) = τ.functional a
+    rw [he]
+  · intro a T
+    change τ.functional (F (ι a * T)) = τ.functional (F (T * ι a))
+    rw [cp_extension_representation_mul_left ι (StarAlgHom.id ℂ M.toStarSubalgebra)
+      F hF he, cp_extension_representation_mul_right ι (StarAlgHom.id ℂ M.toStarSubalgebra)
+      F hF he]
+    exact τ.tracial a (F T)
+
+end WeakPureInfiniteness
+
+end
+
+end OAI

lean/OAI/Analysis/OperatorAlgebra/FiniteHilbertCompression.lean

@@ -0,0 +1,120 @@
+import OAI.Analysis.WeakInfiniteness.MatrixRepresentation
+import OAI.Analysis.WeakInfiniteness.CentralState
+
+namespace OAI
+
+/-! # Completely positive compression to a finite Hilbert space
+
+This is the compression used for the finite Fock-space approximations.
+-/
+
+noncomputable section
+open scoped CStarAlgebra ComplexOrder InnerProductSpace
+
+namespace WeakPureInfiniteness
+
+section Amplification
+
+variable {E H n : Type*} [Fintype n]
+  [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+def amplifyHilbertMap (V : E →L[ℂ] H) :
+    PiLp 2 (fun _ : n => E) →L[ℂ] PiLp 2 (fun _ : n => H) :=
+  (PiLp.continuousLinearEquiv 2 ℂ (fun _ : n => H)).symm.toContinuousLinearMap.comp
+    ((ContinuousLinearMap.pi fun i => V.comp (ContinuousLinearMap.proj i)).comp
+      (PiLp.continuousLinearEquiv 2 ℂ (fun _ : n => E)).toContinuousLinearMap)
+
+omit [Fintype n] [CompleteSpace E] [CompleteSpace H] in
+@[simp] lemma amplifyHilbertMap_apply (V : E →L[ℂ] H)
+    (x : PiLp 2 (fun _ : n => E)) (i : n) :
+    amplifyHilbertMap V x i = V (x i) := by simp [amplifyHilbertMap]
+
+lemma amplifyHilbertMap_adjoint (V : E →L[ℂ] H) :
+    amplifyHilbertMap (n := n) V.adjoint = (amplifyHilbertMap (n := n) V).adjoint := by
+  rw [ContinuousLinearMap.eq_adjoint_iff]
+  intro x y
+  simp only [PiLp.inner_apply, amplifyHilbertMap_apply,
+    ContinuousLinearMap.adjoint_inner_left]
+
+end Amplification
+
+section Compression
+
+variable {A E H : Type*}
+  [NonUnitalCStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+  [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]
+  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+def hilbertCompressionLinear (π : A →⋆ₙₐ[ℂ] (H →L[ℂ] H)) (V : E →L[ℂ] H) :
+    A →ₗ[ℂ] (E →L[ℂ] E) where
+  toFun a := V.adjoint.comp ((π a).comp V)
+  map_add' a b := by ext x; simp
+  map_smul' c a := by ext x; simp
+
+omit [PartialOrder A] [StarOrderedRing A] in
+lemma hilbertCompressionLinear_bound (π : A →⋆ₙₐ[ℂ] (H →L[ℂ] H))
+    (V : E →L[ℂ] H) (a : A) :
+    ‖hilbertCompressionLinear π V a‖ ≤ (‖V‖ * ‖V‖) * ‖a‖ := by
+  calc
+    _ ≤ ‖V.adjoint‖ * (‖π a‖ * ‖V‖) :=
+      (ContinuousLinearMap.opNorm_comp_le _ _).trans
+        (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (norm_nonneg _))
+    _ ≤ ‖V‖ * (‖a‖ * ‖V‖) := by
+      rw [ContinuousLinearMap.adjoint.norm_map]
+      gcongr
+      exact NonUnitalStarAlgHom.norm_apply_le π a
+    _ = _ := by ring
+
+def hilbertCompression (π : A →⋆ₙₐ[ℂ] (H →L[ℂ] H)) (V : E →L[ℂ] H) :
+    A →L[ℂ] (E →L[ℂ] E) :=
+  (hilbertCompressionLinear π V).mkContinuous (‖V‖ * ‖V‖)
+    (hilbertCompressionLinear_bound π V)
+
+omit [PartialOrder A] [StarOrderedRing A] in
+@[simp] lemma hilbertCompression_apply (π : A →⋆ₙₐ[ℂ] (H →L[ℂ] H))
+    (V : E →L[ℂ] H) (a : A) :
+    hilbertCompression π V a = V.adjoint.comp ((π a).comp V) := rfl
+
+omit [PartialOrder A] [StarOrderedRing A] in
+lemma hilbertCompression_norm_le (π : A →⋆ₙₐ[ℂ] (H →L[ℂ] H))
+    (V : E →L[ℂ] H) : ‖hilbertCompression π V‖ ≤ ‖V‖ * ‖V‖ :=
+  ContinuousLinearMap.opNorm_le_bound _ (mul_nonneg (norm_nonneg _) (norm_nonneg _))
+    (hilbertCompressionLinear_bound π V)
+
+lemma hilbertCompression_cp (π : A →⋆ₙₐ[ℂ] (H →L[ℂ] H)) (V : E →L[ℂ] H) :
+    CompletelyPositive (hilbertCompression π V) := by
+  intro n X hX
+  let Y : CStarMatrix (Fin n) (Fin n) (E →L[ℂ] E) :=
+    CStarMatrix.ofMatrix (fun i j => hilbertCompression π V (X i j))
+  let Z := CStarMatrix.mapₙₐ π X
+  have hZ : 0 ≤ matrixOperator Z := by
+    change 0 ≤ matrixOperatorHom (n := Fin n) (H := H) Z
+    exact map_nonneg (matrixOperatorHom (n := Fin n) (H := H))
+      (map_nonneg (CStarMatrix.mapₙₐ π) hX)
+  have he : matrixOperator Y = (amplifyHilbertMap (n := Fin n) V).adjoint.comp
+      ((matrixOperator Z).comp (amplifyHilbertMap V)) := by
+    rw [← amplifyHilbertMap_adjoint]
+    ext x i
+    simp only [matrixOperator_apply, ContinuousLinearMap.comp_apply,
+      amplifyHilbertMap_apply, map_sum]
+    rfl
+  have hY : 0 ≤ matrixOperator Y := by
+    rw [he, ContinuousLinearMap.nonneg_iff_isPositive]
+    exact (ContinuousLinearMap.nonneg_iff_isPositive.mp hZ).adjoint_conj
+      (amplifyHilbertMap (n := Fin n) V)
+  have hreflect := (NonUnitalStarAlgHom.map_le_map_iff
+    (matrixOperatorHom (n := Fin n) (H := E)) matrixOperator_injective
+    (x := 0) (y := Y)).mp
+  apply hreflect
+  rw [map_zero]
+  change 0 ≤ matrixOperator Y
+  exact hY
+
+end Compression
+
+end WeakPureInfiniteness
+
+end
+
+end OAI