Lean statement

Failure of rational injectivity for ordinary coarse assembly

Lean is a language for mathematical statements and proofs that a computer can verify. This page shows one statement file from OpenAI’s release, possible paper matches and independent reports. The code-like names below identify the definitions or theorems selected by the proof-verification settings.

Theorem selected for verification: OAI.CoarseAssembly.bounded_geometry_graph_counterexample_unconditional

Lean statement file: CoarseAssembly.leanShow on the mapOpenAI’s Lean catalogue does not list this as a main result; the release’s Lean notes for family 307 link it.

See the candidate theorem Who ran the proof-verification program Report a comparison with the paper (GitHub issue)

The Lean statement

The lines of the Lean statement that state the theorem, then the definitions in the file that it uses.

theorem bounded_geometry_graph_counterexample_unconditional :    (∀ j, Finite (FiberVertex j) ∧      (fiberedGraph elementaryMoves chosenHolonomyUnit j).Connected) ∧    (∃ D : ℕ, ∀ j (x : FiberVertex j),      Nat.card {y // (fiberedGraph elementaryMoves chosenHolonomyUnit j).Adj x y} ≤ D) ∧    ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧      (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧      ∃ α : KX1 VertexUnion,        (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ constructedCoarseAssembly α = 0 ∧        (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧        ¬ Function.Injective constructedCoarseAssembly ∧        ¬ Function.Injective (constructedCoarseAssembly.toIntLinearMap.lTensor ℚ) := by  sorry

A Lean statement states the theorem and leaves its proof as sorry on purpose. OpenAI’s proof is in a separate solution module, and a program called Comparator checks that proof against this statement.

Definitions needed to read it

Local definitions the statement names, followed through the definitions they name in turn. The match is by name in the source text, so a name reached only through notation can be missed; the full file is below.

definition OAI.CoarseAssembly.operatorConjugation line 262

noncomputable def operatorConjugation (V : E →ₗᵢ[ℂ] F) (T : E →L[ℂ] E) : F →L[ℂ] F :=  V.toContinuousLinearMap ∘L T ∘L V.toContinuousLinearMap.adjoint

definition OAI.CoarseAssembly.operatorConjugationHom line 265

noncomputable def operatorConjugationHom (V : E →ₗᵢ[ℂ] F) :    (E →L[ℂ] E) →⋆ₙₐ[ℂ] (F →L[ℂ] F) := by

Show the remaining 26 lines

  classical  have OAI.CoarseAssembly.operatorConjugation_mul {E : Type _} {F : Type _} [inst_local_2 : NormedAddCommGroup E] [inst_local_3 : InnerProductSpace ℂ E] [inst_local_4 : CompleteSpace E] [inst_local_5 : NormedAddCommGroup F] [inst_local_6 : InnerProductSpace ℂ F] [inst_local_7 : CompleteSpace F] (V : E →ₗᵢ[ℂ] F) (T S : E →L[ℂ] E) :      OAI.CoarseAssembly.operatorConjugation V (T * S) = OAI.CoarseAssembly.operatorConjugation V T * OAI.CoarseAssembly.operatorConjugation V S  :=    open OAI OAI.CoarseAssembly in    by      have hV (z : E) : V.toContinuousLinearMap.adjoint (V z) = z := by        simpa only [ContinuousLinearMap.comp_apply, one_apply_eq_self,          LinearIsometry.coe_toContinuousLinearMap] using DFunLike.congr_fun V.adjoint_comp_self z      ext x      simp [OAI.CoarseAssembly.operatorConjugation, hV]  exact {    toFun := OAI.CoarseAssembly.operatorConjugation V    map_zero' := by simp [OAI.CoarseAssembly.operatorConjugation]    map_add' T S := by simp [OAI.CoarseAssembly.operatorConjugation, ContinuousLinearMap.comp_add,      ContinuousLinearMap.add_comp]    map_mul' := OAI.CoarseAssembly.operatorConjugation_mul V    map_smul' c T := by simp [OAI.CoarseAssembly.operatorConjugation]    map_star' := (    let local_proof {E : Type _} {F : Type _} [inst_local_2 : NormedAddCommGroup E] [inst_local_3 : InnerProductSpace ℂ E] [inst_local_4 : CompleteSpace E] [inst_local_5 : NormedAddCommGroup F] [inst_local_6 : InnerProductSpace ℂ F] [inst_local_7 : CompleteSpace F] (V : E →ₗᵢ[ℂ] F) (T : E →L[ℂ] E) :        OAI.CoarseAssembly.operatorConjugation V (star T) = star (OAI.CoarseAssembly.operatorConjugation V T) :=      open OAI OAI.CoarseAssembly in        by          simp [OAI.CoarseAssembly.operatorConjugation, ContinuousLinearMap.star_eq_adjoint,            ContinuousLinearMap.adjoint_comp, ContinuousLinearMap.comp_assoc]    local_proof) V  }

abbreviation OAI.CoarseAssembly.Congruence.ArithmeticGroup line 302

abbrev ArithmeticGroup := Matrix.SpecialLinearGroup (Fin 3) ℤ

abbreviation OAI.CoarseAssembly.Congruence.Quotient line 304

abbrev Quotient (k : ℕ) := Matrix.SpecialLinearGroup (Fin 3) (ZMod (2 ^ k))

definition OAI.CoarseAssembly.Congruence.reduce line 306

def reduce (k : ℕ) : ArithmeticGroup →* Quotient k :=  Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod (2 ^ k)))

definition OAI.CoarseAssembly.Congruence.diagonal line 309

def diagonal {R : Type*} [CommRing R] (t : Rˣ) : Matrix.SpecialLinearGroup (Fin 3) R :=  ⟨Matrix.diagonal ![(t : R), ((t⁻¹ : Rˣ) : R), 1], by    simp [Matrix.det_diagonal, Fin.prod_univ_succ]⟩

definition OAI.CoarseAssembly.Congruence.holonomy line 313

noncomputable def holonomy (t : ℤ_[2]ˣ) (k : ℕ) : Quotient k :=  diagonal (Units.map (PadicInt.toZModPow k).toMonoidHom t)

definition OAI.CoarseAssembly.Congruence.residueMap line 324

def residueMap {l k : ℕ} (h : l ≤ k) : ZMod (2 ^ k) →+* ZMod (2 ^ l) :=  ZMod.castHom (pow_dvd_pow 2 h) _

definition OAI.CoarseAssembly.Congruence.quotientMap line 327

def quotientMap {l k : ℕ} (h : l ≤ k) : Quotient k →* Quotient l :=  Matrix.SpecialLinearGroup.map (residueMap h)

definition OAI.CoarseAssembly.separatedDist line 411

def separatedDist (o : ∀ i, V i) (x y : Sigma V) : ℝ :=  if h : x.1 = y.1 then dist (h ▸ x.2) y.2  else dist x.2 (o x.1) + ((x.1 : ℝ) + (y.1 : ℝ) + 2) + dist (o y.1) y.2

definition OAI.CoarseAssembly.separatedMetric line 415

@[instance_reducible] def separatedMetric (o : ∀ i, V i) : MetricSpace (Sigma V) := by

Show the remaining 158 lines

  classical  have OAI.CoarseAssembly.separatedDist_comm {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (x y : Sigma V) :      OAI.CoarseAssembly.separatedDist o x y = OAI.CoarseAssembly.separatedDist o y x  :=    open OAI OAI.CoarseAssembly in    by      rcases x with ⟨i, x⟩      rcases y with ⟨j, y⟩      by_cases h : i = j      · subst j; simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof), dist_comm]      · rw [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o h, (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o (Ne.symm h)]        simp only [dist_comm y (o j), dist_comm (o i) x]        ring  have OAI.CoarseAssembly.separatedDist_triangle {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (x y z : Sigma V) :      OAI.CoarseAssembly.separatedDist o x z ≤ OAI.CoarseAssembly.separatedDist o x y + OAI.CoarseAssembly.separatedDist o y z  :=    open OAI OAI.CoarseAssembly in    by      rcases x with ⟨i, x⟩      rcases y with ⟨j, y⟩      rcases z with ⟨k, z⟩      by_cases hij : i = j      · subst j        by_cases hik : i = k        · subst k; simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof)]; exact dist_triangle _ _ _        · simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof), (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hik]          linarith [dist_triangle x y (o i)]      · by_cases hjk : j = k        · subst k          simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof), (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hij]          linarith [dist_triangle (o j) y z]        · by_cases hik : i = k          · subst k            simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof), (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hij,              (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o (Ne.symm hij)]            have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i            have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j            linarith [dist_triangle x (o i) z, dist_nonneg (x := y) (y := o j),              dist_nonneg (x := o j) (y := y)]          · simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hik, (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hij,              (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hjk]            have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j            linarith [dist_nonneg (x := y) (y := o j), dist_nonneg (x := o j) (y := y)]  exact {    dist := OAI.CoarseAssembly.separatedDist o    dist_self x := by rcases x with ⟨i, x⟩; simp [OAI.CoarseAssembly.separatedDist]    dist_comm := OAI.CoarseAssembly.separatedDist_comm o    dist_triangle := OAI.CoarseAssembly.separatedDist_triangle o    eq_of_dist_eq_zero := by      rintro ⟨i, x⟩ ⟨j, y⟩ h      by_cases hij : i = j      · subst j        simp only [(    let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :        OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=      open OAI OAI.CoarseAssembly in        dite_eq_left rfl    local_proof), dist_eq_zero] at h        subst y        rfl      · rw [(    let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)        (x : V i) (y : V j) :        OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =        dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=      open OAI OAI.CoarseAssembly in        dite_eq_right h    local_proof) o hij] at h        have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i        have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j        linarith [dist_nonneg (x := x) (y := o i), dist_nonneg (x := o j) (y := y)]  }

abbreviation OAI.CoarseAssembly.DiscreteRoe.Module line 595

abbrev Module (X H : Type*) [NormedAddCommGroup H] := lp (fun _ : X => H) 2

abbreviation OAI.CoarseAssembly.DiscreteRoe.Operator line 597

abbrev Operator (X H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] :=  Module X H →L[ℂ] Module X H

definition OAI.CoarseAssembly.DiscreteRoe.insert line 600

def insert (x : X) : H →L[ℂ] Module X H :=  lp.singleContinuousLinearMap ℂ (fun _ : X => H) 2 x

definition OAI.CoarseAssembly.DiscreteRoe.entry line 606

def entry (T : Operator X H) (x y : X) : H →L[ℂ] H :=  coordinate x ∘L T ∘L insert y

definition OAI.CoarseAssembly.DiscreteRoe.CompactEntries line 609

def CompactEntries (T : Operator X H) : Prop :=  ∀ x y, IsCompactOperator (entry T x y)

definition OAI.CoarseAssembly.DiscreteRoe.PropagationLE line 620

def PropagationLE (r : ℝ) (T : Operator X H) : Prop :=  ∀ x y, r < dist x y → entry T x y = 0

definition OAI.CoarseAssembly.DiscreteRoe.Generator line 623

def Generator (T : Operator X H) : Prop :=  (∃ r : ℝ, 0 ≤ r ∧ PropagationLE r T) ∧ CompactEntries T ∧ CompactEntries (star T)

definition OAI.CoarseAssembly.DiscreteRoe.algebra line 626

def algebra : NonUnitalStarSubalgebra ℂ (Operator X H) :=  (NonUnitalStarAlgebra.adjoin ℂ {T : Operator X H | Generator T}).topologicalClosure

definition OAI.CoarseAssembly.DiscreteRoe.conjugationHom line 668

def conjugationHom (V : Module D H →ₗᵢ[ℂ] Module X H)    (hV : MapsToRoe V) :    algebra (X := D) (H := H) →⋆ₙₐ[ℂ] algebra (X := X) (H := H) :=  NonUnitalStarAlgHom.codRestrict    ((operatorConjugationHom V).comp (NonUnitalStarSubalgebraClass.subtype _))    _ (fun T => hV T T.property)

definition OAI.CoarseAssembly.UniformFiniteBalls line 692

def UniformFiniteBalls (D : Type*) [PseudoMetricSpace D] : Prop :=  ∀ R : ℝ, 0 ≤ R → ∃ N : ℕ, ∀ u : D, ∃ b : Finset D,    (∀ v, v ∈ b ↔ dist u v ≤ R) ∧ b.card ≤ N

abbreviation OAI.CoarseAssembly.LatticeVertex line 711
```
abbrev LatticeVertex := ℤ × ℤ
```

definition OAI.CoarseAssembly.latticeRadius line 713

def latticeRadius (u : LatticeVertex) : ℤ :=  max (max |u.1| |u.2|) |u.1 + u.2|

definition OAI.CoarseAssembly.triangularGraph line 716

def triangularGraph : SimpleGraph LatticeVertex where  Adj u v := |u.1 - v.1| ≤ 1 ∧ |u.2 - v.2| ≤ 1 ∧    |(u.1 + u.2) - (v.1 + v.2)| ≤ 1 ∧ u ≠ v  symm := ⟨by intro u v h; simpa only [abs_sub_comm, ne_eq, eq_comm] using h⟩  loopless := ⟨fun _ h => h.2.2.2 rfl⟩

72 more definitions are reached the same way; the full file lists them.

Possible paper match, with no recorded review

No paper statement clearly matched the Lean wording. Statement Map, the program that collects Atlas’s source records, selected this possible match using words in OpenAI’s catalogue and Lean note. No review of whether the statements mean the same thing is recorded.

Shared with the catalogue’s wording or OpenAI’s note, none of them matched in the Lean text: after, assembly, bounded, coarse, connected, degree, discrete, disjoint and ten more.

Statements in A counterexample to the coarse Novikov conjecture come first because the release lists only that paper for this Lean statement.

Theorem 1.1 of A counterexample to the coarse Novikov conjecture

Theorem

There is a uniformly discrete bounded-geometry metric space X, which is a coarse disjoint union of finite connected graphs of uniformly bounded degree, and an infinite-order element \alpha\in KX_1(X) such that

\mu_X(\alpha)=0\quad\text{in }K_1(C^*(X)).

Consequently, ordinary coarse assembly for X fails to be injective both integrally and after tensoring its domain and target with \Q.

Section 1, Introduction Read it in the paper TeX source, line 49

Show the TeX

There is a uniformly discrete bounded-geometry metric space $X$, which is a
coarse disjoint union of finite connected graphs of uniformly bounded degree,
and an infinite-order element $\alpha\in KX_1(X)$ such that
\[
 \mu_X(\alpha)=0\quad\text{in }K_1(C^*(X)).
\]
Consequently, ordinary coarse assembly for $X$ fails to be injective both
integrally and after tensoring its domain and target with $\Q$.

Other possible paper matches, closest wording first

Proposition 5.1 of A counterexample to the coarse Novikov conjecture. Words of the Lean statement, its names split into words, that also appear in the theorem: 1/2, operator, compact, partition, nonempty, locally and 19 more. Shared only with the release’s name for the Lean statement or OpenAI’s note on it: uniformly.
Theorem 1.1 of Failure of rational injectivity for maximal coarse assembly. Words of the Lean statement, its names split into words, that also appear in the theorem: vertex, connected, max, union, graphs, injective and five more. Found in the paper’s title, which its main theorem states: rational and assembly. Shared only with the release’s name for the Lean statement or OpenAI’s note on it: degree, order and infinite.
Proposition 4.4 of Failure of rational injectivity for maximal coarse assembly. Words of the Lean statement, its names split into words, that also appear in the theorem: theory, id, map, conjugation, isometry, induces and one more.
Proposition 4.1 of A counterexample to the coarse Novikov conjecture. Words of the Lean statement, its names split into words, that also appear in the theorem: integer and kx. Shared only with the release’s name for the Lean statement or OpenAI’s note on it: nonzero.
Proposition 4.5 of Failure of rational injectivity for maximal coarse assembly. Words of the Lean statement, its names split into words, that also appear in the theorem: constructed, max and kx.
Proposition 3.5 of Failure of rational injectivity for maximal coarse assembly. Words of the Lean statement, its names split into words, that also appear in the theorem: rational and kx. Shared only with the release’s name for the Lean statement or OpenAI’s note on it: infinite and order.

How Atlas selects possible matches: it compares words in the Lean statement with every statement in the family. It also splits Lean names into words. The release’s label and note receive less weight; a main theorem wins a close match. If the Lean wording yields no clear match, Atlas uses the catalogue description. This selects passages to compare; it does not establish that they mean the same thing.

Reported Comparator runs

Atlas has no report of an independent group using Comparator to verify OpenAI’s proof of this Lean statement at the version shown here. Each group reports its own Comparator run for this statement file. Atlas has not repeated the runs.

For a configured theorem, Comparator tests whether OpenAI’s proof proves the exact Lean statement. Some files instead configure definitions for comparison by name and type. Acceptance does not establish that the statement means the same thing as the paper’s theorem.

Carlos Toledo’s cert-machine

How they ran it, in their words

Every Comparator challenge re-run on Linux with nanoda switched on, decided by a preregistered rule; every family’s challenge statements read against OpenAI’s headline, clause by clause. Decider: Comparator (leanprover/comparator d03acab1 = tag v4.34.0, built with the release’s toolchain v4.34.1), lean4export 076e8e57, landrun 811cfff5, nanoda_lib 3a240721 — on GitHub’s Linux runners (.github/workflows/openai-math-kernel.yml), one j…

No verdict reached Their term: “REFUSED”.
Re-run through Comparator did not reach a verdict (the job ended (failure) in the step "comparator, Lean’s kernel and nanoda" without uploading a result: the runner terminated it (GitHub: Process completed with exit code 143.)).
Reported 10 October 2026, at the release version shown here. Original verification report

MathVet

How they ran it, in their words

An independent, model-assisted, pre-referee reading of each family’s challenge statements against its headline claim under a published rubric (PROTOCOL.md), with its own Comparator runs per challenge. Its protocol describes a planned error-rate study; this import does not establish that the study has been completed.

Built; Comparator not run Their term: “closure-pass”.
The solution was built and its dependency closure checked; Comparator was not run.
Reported 10 October 2026, at the release version shown here. Original verification report

What an accepted Comparator run would establish

If Comparator is run under this configuration and accepts, the solution proves the configured theorem using only the allowed axioms, and the Lean kernel accepts every step.

This configuration lists no definition holes, so every definition the statement uses is compared as it is written in this file.

Allowed axioms: propext, Quot.sound, Classical.choice

Acceptance leaves open whether the Lean statement means the same thing as the paper’s theorem, whether the paper’s other claims are correct, and whether the result is new. Those questions require comparing the definitions and statements, reviewing the paper’s arguments, and reading the earlier literature.

Do family 307’s Lean statements express the advertised result?

These assessments compare all the family’s Lean statements with the whole result OpenAI describes in its catalogue. They do not assess this statement alone. Each group uses its own published rules.

Neither group finds that the Lean statements express or imply the whole advertised result. They describe what the statements express in different terms.

MathVet
Finds part of it stated, or a narrower or weaker statement Their term: “partial”.
Only a special case is stated, or a co-equal headline claim has no challenge statement. Their record
Their note: bounded_geometry_graph_counterexample_unconditional gives finite connected bounded-degree graphs fiberedGraph ... j whose coarse union VertexUnion is proper, has uniformly finite balls and separation ≥ 1, and α ∈ KX1 VertexUnion of infinite order with constructedCoarseAssembly α = 0, 1 ⊗ α ≠ 0 and non-injectivity also after ⊗ ℚ, but the target is K₁ of the *reduced* Roe algebra (DiscreteRoe.algebra; the file header says 'ordinary reduced coarse assembly map'). That is the summary's companion claim (the rational coarse Novikov counterexample); the headline failure for the *maximal* assembly map is strictly stronger (reduced = quotient ∘ maximal, so ker(max) ⊆ ker(reduced)) and has no statement. Title and summary say 'maximal' while docs, lean_scope and the Lean say 'reduced', and Lean wins.
Definitions the group asks readers to compare with the paper: The assembly map is built with totalizing fallbacks: separatedIndexFamily is if h : (∀ r s h a, f s (map r s h a) = f r a) then {atScale := f, compatible := h} else {atScale := fun _ => 0, ..} and analyticFamilyIndex is if h : relations A ≤ (analyticFamilyIndexFree ..).ker then QuotientAddGroup.lift .. else 0, so from the statement alone the map could be the zero map; the solution proves the genuine branches are taken (separatedIndexFamily_atScale, analyticFamilyIndex_eq_lift in OAI/Topology/CoarseAssembly) ; 6,648-line hand-built stack with no Mathlib counterpart: coarse K-homology KX1 X := (coarsening X).Homology (direct limit over Rips complexes of OddK C₀(P_r X, ℂ), odd Fredholm modules mod CycleRelation degenerate/unitary/directSum/homotopy), K1 A := ker (K₁(A⁺) → K₁ ℂ) via TopologicalK1.Relation (mul/stabilize/homotopy), and vertexUnionMetric = graph metrics on the fibres glued by separatedDist (d(x,o_i) + i + j + 2 + d(o_j,y)); read as standard, not independently re-derived. The statement does not itself say that the fibre metrics are the graph metrics.
Carlos Toledo’s cert-machine
Finds part of it stated, or a narrower or weaker statement Their term: “NARROWER — UNLINKED”.
The challenge statements state less than the headline; the missing part comes from a paper the Lean note does not link. Their record
Their note: failure of rational injectivity for the MAXIMAL coarse assembly map (the headline's lead claim, the October-5 manuscript); only the reduced (September-23 companion) result is stated

Read the complete assessments on the family page.

OpenAI’s own note on what this Lean statement covers

“The formalization constructs a counterexample from a coarse disjoint union of finite connected graphs with uniformly bounded degree. Its degree-one coarse $K$-homology contains an infinite-order class whose image under ordinary coarse assembly into the reduced locally compact Roe algebra vanishes. The class remains nonzero after tensoring with $\mathbb Q$, so rational injectivity fails.”
Quoted from OpenAI’s Lean note for this family

An AI agent drafted an interpretation of that note, classifying this statement as “states a paper’s theorem as the paper does”. No human review of the draft is recorded.

Supporting material

The complete Lean statement file

6,648 lines, copied from release version fd4aeeb. A name defined in this file links to its line; pointing at the name shows its definition.

Declared in this fileOpenAI’s library at fd4aeebOther linked names open the current documentation for Mathlib, Lean’s mathematical library.

Links in the file: 1,904 to its own declarations, 3,398 to Mathlib’s documentation. 15 declared names also link to the same declaration in OpenAI’s library. 17 identifiers stay plain because they resolve to no single declaration: variables Lean binds automatically, notation, or names the scan of the pinned sources did not find. 6 of them could name more than one declaration. OpenAI uses Mathlib version d13f23b. The linked documentation describes the current version, so names that have since changed may be missing there.

import Mathlibopen scoped Topologynamespace OAI/-! # A bounded-geometry counterexample to coarse NovikovThe concrete graph union has an infinite-order class killed by itsordinary reduced coarse assembly map, including after rationalization.-/sectionnoncomputable sectionnamespace CoarseAssemblyattribute [-instance] CStarAlgebra.toNormedRing CommCStarAlgebra.toNormedCommRingopen Filteropen scoped Topologyvariable {ι : Type*} {E F : ι → Type*}variable [∀ i, NormedAddCommGroup (E i)] [∀ i, NormedSpace ℂ (E i)]variable [∀ i, NormedAddCommGroup (F i)] [∀ i, NormedSpace ℂ (F i)]def blockLinear (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (_hC : 0 ≤ C)    (hA : ∀ i, ‖A i‖ ≤ C) : lp E 2 →ₗ[ℂ] lp F 2 where  toFun x := ⟨fun i => A i (x i), by    apply ((lp.memℓp x).norm.const_smul C).mono    intro i    exact (A i).le_opNorm (x i) |>.trans (mul_le_mul_of_nonneg_right (hA i) (norm_nonneg _))⟩  map_add' x y := by ext i; exact map_add (A i) _ _  map_smul' c x := by ext i; exact map_smul (A i) _ _def blockOperator (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C)    (hA : ∀ i, ‖A i‖ ≤ C) : lp E 2 →L[ℂ] lp F 2 := by  classical  exact (OAI.CoarseAssembly.blockLinear A C hC hA).mkContinuous C ((    let local_proof {ι : Type _} {E : ι → Type _} {F : ι → Type _} [inst_local_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_local_4 : (i : ι) → NormedSpace ℂ (E i)] [inst_local_5 : (i : ι) → NormedAddCommGroup (F i)] [inst_local_6 : (i : ι) → NormedSpace ℂ (F i)] (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C)        (hA : ∀ i, ‖A i‖ ≤ C) (x : lp E 2) :        ‖OAI.CoarseAssembly.blockLinear A C hC hA x‖ ≤ C * ‖x‖ :=      open OAI OAI.CoarseAssembly in        open Filter in        open scoped Topology in        by          calc            _ ≤ ‖C • lp.toNorm x‖ := by              apply lp.norm_mono (by norm_num : (2 : ENNReal) ≠ 0)              intro i              change ‖A i (x i)‖ ≤ ‖C * ‖x i‖‖              rw [Real.norm_eq_abs, abs_of_nonneg (mul_nonneg hC (norm_nonneg _))]              exact (A i).le_opNorm (x i) |>.trans                (mul_le_mul_of_nonneg_right (hA i) (norm_nonneg _))            _ = C * ‖x‖ := by rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg hC, lp.norm_toNorm]    local_proof) A C hC hA)def blockIsometry (V : ∀ i, E i →ₗᵢ[ℂ] F i) : lp E 2 →ₗᵢ[ℂ] lp F 2 where  toLinearMap := (blockOperator (fun i => (V i).toContinuousLinearMap) 1 zero_le_one    (fun i => (V i).norm_toContinuousLinearMap_le)).toLinearMap  norm_map' x := by    apply le_antisymm    · apply lp.norm_mono (by norm_num : (2 : ENNReal) ≠ 0)      intro i      exact le_of_eq ((V i).norm_map (x i))    · apply lp.norm_mono (by norm_num : (2 : ENNReal) ≠ 0)      intro i      exact le_of_eq ((V i).norm_map (x i)).symmend CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssemblyvariable {ι : Type*} {Q : ι → Type*} {H : Type*}variable [NormedAddCommGroup H] [NormedSpace ℂ H]attribute [-instance] CStarAlgebra.toNormedRing CommCStarAlgebra.toNormedCommRingattribute [local instance 10000] T4Space.t3Space T5Space.toT4Space OrderTopology.t5Space  AddGroup.existsAddOfLEdef flattenVector (x : lp (fun i => lp (fun _ : Q i => H) 2) 2) :    lp (fun _ : Sigma Q => H) 2 := by  classical  exact ⟨fun q => x q.1 q.2, by      apply memℓp_gen      simp only [ENNReal.toReal_ofNat, Real.rpow_two]      apply (summable_sigma_of_nonneg (fun q => sq_nonneg ‖x q.1 q.2‖)).2      refine ⟨fun i => (    let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]        (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) :=      open OAI OAI.CoarseAssembly in        by          simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using            (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal)    local_proof) (x i), ?_⟩      simpa only [← (    let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]        (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 :=      open OAI OAI.CoarseAssembly in        by          simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using            lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x    local_proof)] using (    let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]        (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) :=      open OAI OAI.CoarseAssembly in        by          simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using            (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal)    local_proof) x⟩def rowVector (x : lp (fun _ : Sigma Q => H) 2) (i : ι) : lp (fun _ : Q i => H) 2 := by  classical  exact ⟨fun q => x ⟨i, q⟩, by      apply memℓp_gen      simp only [ENNReal.toReal_ofNat, Real.rpow_two]      exact ((summable_sigma_of_nonneg (fun q => sq_nonneg ‖x q‖)).1        ((    let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]        (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) :=      open OAI OAI.CoarseAssembly in        by          simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using            (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal)    local_proof) x)).1 i⟩def unflattenVector (x : lp (fun _ : Sigma Q => H) 2) :    lp (fun i => lp (fun _ : Q i => H) 2) 2 := by  classical  exact ⟨OAI.CoarseAssembly.rowVector x, by      apply memℓp_gen      simp only [ENNReal.toReal_ofNat, Real.rpow_two, (    let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]        (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 :=      open OAI OAI.CoarseAssembly in        by          simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using            lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x    local_proof)]      exact ((summable_sigma_of_nonneg (fun q => sq_nonneg ‖x q‖)).1        ((    let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]        (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) :=      open OAI OAI.CoarseAssembly in        by          simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using            (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal)    local_proof) x)).2⟩def flattenEquiv :    lp (fun i => lp (fun _ : Q i => H) 2) 2 ≃ₗᵢ[ℂ] lp (fun _ : Sigma Q => H) 2 := by  classical  have OAI.CoarseAssembly.flattenVector_norm {ι : Type _} {Q : ι → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (x : lp (fun i => lp (fun _ : Q i => H) 2) 2) :      ‖OAI.CoarseAssembly.flattenVector x‖ = ‖x‖  :=    open OAI OAI.CoarseAssembly in    by      have hsq : ‖OAI.CoarseAssembly.flattenVector x‖ ^ 2 = ‖x‖ ^ 2 := by        calc          _ = ∑' q, ‖OAI.CoarseAssembly.flattenVector x q‖ ^ 2 := (      let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]          (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 :=        open OAI OAI.CoarseAssembly in          by            simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using              lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x      local_proof) _          _ = ∑' i, ∑' q : Q i, ‖OAI.CoarseAssembly.flattenVector x ⟨i, q⟩‖ ^ 2 :=            Summable.tsum_sigma' (fun i => (      let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]          (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) :=        open OAI OAI.CoarseAssembly in          by            simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using              (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal)      local_proof) (x i))              ((      let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]          (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) :=        open OAI OAI.CoarseAssembly in          by            simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using              (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal)      local_proof) (OAI.CoarseAssembly.flattenVector x))          _ = ∑' i, ‖x i‖ ^ 2 := tsum_congr (fun i => ((      let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]          (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 :=        open OAI OAI.CoarseAssembly in          by            simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using              lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x      local_proof) (x i)).symm)          _ = ‖x‖ ^ 2 := ((      let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]          (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 :=        open OAI OAI.CoarseAssembly in          by            simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using              lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x      local_proof) x).symm      nlinarith [norm_nonneg (OAI.CoarseAssembly.flattenVector x), norm_nonneg x]  exact {    toFun := OAI.CoarseAssembly.flattenVector    invFun := OAI.CoarseAssembly.unflattenVector    left_inv := (    let local_proof {ι : Type _} {Q : ι → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (x : lp (fun i => lp (fun _ : Q i => H) 2) 2) :        OAI.CoarseAssembly.unflattenVector (OAI.CoarseAssembly.flattenVector x) = x :=      open OAI OAI.CoarseAssembly in        by          apply lp.ext          funext i          apply lp.ext          rfl    local_proof)    right_inv := (    let local_proof {ι : Type _} {Q : ι → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (x : lp (fun _ : Sigma Q => H) 2) :        OAI.CoarseAssembly.flattenVector (OAI.CoarseAssembly.unflattenVector x) = x :=      open OAI OAI.CoarseAssembly in        by          apply lp.ext          rfl    local_proof)    map_add' _ _ := rfl    map_smul' _ _ := rfl    norm_map' := OAI.CoarseAssembly.flattenVector_norm  }end CoarseAssemblyendendsectionnamespace CoarseAssemblyvariable {E F H : Type*}variable [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]variable [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F]variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]noncomputable def operatorConjugation (V : E →ₗᵢ[ℂ] F) (T : E →L[ℂ] E) : F →L[ℂ] F :=  V.toContinuousLinearMap ∘L T ∘L V.toContinuousLinearMap.adjointnoncomputable def operatorConjugationHom (V : E →ₗᵢ[ℂ] F) :    (E →L[ℂ] E) →⋆ₙₐ[ℂ] (F →L[ℂ] F) := by  classical  have OAI.CoarseAssembly.operatorConjugation_mul {E : Type _} {F : Type _} [inst_local_2 : NormedAddCommGroup E] [inst_local_3 : InnerProductSpace ℂ E] [inst_local_4 : CompleteSpace E] [inst_local_5 : NormedAddCommGroup F] [inst_local_6 : InnerProductSpace ℂ F] [inst_local_7 : CompleteSpace F] (V : E →ₗᵢ[ℂ] F) (T S : E →L[ℂ] E) :      OAI.CoarseAssembly.operatorConjugation V (T * S) = OAI.CoarseAssembly.operatorConjugation V T * OAI.CoarseAssembly.operatorConjugation V S  :=    open OAI OAI.CoarseAssembly in    by      have hV (z : E) : V.toContinuousLinearMap.adjoint (V z) = z := by        simpa only [ContinuousLinearMap.comp_apply, one_apply_eq_self,          LinearIsometry.coe_toContinuousLinearMap] using DFunLike.congr_fun V.adjoint_comp_self z      ext x      simp [OAI.CoarseAssembly.operatorConjugation, hV]  exact {    toFun := OAI.CoarseAssembly.operatorConjugation V    map_zero' := by simp [OAI.CoarseAssembly.operatorConjugation]    map_add' T S := by simp [OAI.CoarseAssembly.operatorConjugation, ContinuousLinearMap.comp_add,      ContinuousLinearMap.add_comp]    map_mul' := OAI.CoarseAssembly.operatorConjugation_mul V    map_smul' c T := by simp [OAI.CoarseAssembly.operatorConjugation]    map_star' := (    let local_proof {E : Type _} {F : Type _} [inst_local_2 : NormedAddCommGroup E] [inst_local_3 : InnerProductSpace ℂ E] [inst_local_4 : CompleteSpace E] [inst_local_5 : NormedAddCommGroup F] [inst_local_6 : InnerProductSpace ℂ F] [inst_local_7 : CompleteSpace F] (V : E →ₗᵢ[ℂ] F) (T : E →L[ℂ] E) :        OAI.CoarseAssembly.operatorConjugation V (star T) = star (OAI.CoarseAssembly.operatorConjugation V T) :=      open OAI OAI.CoarseAssembly in        by          simp [OAI.CoarseAssembly.operatorConjugation, ContinuousLinearMap.star_eq_adjoint,            ContinuousLinearMap.adjoint_comp, ContinuousLinearMap.comp_assoc]    local_proof) V  }end CoarseAssemblyendsectionnamespace CoarseAssembly.Congruenceabbrev ArithmeticGroup := Matrix.SpecialLinearGroup (Fin 3) ℤabbrev Quotient (k : ℕ) := Matrix.SpecialLinearGroup (Fin 3) (ZMod (2 ^ k))def reduce (k : ℕ) : ArithmeticGroup →* Quotient k :=  Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod (2 ^ k)))def diagonal {R : Type*} [CommRing R] (t : Rˣ) : Matrix.SpecialLinearGroup (Fin 3) R :=  ⟨Matrix.diagonal ![(t : R), ((t⁻¹ : Rˣ) : R), 1], by    simp [Matrix.det_diagonal, Fin.prod_univ_succ]⟩noncomputable def holonomy (t : ℤ_[2]ˣ) (k : ℕ) : Quotient k :=  diagonal (Units.map (PadicInt.toZModPow k).toMonoidHom t)end CoarseAssembly.Congruenceendsectionnamespace CoarseAssembly.Congruencedef residueMap {l k : ℕ} (h : l ≤ k) : ZMod (2 ^ k) →+* ZMod (2 ^ l) :=  ZMod.castHom (pow_dvd_pow 2 h) _def quotientMap {l k : ℕ} (h : l ≤ k) : Quotient k →* Quotient l :=  Matrix.SpecialLinearGroup.map (residueMap h)end CoarseAssembly.Congruenceendsectionnoncomputable sectionnamespace CoarseAssemblyvariable {I : Type*} {Q : I → Type*} {H : Type*}variable [NormedAddCommGroup H] [NormedSpace ℂ H]def flattenOperator    (A : lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ]      lp (fun i => lp (fun _ : Q i => H) 2) 2) :    lp (fun _ : Sigma Q => H) 2 →L[ℂ] lp (fun _ : Sigma Q => H) 2 :=  (flattenEquiv (Q := Q) (H := H)).toLinearIsometry.toContinuousLinearMap.comp    (A.comp (flattenEquiv (Q := Q) (H := H)).symm.toLinearIsometry.toContinuousLinearMap)variable [DecidableEq I] [∀ i, DecidableEq (Q i)]end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssembly@[instance_reducible] def discreteGraphMetric (V : Type*) : MetricSpace V := by  classical  exact {    dist := fun x y => if x = y then 0 else 1    dist_self := by intro x; simp    dist_comm := by intro x y; by_cases hxy : x = y <;> simp_all [eq_comm]    dist_triangle := by intro x y z; split_ifs <;> simp_all    eq_of_dist_eq_zero := by      intro x y hdist      by_contra hxy      simp [hxy] at hdist  }variable {V : Type*} (G : SimpleGraph V)@[instance_reducible] def connectedGraphMetric (hG : G.Connected) : MetricSpace V where  dist x y := (G.dist x y : ℝ)  dist_self x := (congrArg (fun distance : ℕ => (distance : ℝ)) (G.dist_self (v := x))).trans    Nat.cast_zero  dist_comm x y := congrArg (fun distance : ℕ => (distance : ℝ)) (G.dist_comm (u := x) (v := y))  dist_triangle x y z :=    (show (G.dist x z : ℝ) ≤ ((G.dist x y + G.dist y z : ℕ) : ℝ) from      Nat.cast_le.mpr (hG.dist_triangle (u := x) (v := y) (w := z))).trans_eq (Nat.cast_add _ _)  eq_of_dist_eq_zero := by    intro x y h    exact hG.dist_eq_zero_iff.mp (Nat.cast_eq_zero.mp h)@[instance_reducible] def graphMetricOrDiscrete : MetricSpace V := by  classical  exact if hG : G.Connected then connectedGraphMetric G hG else discreteGraphMetric Vend CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssemblyvariable {V : ℕ → Type*} [∀ i, MetricSpace (V i)]def separatedDist (o : ∀ i, V i) (x y : Sigma V) : ℝ :=  if h : x.1 = y.1 then dist (h ▸ x.2) y.2  else dist x.2 (o x.1) + ((x.1 : ℝ) + (y.1 : ℝ) + 2) + dist (o y.1) y.2@[instance_reducible] def separatedMetric (o : ∀ i, V i) : MetricSpace (Sigma V) := by  classical  have OAI.CoarseAssembly.separatedDist_comm {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (x y : Sigma V) :      OAI.CoarseAssembly.separatedDist o x y = OAI.CoarseAssembly.separatedDist o y x  :=    open OAI OAI.CoarseAssembly in    by      rcases x with ⟨i, x⟩      rcases y with ⟨j, y⟩      by_cases h : i = j      · subst j; simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof), dist_comm]      · rw [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o h, (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o (Ne.symm h)]        simp only [dist_comm y (o j), dist_comm (o i) x]        ring  have OAI.CoarseAssembly.separatedDist_triangle {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (x y z : Sigma V) :      OAI.CoarseAssembly.separatedDist o x z ≤ OAI.CoarseAssembly.separatedDist o x y + OAI.CoarseAssembly.separatedDist o y z  :=    open OAI OAI.CoarseAssembly in    by      rcases x with ⟨i, x⟩      rcases y with ⟨j, y⟩      rcases z with ⟨k, z⟩      by_cases hij : i = j      · subst j        by_cases hik : i = k        · subst k; simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof)]; exact dist_triangle _ _ _        · simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof), (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hik]          linarith [dist_triangle x y (o i)]      · by_cases hjk : j = k        · subst k          simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof), (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hij]          linarith [dist_triangle (o j) y z]        · by_cases hik : i = k          · subst k            simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof), (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hij,              (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o (Ne.symm hij)]            have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i            have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j            linarith [dist_triangle x (o i) z, dist_nonneg (x := y) (y := o j),              dist_nonneg (x := o j) (y := y)]          · simp only [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hik, (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hij,              (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hjk]            have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j            linarith [dist_nonneg (x := y) (y := o j), dist_nonneg (x := o j) (y := y)]  exact {    dist := OAI.CoarseAssembly.separatedDist o    dist_self x := by rcases x with ⟨i, x⟩; simp [OAI.CoarseAssembly.separatedDist]    dist_comm := OAI.CoarseAssembly.separatedDist_comm o    dist_triangle := OAI.CoarseAssembly.separatedDist_triangle o    eq_of_dist_eq_zero := by      rintro ⟨i, x⟩ ⟨j, y⟩ h      by_cases hij : i = j      · subst j        simp only [(    let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :        OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=      open OAI OAI.CoarseAssembly in        dite_eq_left rfl    local_proof), dist_eq_zero] at h        subst y        rfl      · rw [(    let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)        (x : V i) (y : V j) :        OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =        dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=      open OAI OAI.CoarseAssembly in        dite_eq_right h    local_proof) o hij] at h        have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i        have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j        linarith [dist_nonneg (x := x) (y := o i), dist_nonneg (x := o j) (y := y)]  }end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoeopen scoped Topologyvariable {X Y H : Type*}variable [NormedAddCommGroup H] [InnerProductSpace ℂ H]variable [DecidableEq X] [DecidableEq Y]abbrev Module (X H : Type*) [NormedAddCommGroup H] := lp (fun _ : X => H) 2abbrev Operator (X H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] :=  Module X H →L[ℂ] Module X Hdef insert (x : X) : H →L[ℂ] Module X H :=  lp.singleContinuousLinearMap ℂ (fun _ : X => H) 2 xdef coordinate (x : X) : Module X H →L[ℂ] H :=  lp.evalCLM ℂ (fun _ : X => H) 2 xdef entry (T : Operator X H) (x y : X) : H →L[ℂ] H :=  coordinate x ∘L T ∘L insert ydef CompactEntries (T : Operator X H) : Prop :=  ∀ x y, IsCompactOperator (entry T x y)variable [CompleteSpace H] [PseudoMetricSpace X]local instance operatorScalarTower : IsScalarTower ℂ (Operator X H) (Operator X H) where  smul_assoc c T S := by ext h; simplocal instance operatorScalarComm : SMulCommClass ℂ (Operator X H) (Operator X H) where  smul_comm c T S := by ext h; simpdef PropagationLE (r : ℝ) (T : Operator X H) : Prop :=  ∀ x y, r < dist x y → entry T x y = 0def Generator (T : Operator X H) : Prop :=  (∃ r : ℝ, 0 ≤ r ∧ PropagationLE r T) ∧ CompactEntries T ∧ CompactEntries (star T)def algebra : NonUnitalStarSubalgebra ℂ (Operator X H) :=  (NonUnitalStarAlgebra.adjoin ℂ {T : Operator X H | Generator T}).topologicalClosureinstance : NonUnitalCStarAlgebra (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)) := by  classical  exact NonUnitalStarSubalgebra.nonUnitalCStarAlgebra _ (h_closed := (    let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in        open scoped Topology in        by          let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩          exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _    local_proof))variable [PseudoMetricSpace Y]end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoeopen scoped Topologyvariable {B D X H : Type*} [DecidableEq B] [DecidableEq D] [DecidableEq X]variable [PseudoMetricSpace B] [PseudoMetricSpace D] [PseudoMetricSpace X]variable [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]def MapsToRoe (V : Module D H →ₗᵢ[ℂ] Module X H) : Prop :=  ∀ T : Operator D H, T ∈ algebra (X := D) (H := H) →    operatorConjugation V T ∈ algebra (X := X) (H := H)def conjugationHom (V : Module D H →ₗᵢ[ℂ] Module X H)    (hV : MapsToRoe V) :    algebra (X := D) (H := H) →⋆ₙₐ[ℂ] algebra (X := X) (H := H) :=  NonUnitalStarAlgHom.codRestrict    ((operatorConjugationHom V).comp (NonUnitalStarSubalgebraClass.subtype _))    _ (fun T => hV T T.property)end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssemblyopen DiscreteRoeopen scoped Topologyvariable {D : Type*} [DecidableEq D] [PseudoMetricSpace D]def UniformFiniteBalls (D : Type*) [PseudoMetricSpace D] : Prop :=  ∀ R : ℝ, 0 ≤ R → ∃ N : ℕ, ∀ u : D, ∃ b : Finset D,    (∀ v, v ∈ b ↔ dist u v ≤ R) ∧ b.card ≤ Nvariable {Q : D → Type*} [∀ u, Fintype (Q u)] [∀ u, Nonempty (Q u)]variable [∀ u, DecidableEq (Q u)] [PseudoMetricSpace (Sigma Q)]variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]end CoarseAssemblyendendsectionnamespace CoarseAssemblyabbrev LatticeVertex := ℤ × ℤdef latticeRadius (u : LatticeVertex) : ℤ :=  max (max |u.1| |u.2|) |u.1 + u.2|def triangularGraph : SimpleGraph LatticeVertex where  Adj u v := |u.1 - v.1| ≤ 1 ∧ |u.2 - v.2| ≤ 1 ∧    |(u.1 + u.2) - (v.1 + v.2)| ≤ 1 ∧ u ≠ v  symm := ⟨by intro u v h; simpa only [abs_sub_comm, ne_eq, eq_comm] using h⟩  loopless := ⟨fun _ h => h.2.2.2 rfl⟩def Disc (j : ℕ) := {u : LatticeVertex // latticeRadius u ≤ (j : ℤ)}noncomputable instance (j : ℕ) : Fintype (OAI.CoarseAssembly.Disc j) := by  classical  exact ((    let local_proof (j : ℕ) : {u : OAI.CoarseAssembly.LatticeVertex | OAI.CoarseAssembly.latticeRadius u ≤ (j : ℤ)}.Finite :=      open OAI OAI.CoarseAssembly in        by          apply ((Set.finite_Icc (-(j : ℤ)) j).prod (Set.finite_Icc (-(j : ℤ)) j)).subset          intro u hu          simp only [Set.mem_ofPred_eq, OAI.CoarseAssembly.latticeRadius, max_le_iff, abs_le] at hu          exact ⟨hu.1.1, hu.1.2⟩    local_proof) j).fintypedef discGraph (j : ℕ) : SimpleGraph (Disc j) where  Adj u v := triangularGraph.Adj u.val v.val  symm := ⟨fun _ _ h => h.symm⟩  loopless := ⟨fun _ h => h.2.2.2 rfl⟩def discDepth (j : ℕ) (u : Disc j) : ℕ := ((j : ℤ) - latticeRadius u.val).toNatend CoarseAssemblyendsectionnamespace CoarseAssemblydef latticeCharge (u v : LatticeVertex) : ℤ :=  if u.2 < 0 ∧ v.2 = 0 ∧ 0 < v.1 then 1  else if v.2 < 0 ∧ u.2 = 0 ∧ 0 < u.1 then -1 else 0end CoarseAssemblyendsectionnamespace CoarseAssemblyopen Setvariable {p : ℕ} [Fact p.Prime]sectionattribute [local instance 1001] instIsDomain BaireSpace.of_completelyPseudoMetrizable  T3Space.toT0Space T4Space.t3Space instT4SpaceOfT1SpaceOfNormalSpace  T2Space.t1Space TopologicalSpace.t2Space_of_metrizableSpace  CompletelyNormalSpace.toNormalSpace  UniformSpace.completelyNormalSpace_of_isCountablyGenerated_uniformityendend CoarseAssemblyendsectionnamespace CoarseAssembly.Congruencenoncomputable def chosenHolonomyUnit : ℤ_[2]ˣ := by  classical  have OAI.CoarseAssembly.exists_transcendental_principal_unit {p : ℕ} [inst_local_1 : Fact (Nat.Prime p)] :      ∃ t : ℤ_[p]ˣ, Transcendental ℤ (t : ℤ_[p]) ∧        ∃ a : ℤ_[p], (t : ℤ_[p]) = 1 + (p : ℤ_[p]) * a  :=    open OAI OAI.CoarseAssembly in    open Set in    by      obtain ⟨x, hx, hclose⟩ :=        ((      let local_proof {p : ℕ} [inst_local_1 : Fact (Nat.Prime p)] : Dense {x : ℚ_[p] | Transcendental ℤ x} :=        open OAI OAI.CoarseAssembly in          open Set in          by            have hcount : Set.Countable {x : ℚ_[p] | IsAlgebraic ℤ x} :=              Algebraic.countable ℤ ℚ_[p]            have hd : Dense (⋂ x ∈ {x : ℚ_[p] | IsAlgebraic ℤ x}, ({x}ᶜ : Set ℚ_[p])) :=              dense_biInter_of_isOpen (fun _ _ => isOpen_compl_singleton) hcount                (fun x _ => dense_compl_singleton x)            apply hd.mono            intro x hx hxalg            have hxnot := Set.mem_iInter₂.mp hx x hxalg            exact hxnot (Set.mem_singleton x)      @local_proof) (p := p)).exists_dist_lt (1 : ℚ_[p]) zero_lt_one      have hnear : ‖x - 1‖ < 1 := by        simpa only [dist_eq_norm, norm_sub_rev] using hclose      have hxnorm : ‖x‖ = 1 := by        simpa only [norm_one] using Padic.norm_eq_of_norm_sub_lt_right          (show ‖x - 1‖ < ‖(1 : ℚ_[p])‖ by simpa using hnear)      let z : ℤ_[p] := ⟨x, hxnorm.le⟩      have hznorm : ‖z‖ = 1 := hxnorm      obtain ⟨t, ht⟩ := PadicInt.isUnit_iff.mpr hznorm      refine ⟨t, ?_, ?_⟩      · rw [ht]        intro hzalg        let f : ℤ_[p] →ₐ[ℤ] ℚ_[p] :=          { PadicInt.Coe.ringHom with commutes' := fun n => by simp }        exact hx (hzalg.algHom f)      · have hzclose : ‖z - 1‖ < 1 := hnear        obtain ⟨a, ha⟩ := (PadicInt.norm_lt_one_iff_dvd (z - 1)).mp hzclose        refine ⟨a, ?_⟩        rw [ht]        linear_combination ha  exact (OAI.CoarseAssembly.exists_transcendental_principal_unit (p := 2)).chooseend CoarseAssembly.Congruenceendsectionnoncomputable sectionnamespace CoarseAssemblyopen Congruencedef symmetricMoves (S : Finset ArithmeticGroup) : Finset ArithmeticGroup :=  insert 1 (S ∪ S.image Inv.inv)abbrev FiberVertex (j : ℕ) := (u : Disc j) × Quotient (discDepth j u)instance (j : ℕ) : Fintype (FiberVertex j) := inferInstancedef fiberCoordinate {j l : ℕ} (x : FiberVertex j) (h : l ≤ discDepth j x.1) : Quotient l :=  quotientMap h x.2def fiberCharge {j : ℕ} (x y : FiberVertex j) : ℤ :=  latticeCharge x.1.val y.1.valdef LiftStep (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) {j : ℕ}    (x y : FiberVertex j) : Prop :=  ∃ s ∈ symmetricMoves S,    (x.1 = y.1 ∨ (discGraph j).Adj x.1 y.1 ∧ s = 1) ∧    ∀ l (hx : l ≤ discDepth j x.1) (hy : l ≤ discDepth j y.1),      fiberCoordinate y hy = reduce l s * fiberCoordinate x hx *        holonomy t l ^ fiberCharge x ydef fiberedGraph (S : Finset OAI.CoarseAssembly.Congruence.ArithmeticGroup) (t : ℤ_[2]ˣ) (j : ℕ) :    SimpleGraph (OAI.CoarseAssembly.FiberVertex j) := by  classical  have OAI.CoarseAssembly.liftStep_reverse {S : Finset OAI.CoarseAssembly.Congruence.ArithmeticGroup} {t : ℤ_[2]ˣ} {j : ℕ}      {x y : OAI.CoarseAssembly.FiberVertex j} (h : OAI.CoarseAssembly.LiftStep S t x y) : OAI.CoarseAssembly.LiftStep S t y x  :=    open OAI OAI.CoarseAssembly in    open Congruence in    by      obtain ⟨s, hs, hp, he⟩ := h      refine ⟨s⁻¹, (      let local_proof {S : Finset OAI.CoarseAssembly.Congruence.ArithmeticGroup} {s : OAI.CoarseAssembly.Congruence.ArithmeticGroup}          (h : s ∈ OAI.CoarseAssembly.symmetricMoves S) : s⁻¹ ∈ OAI.CoarseAssembly.symmetricMoves S :=        open OAI OAI.CoarseAssembly in          open Congruence in          by            simp only [OAI.CoarseAssembly.symmetricMoves, Finset.mem_insert, Finset.mem_union, Finset.mem_image] at *            rcases h with h | h | ⟨a, ha, rfl⟩            · left; simp [h]            · exact Or.inr (Or.inr ⟨s, h, rfl⟩)            · exact Or.inr (Or.inl (by simpa using ha))      local_proof) hs, ?_, ?_⟩      · rcases hp with hp | ⟨hp, rfl⟩        · exact Or.inl hp.symm        · exact Or.inr ⟨hp.symm, inv_one⟩      · intro l hy hx        have hc : OAI.CoarseAssembly.fiberCharge y x = -OAI.CoarseAssembly.fiberCharge x y := (      let local_proof (u v : OAI.CoarseAssembly.LatticeVertex) : OAI.CoarseAssembly.latticeCharge v u = -OAI.CoarseAssembly.latticeCharge u v :=        open OAI OAI.CoarseAssembly in          by            simp only [OAI.CoarseAssembly.latticeCharge]            split_ifs <;> omega      local_proof) _ _        rw [hc, map_inv, zpow_neg, he l hx hy]        group  exact {    Adj x y := x ≠ y ∧ OAI.CoarseAssembly.LiftStep S t x y    symm := ⟨fun _ _ h => ⟨Ne.symm h.1, OAI.CoarseAssembly.liftStep_reverse h.2⟩⟩    loopless := ⟨fun _ h => h.1 rfl⟩  }end CoarseAssemblyendendnoncomputable sectionnamespace CoarseAssemblyopen Congruencesectionattribute [local instance 1001] IsStrictOrderedRing.toIsOrderedRing Int.instSemiringdef discBoundaryBase (j : ℕ) : Disc j :=  ⟨((j : ℤ), 0), by simp [latticeRadius, max_self]⟩enddef fiberBoundaryBase (j : ℕ) : FiberVertex j := ⟨discBoundaryBase j, 1⟩end CoarseAssemblyendsectionnoncomputable sectionnamespace CoarseAssemblyopen Congruenceabbrev BaseUnion := (j : ℕ) × Disc jabbrev BaseFiber (u : BaseUnion) := Quotient (discDepth u.1 u.2)abbrev VertexUnion := Sigma BaseFibernoncomputable instance baseUnionDecidableEq : DecidableEq BaseUnion := Classical.decEq _noncomputable instance vertexUnionDecidableEq : DecidableEq VertexUnion :=  inferInstanceAs (DecidableEq (Sigma BaseFiber))@[instance_reducible] def componentMetric (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ)    (j : ℕ) : MetricSpace (FiberVertex j) :=  graphMetricOrDiscrete (fiberedGraph S t j)@[instance_reducible] def componentUnionMetric (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) :    MetricSpace ((j : ℕ) × FiberVertex j) := by  letI := componentMetric S t  exact separatedMetric fiberBoundaryBase@[instance_reducible] def vertexUnionMetric (S : Finset ArithmeticGroup) (t : ℤ_[2]ˣ) :    MetricSpace VertexUnion := by  letI := componentUnionMetric S t  exact (Equiv.sigmaAssoc (fun j u => Quotient (discDepth j u))).metricSpaceend CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssemblyopen Congruencedef positiveElementaryMove (p : Fin 3 × Fin 3) : ArithmeticGroup :=  if h : p.1 ≠ p.2 then Matrix.SpecialLinearGroup.transvection h (1 : ℤ) else 1def elementaryMoves : Finset ArithmeticGroup :=  symmetricMoves (Finset.univ.image positiveElementaryMove)abbrev AmpleSpace := lp (fun _ : ℕ => ℂ) 2end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticuniverse ustructure HilbertSpace where  Carrier : Type u  normed : NormedAddCommGroup Carrier  inner : InnerProductSpace ℂ Carrier  complete : CompleteSpace Carrier  secondCountable : SecondCountableTopology Carrierattribute [instance] HilbertSpace.normed HilbertSpace.inner  HilbertSpace.complete HilbertSpace.secondCountableinstance : CoeSort HilbertSpace (Type u) := ⟨HilbertSpace.Carrier⟩abbrev End (H : HilbertSpace) := H →L[ℂ] Hvariable (A : Type u) [NonUnitalCStarAlgebra A]structure OddCycle where  space : HilbertSpace.{u}  representation : A →⋆ₙₐ[ℂ] End space  operator : End space  commutator_compact : ∀ a : A,    IsCompactOperator (operator * representation a - representation a * operator : End space)  square_compact : ∀ a : A,    IsCompactOperator ((operator * operator - 1) * representation a : End space)  adjoint_compact : ∀ a : A,    IsCompactOperator ((star operator - operator) * representation a : End space)variable {A} {B : Type u} [NonUnitalCStarAlgebra B]namespace OddCycledef Degenerate (c : OddCycle A) : Prop :=  (∀ a, c.operator * c.representation a - c.representation a * c.operator = 0) ∧  (∀ a, (c.operator * c.operator - 1) * c.representation a = 0) ∧  (∀ a, (star c.operator - c.operator) * c.representation a = 0)def precomp (c : OddCycle A) (φ : B →⋆ₙₐ[ℂ] A) : OddCycle B where  space := c.space  representation := c.representation.comp φ  operator := c.operator  commutator_compact b := c.commutator_compact (φ b)  square_compact b := c.square_compact (φ b)  adjoint_compact b := c.adjoint_compact (φ b)structure UnitaryEquivalent (c d : OddCycle A) where  unitary : c.space ≃ₗᵢ[ℂ] d.space  representation_eq : ∀ a,    d.representation a = operatorConjugation unitary.toLinearIsometry (c.representation a)  operator_eq : d.operator = operatorConjugation unitary.toLinearIsometry c.operatordef UnitaryEquivalent.precomp {c d : OddCycle A} (e : UnitaryEquivalent c d)    (φ : B →⋆ₙₐ[ℂ] A) : UnitaryEquivalent (c.precomp φ) (d.precomp φ) where  unitary := e.unitary  representation_eq b := e.representation_eq (φ b)  operator_eq := e.operator_eqstructure IsDirectSum (c d e : OddCycle A) where  left : c.space →ₗᵢ[ℂ] e.space  right : d.space →ₗᵢ[ℂ] e.space  orthogonal : left.toContinuousLinearMap.adjoint ∘L right.toContinuousLinearMap = 0  exhaustive : left.toContinuousLinearMap.comp left.toContinuousLinearMap.adjoint +    right.toContinuousLinearMap.comp right.toContinuousLinearMap.adjoint = 1  representation_eq : ∀ a,    e.representation a = operatorConjugation left (c.representation a) +      operatorConjugation right (d.representation a)  operator_eq : e.operator = operatorConjugation left c.operator +    operatorConjugation right d.operatordef IsDirectSum.precomp {c d e : OddCycle A} (h : IsDirectSum c d e)    (φ : B →⋆ₙₐ[ℂ] A) : IsDirectSum (c.precomp φ) (d.precomp φ) (e.precomp φ) where  left := h.left  right := h.right  orthogonal := h.orthogonal  exhaustive := h.exhaustive  representation_eq b := h.representation_eq (φ b)  operator_eq := h.operator_eqend OddCycleabbrev Interval := Set.Icc (0 : ℝ) 1def start : Interval := ⟨0, by norm_num⟩def finish : Interval := ⟨1, by norm_num⟩structure OddHomotopy (A : Type u) [NonUnitalCStarAlgebra A] where  space : HilbertSpace.{u}  representation : Interval → A →⋆ₙₐ[ℂ] End space  operator : Interval → End space  continuous_representation : ∀ a, Continuous (fun t => representation t a)  continuous_operator : Continuous operator  commutator_compact : ∀ t a,    IsCompactOperator (operator t * representation t a - representation t a * operator t : End space)  square_compact : ∀ t a,    IsCompactOperator ((operator t * operator t - 1) * representation t a : End space)  adjoint_compact : ∀ t a,    IsCompactOperator ((star (operator t) - operator t) * representation t a : End space)namespace OddHomotopydef eval (h : OddHomotopy A) (t : Interval) : OddCycle A where  space := h.space  representation := h.representation t  operator := h.operator t  commutator_compact := h.commutator_compact t  square_compact := h.square_compact t  adjoint_compact := h.adjoint_compact tdef precomp (h : OddHomotopy A) (φ : B →⋆ₙₐ[ℂ] A) : OddHomotopy B where  space := h.space  representation t := (h.representation t).comp φ  operator := h.operator  continuous_representation b := h.continuous_representation (φ b)  continuous_operator := h.continuous_operator  commutator_compact t b := h.commutator_compact t (φ b)  square_compact t b := h.square_compact t (φ b)  adjoint_compact t b := h.adjoint_compact t (φ b)end OddHomotopyend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticuniverse uvariable (A : Type u) [NonUnitalCStarAlgebra A]inductive CycleRelation : FreeAbelianGroup (OddCycle A) → Prop  | degenerate (c : OddCycle A) (h : c.Degenerate) :      CycleRelation (FreeAbelianGroup.of c)  | unitary (c d : OddCycle A) (h : c.UnitaryEquivalent d) :      CycleRelation (FreeAbelianGroup.of c - FreeAbelianGroup.of d)  | directSum (c d e : OddCycle A) (h : c.IsDirectSum d e) :      CycleRelation (FreeAbelianGroup.of e - (FreeAbelianGroup.of c + FreeAbelianGroup.of d))  | homotopy (h : OddHomotopy A) :      CycleRelation (FreeAbelianGroup.of (h.eval start) - FreeAbelianGroup.of (h.eval finish))def relations : AddSubgroup (FreeAbelianGroup (OddCycle A)) :=  AddSubgroup.closure {z | CycleRelation A z}abbrev OddK := FreeAbelianGroup (OddCycle A) ⧸ relations Adef cycleClass (c : OddCycle A) : OddK A :=  QuotientAddGroup.mk (FreeAbelianGroup.of c)variable {A}variable {B C : Type u} [NonUnitalCStarAlgebra B] [NonUnitalCStarAlgebra C]def precompFree (φ : B →⋆ₙₐ[ℂ] A) : FreeAbelianGroup (OddCycle A) →+ OddK B :=  FreeAbelianGroup.lift (fun c => cycleClass B (c.precomp φ))def precomp (φ : B →⋆ₙₐ[ℂ] A) : OAI.CoarseAssembly.Analytic.OddK A →+ OAI.CoarseAssembly.Analytic.OddK B := by  classical  have OAI.CoarseAssembly.Analytic.degenerate_zero {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (hc : c.Degenerate) : OAI.CoarseAssembly.Analytic.cycleClass A c = 0  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    (      let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {z : FreeAbelianGroup (OAI.CoarseAssembly.Analytic.OddCycle A)} (hz : OAI.CoarseAssembly.Analytic.CycleRelation A z) :          (QuotientAddGroup.mk z : OAI.CoarseAssembly.Analytic.OddK A) = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure hz)      local_proof) (.degenerate c hc)  have OAI.CoarseAssembly.Analytic.unitary_eq {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] (c d : OAI.CoarseAssembly.Analytic.OddCycle A) (h : c.UnitaryEquivalent d) :      OAI.CoarseAssembly.Analytic.cycleClass A c = OAI.CoarseAssembly.Analytic.cycleClass A d  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      have hz := (      let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {z : FreeAbelianGroup (OAI.CoarseAssembly.Analytic.OddCycle A)} (hz : OAI.CoarseAssembly.Analytic.CycleRelation A z) :          (QuotientAddGroup.mk z : OAI.CoarseAssembly.Analytic.OddK A) = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure hz)      local_proof) (.unitary c d h)      exact sub_eq_zero.mp (by simpa only [OAI.CoarseAssembly.Analytic.cycleClass, OAI.CoarseAssembly.Analytic.OddK, QuotientAddGroup.mk_sub] using hz)  have OAI.CoarseAssembly.Analytic.directSum_eq {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] (c d e : OAI.CoarseAssembly.Analytic.OddCycle A) (h : c.IsDirectSum d e) :      OAI.CoarseAssembly.Analytic.cycleClass A e = OAI.CoarseAssembly.Analytic.cycleClass A c + OAI.CoarseAssembly.Analytic.cycleClass A d  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      have hz := (      let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {z : FreeAbelianGroup (OAI.CoarseAssembly.Analytic.OddCycle A)} (hz : OAI.CoarseAssembly.Analytic.CycleRelation A z) :          (QuotientAddGroup.mk z : OAI.CoarseAssembly.Analytic.OddK A) = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure hz)      local_proof) (.directSum c d e h)      exact sub_eq_zero.mp (by simpa only [OAI.CoarseAssembly.Analytic.cycleClass, OAI.CoarseAssembly.Analytic.OddK, QuotientAddGroup.mk_sub, QuotientAddGroup.mk_add] using hz)  have OAI.CoarseAssembly.Analytic.homotopy_eq {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] (h : OAI.CoarseAssembly.Analytic.OddHomotopy A) :      OAI.CoarseAssembly.Analytic.cycleClass A (h.eval OAI.CoarseAssembly.Analytic.start) = OAI.CoarseAssembly.Analytic.cycleClass A (h.eval OAI.CoarseAssembly.Analytic.finish)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      have hz := (      let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {z : FreeAbelianGroup (OAI.CoarseAssembly.Analytic.OddCycle A)} (hz : OAI.CoarseAssembly.Analytic.CycleRelation A z) :          (QuotientAddGroup.mk z : OAI.CoarseAssembly.Analytic.OddK A) = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure hz)      local_proof) (.homotopy h)      exact sub_eq_zero.mp (by simpa only [OAI.CoarseAssembly.Analytic.cycleClass, OAI.CoarseAssembly.Analytic.OddK, QuotientAddGroup.mk_sub] using hz)  have OAI.CoarseAssembly.Analytic.precompFree_relation {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {B : Type _} [inst_local_3 : NonUnitalCStarAlgebra B] (φ : B →⋆ₙₐ[ℂ] A)      {z : FreeAbelianGroup (OAI.CoarseAssembly.Analytic.OddCycle A)} (hz : OAI.CoarseAssembly.Analytic.CycleRelation A z) :      OAI.CoarseAssembly.Analytic.precompFree φ z = 0  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      cases hz with      | degenerate c h =>        simpa [OAI.CoarseAssembly.Analytic.precompFree] using OAI.CoarseAssembly.Analytic.degenerate_zero (c.precomp φ) (((      let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {B : Type _} [inst_local_3 : NonUnitalCStarAlgebra B] {c : OAI.CoarseAssembly.Analytic.OddCycle A} (hc : c.Degenerate)          (φ : B →⋆ₙₐ[ℂ] A) : (c.precomp φ).Degenerate :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic OAI.CoarseAssembly.Analytic.OddCycle in          ⟨fun b => hc.1 (φ b), fun b => hc.2.1 (φ b), fun b => hc.2.2 (φ b)⟩      local_proof) h φ))      | unitary c d h =>        simpa [OAI.CoarseAssembly.Analytic.precompFree] using sub_eq_zero.mpr          (OAI.CoarseAssembly.Analytic.unitary_eq (c.precomp φ) (d.precomp φ) (h.precomp φ))      | directSum c d e h =>        simpa [OAI.CoarseAssembly.Analytic.precompFree] using sub_eq_zero.mpr          (OAI.CoarseAssembly.Analytic.directSum_eq (c.precomp φ) (d.precomp φ) (e.precomp φ) (h.precomp φ))      | homotopy h =>        simpa [OAI.CoarseAssembly.Analytic.precompFree, OAI.CoarseAssembly.Analytic.OddHomotopy.precomp, OAI.CoarseAssembly.Analytic.OddHomotopy.eval, OAI.CoarseAssembly.Analytic.OddCycle.precomp] using sub_eq_zero.mpr (OAI.CoarseAssembly.Analytic.homotopy_eq (h.precomp φ))  exact QuotientAddGroup.lift (OAI.CoarseAssembly.Analytic.relations A) (OAI.CoarseAssembly.Analytic.precompFree φ)      ((AddSubgroup.closure_le _).2 (fun _ hz => OAI.CoarseAssembly.Analytic.precompFree_relation φ hz))end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {H : HilbertSpace}variable {A : Type} [NonUnitalCStarAlgebra A]def OddCycle.compactPerturb (c : OAI.CoarseAssembly.Analytic.OddCycle A) (K : OAI.CoarseAssembly.Analytic.End c.space)    (hK : IsCompactOperator K) (hKs : IsCompactOperator (star K : OAI.CoarseAssembly.Analytic.End c.space)) : OAI.CoarseAssembly.Analytic.OddCycle A := by  classical  exact {    space := c.space    representation := c.representation    operator := c.operator + K    commutator_compact a := by      have he : (c.operator + K) * c.representation a - c.representation a * (c.operator + K) =          (c.operator * c.representation a - c.representation a * c.operator) +            (K * c.representation a - c.representation a * K) := by noncomm_ring      rw [he]      exact (c.commutator_compact a).add        (((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (K * T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.comp_clm T    local_proof) hK _).sub ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (T * K) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.clm_comp T    local_proof) hK _))    square_compact a := by      have he : ((c.operator + K) * (c.operator + K) - 1) * c.representation a =          (c.operator * c.operator - 1) * c.representation a +            (c.operator * K) * c.representation a +            (K * c.operator) * c.representation a + (K * K) * c.representation a := by        noncomm_ring      rw [he]      exact (((c.square_compact a).add        ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (K * T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.comp_clm T    local_proof) ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (T * K) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.clm_comp T    local_proof) hK _) _)).add        ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (K * T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.comp_clm T    local_proof) ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (K * T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.comp_clm T    local_proof) hK _) _)).add        ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (K * T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.comp_clm T    local_proof) ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (K * T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.comp_clm T    local_proof) hK _) _)    adjoint_compact a := by      have he : (star (c.operator + K) - (c.operator + K)) * c.representation a =          (star c.operator - c.operator) * c.representation a +            (star K - K) * c.representation a := by        rw [star_add]        noncomm_ring      rw [he]      exact (c.adjoint_compact a).add ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (K * T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.comp_clm T    local_proof) (hKs.sub hK) _)  }end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type} [NonUnitalCStarAlgebra A]def OddCycle.localCompactPerturb (c : OAI.CoarseAssembly.Analytic.OddCycle A) (K : OAI.CoarseAssembly.Analytic.End c.space)    (hr : ∀ a, IsCompactOperator (K * c.representation a : OAI.CoarseAssembly.Analytic.End c.space))    (hl : ∀ a, IsCompactOperator (c.representation a * K : OAI.CoarseAssembly.Analytic.End c.space))    (hs : ∀ a, IsCompactOperator (star K * c.representation a : OAI.CoarseAssembly.Analytic.End c.space)) : OAI.CoarseAssembly.Analytic.OddCycle A := by  classical  exact {    space := c.space    representation := c.representation    operator := c.operator + K    commutator_compact a := by      have he : (c.operator + K) * c.representation a - c.representation a * (c.operator + K) =          (c.operator * c.representation a - c.representation a * c.operator) +          (K * c.representation a - c.representation a * K) := by noncomm_ring      rw [he]      exact (c.commutator_compact a).add ((hr a).sub (hl a))    square_compact a := by      have he : ((c.operator + K) * (c.operator + K) - 1) * c.representation a =          (c.operator * c.operator - 1) * c.representation a +            c.operator * (K * c.representation a) +            K * (c.operator * c.representation a - c.representation a * c.operator) +            (K * c.representation a) * c.operator + K * (K * c.representation a) := by        noncomm_ring      rw [he]      exact ((((c.square_compact a).add ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (T * K) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.clm_comp T    local_proof) (hr a) _)).add        ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (T * K) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.clm_comp T    local_proof) (c.commutator_compact a) _)).add        ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (K * T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.comp_clm T    local_proof) (hr a) _)).add ((    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (T * K) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.clm_comp T    local_proof) (hr a) _)    adjoint_compact a := by      have he : (star (c.operator + K) - (c.operator + K)) * c.representation a =          (star c.operator - c.operator) * c.representation a +            (star K * c.representation a - K * c.representation a) := by        rw [star_add]        noncomm_ring      rw [he]      exact (c.adjoint_compact a).add ((hs a).sub (hr a))  }end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {H : HilbertSpace}def symmetricCutDown (P F : End H) : End H :=  (1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P)end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type} [CStarAlgebra A]def OddCycle.scalarRestriction (c : OddCycle A) : OddCycle ℂ :=  c.precomp (StarAlgHom.ofId ℂ A).toNonUnitalStarAlgHomend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type} [CStarAlgebra A]def representedCorrection (c : OddCycle A) : End c.space :=  symmetricCutDown (c.representation 1) c.operator - c.operatordef OddCycle.cutDown (c : OAI.CoarseAssembly.Analytic.OddCycle A) : OAI.CoarseAssembly.Analytic.OddCycle A := by  classical  have OAI.CoarseAssembly.Analytic.scalarCutDown_compact (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ) :      let P := c.representation 1      let K := OAI.CoarseAssembly.Analytic.symmetricCutDown P c.operator - c.operator      IsCompactOperator (K * P : OAI.CoarseAssembly.Analytic.End c.space) ∧        IsCompactOperator (P * K : OAI.CoarseAssembly.Analytic.End c.space) ∧        IsCompactOperator (star K * P : OAI.CoarseAssembly.Analytic.End c.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      let P := c.representation 1      let K := OAI.CoarseAssembly.Analytic.symmetricCutDown P c.operator - c.operator      have hp : IsSelfAdjoint P := (      let local_proof (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ) : IsSelfAdjoint (c.representation 1) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star (c.representation 1) = c.representation 1            rw [← map_star, star_one]      local_proof) c      have hpp : P * P = P := (      let local_proof (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ) : c.representation 1 * c.representation 1 =          c.representation 1 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by rw [← map_mul, one_mul]      local_proof) c      have hd := c.adjoint_compact 1      have hc := c.commutator_compact 1      have hr : IsCompactOperator (K * P : OAI.CoarseAssembly.Analytic.End c.space) := by        dsimp only [K]        rw [(      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P)          (hPP : P * P = P) :          (OAI.CoarseAssembly.Analytic.symmetricCutDown P F - F) * P = -(F * P - P * F) * P +          (1 / 2 : ℝ) • (P * ((star F - F) * P)) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            simp only [OAI.CoarseAssembly.Analytic.symmetricCutDown, sub_mul, add_mul, smul_mul_assoc,              star_mul, hP.star_eq, mul_sub, mul_assoc, hPP, one_mul, neg_mul]            module      local_proof) P c.operator hp hpp]        exact ((      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :          IsCompactOperator (K * T) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          hK.comp_clm T      local_proof) hc.neg P).add (((      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :          IsCompactOperator (T * K) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          hK.clm_comp T      local_proof) hd P).smul (1 / 2 : ℝ))      have hl : IsCompactOperator (P * K : OAI.CoarseAssembly.Analytic.End c.space) := by        dsimp only [K]        rw [(      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P)          (hPP : P * P = P) :          P * (OAI.CoarseAssembly.Analytic.symmetricCutDown P F - F) = P * (F * P - P * F) +          (1 / 2 : ℝ) • (P * ((star F - F) * P)) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            simp only [OAI.CoarseAssembly.Analytic.symmetricCutDown, mul_sub, mul_add, mul_smul_comm,              star_mul, hP.star_eq, sub_mul, ← mul_assoc, hPP, mul_one]            module      local_proof) P c.operator hp hpp]        exact ((      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :          IsCompactOperator (T * K) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          hK.clm_comp T      local_proof) hc P).add (((      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :          IsCompactOperator (T * K) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          hK.clm_comp T      local_proof) hd P).smul (1 / 2 : ℝ))      refine ⟨hr, hl, ?_⟩      have he : star K * P = K * P - (star c.operator - c.operator) * P := by        dsimp only [K]        rw [star_sub, ((      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) :          IsSelfAdjoint (OAI.CoarseAssembly.Analytic.symmetricCutDown P F) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star ((1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P)) = _            rw [star_add, star_smul, star_trivial, star_add, star_star, star_sub, star_one, hP.star_eq]            rw [add_comm (star (P * F * P))]            rfl      local_proof) P c.operator hp).star_eq]        noncomm_ring      rw [he]      exact hr.sub hd  have OAI.CoarseAssembly.Analytic.representedCutDown_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :      let P := c.representation 1      let K := OAI.CoarseAssembly.Analytic.symmetricCutDown P c.operator - c.operator      IsCompactOperator (K * P : OAI.CoarseAssembly.Analytic.End c.space) ∧        IsCompactOperator (P * K : OAI.CoarseAssembly.Analytic.End c.space) ∧        IsCompactOperator (star K * P : OAI.CoarseAssembly.Analytic.End c.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      have h := OAI.CoarseAssembly.Analytic.scalarCutDown_compact c.scalarRestriction      change let P : OAI.CoarseAssembly.Analytic.End c.space := c.representation (algebraMap ℂ A 1)             let K : OAI.CoarseAssembly.Analytic.End c.space := OAI.CoarseAssembly.Analytic.symmetricCutDown P c.operator - c.operator             IsCompactOperator (K * P : OAI.CoarseAssembly.Analytic.End c.space) ∧               IsCompactOperator (P * K : OAI.CoarseAssembly.Analytic.End c.space) ∧               IsCompactOperator (star K * P : OAI.CoarseAssembly.Analytic.End c.space) at h      simpa only [map_one] using h  have OAI.CoarseAssembly.Analytic.representedCorrection_right {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : A) :      IsCompactOperator (OAI.CoarseAssembly.Analytic.representedCorrection c * c.representation a : OAI.CoarseAssembly.Analytic.End c.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      have hp : c.representation 1 * c.representation a = c.representation a := by        rw [← map_mul, one_mul]      rw [← hp, ← mul_assoc]      exact (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :          IsCompactOperator (K * T) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          hK.comp_clm T      local_proof) (OAI.CoarseAssembly.Analytic.representedCutDown_compact c).1 _  have OAI.CoarseAssembly.Analytic.representedCorrection_left {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : A) :      IsCompactOperator (c.representation a * OAI.CoarseAssembly.Analytic.representedCorrection c : OAI.CoarseAssembly.Analytic.End c.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      have hp : c.representation a * c.representation 1 = c.representation a := by        rw [← map_mul, mul_one]      rw [← hp, mul_assoc]      exact (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :          IsCompactOperator (T * K) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          hK.clm_comp T      local_proof) (OAI.CoarseAssembly.Analytic.representedCutDown_compact c).2.1 _  have OAI.CoarseAssembly.Analytic.representedCorrection_star {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : A) :      IsCompactOperator (star (OAI.CoarseAssembly.Analytic.representedCorrection c) * c.representation a : OAI.CoarseAssembly.Analytic.End c.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      have hp : c.representation 1 * c.representation a = c.representation a := by        rw [← map_mul, one_mul]      rw [← hp, ← mul_assoc]      exact (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :          IsCompactOperator (K * T) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          hK.comp_clm T      local_proof) (OAI.CoarseAssembly.Analytic.representedCutDown_compact c).2.2 _  exact c.localCompactPerturb (OAI.CoarseAssembly.Analytic.representedCorrection c) (OAI.CoarseAssembly.Analytic.representedCorrection_right c)      (OAI.CoarseAssembly.Analytic.representedCorrection_left c) (OAI.CoarseAssembly.Analytic.representedCorrection_star c)end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type} [CStarAlgebra A] {H : HilbertSpace}def completedRepresentation (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) :    A →⋆ₙₐ[ℂ] OAI.CoarseAssembly.Analytic.End c.space := by  classical  have OAI.CoarseAssembly.Analytic.representation_unit_projection {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :      IsStarProjection (c.representation 1)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    ⟨(      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          c.representation 1 * c.representation 1 = c.representation 1 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            rw [← map_mul, one_mul]      local_proof) c, (      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          IsSelfAdjoint (c.representation 1) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star (c.representation 1) = c.representation 1            rw [← map_star, star_one]      local_proof) c⟩  exact {    toFun a := c.representation a + χ a • (1 - c.representation 1)    map_zero' := by simp    map_add' a b := by simp only [map_add, add_smul]; abel    map_smul' z a := by simp [smul_add, smul_smul]    map_star' a := by      simp only [map_star, star_add, star_smul, star_sub, star_one,        ((    let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :        IsSelfAdjoint (c.representation 1) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        by          change star (c.representation 1) = c.representation 1          rw [← map_star, star_one]    local_proof) c).star_eq]    map_mul' a b := by      have hQ := (OAI.CoarseAssembly.Analytic.representation_unit_projection c).one_sub.isIdempotentElem      rw [map_mul, add_mul, mul_add, mul_add, mul_smul_comm,        (    let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : A) :        c.representation a * (1 - c.representation 1) = 0 :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        by          rw [mul_sub, mul_one, ← map_mul, mul_one, sub_self]    local_proof), smul_zero, smul_mul_assoc,        (    let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : A) :        (1 - c.representation 1) * c.representation a = 0 :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        by          rw [sub_mul, one_mul, ← map_mul, one_mul, sub_self]    local_proof), smul_zero, smul_mul_assoc, mul_smul_comm,        hQ, smul_smul]      simp only [map_mul, add_zero, zero_add]  }def OddCycle.characterExtension (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ)    (hF : IsSelfAdjoint c.operator)    (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1)    (hsq : IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space)) : OAI.CoarseAssembly.Analytic.OddCycle A := by  classical  exact {    space := c.space    representation := OAI.CoarseAssembly.Analytic.completedRepresentation c χ    operator := c.operator    commutator_compact a := by      have hQ' : (1 - c.representation 1) * c.operator = 1 - c.representation 1 := by        have h := congrArg star hQ        simpa only [star_mul, star_sub, star_one, hF.star_eq,          ((    let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :        IsSelfAdjoint (c.representation 1) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        by          change star (c.representation 1) = c.representation 1          rw [← map_star, star_one]    local_proof) c).star_eq] using h      change IsCompactOperator        (c.operator * (c.representation a + χ a • (1 - c.representation 1)) -          (c.representation a + χ a • (1 - c.representation 1)) * c.operator : OAI.CoarseAssembly.Analytic.End c.space)      simpa only [mul_add, add_mul, mul_smul_comm, smul_mul_assoc, hQ, hQ',        add_sub_add_right_eq_sub] using c.commutator_compact a    square_compact a := (    let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :        IsCompactOperator (K * T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        hK.comp_clm T    local_proof) hsq _    adjoint_compact a := by      rw [hF.star_eq, sub_self, zero_mul]      exact isCompactOperator_zero  }end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticopen scoped ZeroAtInftyuniverse uvariable {X Y Z : Type u} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z]abbrev LocallyFiniteK1 (X : Type u) [TopologicalSpace X] := OddK C₀(X, ℂ)def pullback (f : CocompactMap X Y) : C₀(Y, ℂ) →⋆ₙₐ[ℂ] C₀(X, ℂ) where  toNonUnitalAlgHom := ZeroAtInftyContinuousMap.compNonUnitalAlgHom f  map_star' a := by ext x; rfldef pushforward (f : CocompactMap X Y) : LocallyFiniteK1 X →+ LocallyFiniteK1 Y :=  precomp (pullback f)structure Coarsening where  space : ℕ → Type u  topology : ∀ n, TopologicalSpace (space n)  inclusion : ∀ r s, r ≤ s → @CocompactMap (space r) (space s) (topology r) (topology s)  inclusion_self : ∀ r h, inclusion r r h = @CocompactMap.id (space r) (topology r)  inclusion_comp : ∀ r s t hrs hst,    inclusion r t (hrs.trans hst) = (inclusion s t hst).comp (inclusion r s hrs)attribute [instance] Coarsening.topologynamespace Coarseningdef map (C : Coarsening) (r s : ℕ) (h : r ≤ s) :    LocallyFiniteK1 (C.space r) →+ LocallyFiniteK1 (C.space s) :=  pushforward (C.inclusion r s h)abbrev Homology (C : Coarsening) :=  AddCommGroup.DirectLimit (fun r => LocallyFiniteK1 (C.space r)) (fun r s h => C.map r s h)end Coarseningend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen Topologyvariable (X : Type*) [PseudoMetricSpace X]@[ext] structure Point (r : ℝ) where  weight : X →₀ ℝ  nonneg : ∀ x, 0 ≤ weight x  total : weight.sum (fun _ t => t) = 1  diameter : ∀ x ∈ weight.support, ∀ y ∈ weight.support, dist x y ≤ rvariable {X}def coordinates {r : ℝ} (p : Point X r) : X → ℝ := p.weightinstance (r : ℝ) : TopologicalSpace (Point X r) :=  TopologicalSpace.induced coordinates inferInstanceinstance (r : ℝ) : T2Space (OAI.CoarseAssembly.Rips.Point X r) := by  classical  exact (IsEmbedding.mk ⟨rfl⟩ (    let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Function.Injective (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in        open Topology in        by          intro p q h          apply OAI.CoarseAssembly.Rips.Point.ext          exact Finsupp.ext (congrFun h)    local_proof)).t2Spacedef coarsen {r s : ℝ} (h : r ≤ s) (p : Point X r) : Point X s where  weight := p.weight  nonneg := p.nonneg  total := p.total  diameter x hx y hy := (p.diameter x hx y hy).trans hdef inclusion {r s : ℝ} (h : r ≤ s) : CocompactMap (OAI.CoarseAssembly.Rips.Point X r) (OAI.CoarseAssembly.Rips.Point X s) := by  classical  have OAI.CoarseAssembly.Rips.coordinate_continuous {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} (x : X) :      Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => p.weight x)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    (continuous_apply x).comp (      let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Continuous (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          continuous_induced_dom      local_proof)  have OAI.CoarseAssembly.Rips.coarsen_closedEmbedding {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r s : ℝ} (h : r ≤ s) :      Topology.IsClosedEmbedding (OAI.CoarseAssembly.Rips.coarsen (X := X) h)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    by      refine ⟨(      let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r s : ℝ} (h : r ≤ s) : IsEmbedding (OAI.CoarseAssembly.Rips.coarsen (X := X) h) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          by            exact {              eq_induced := by                change TopologicalSpace.induced OAI.CoarseAssembly.Rips.coordinates _ =                  TopologicalSpace.induced (OAI.CoarseAssembly.Rips.coarsen h) (TopologicalSpace.induced OAI.CoarseAssembly.Rips.coordinates _)                rw [induced_compose]                rfl              injective := by                intro p q heq                apply OAI.CoarseAssembly.Rips.Point.ext                exact congrArg (fun p : OAI.CoarseAssembly.Rips.Point X s => p.weight) heq            }      local_proof) h, ?_⟩      rw [(      let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r s : ℝ} (h : r ≤ s) :          Set.range (OAI.CoarseAssembly.Rips.coarsen (X := X) h) =          {p : OAI.CoarseAssembly.Rips.Point X s | ∀ x y, r < dist x y → p.weight x = 0 ∨ p.weight y = 0} :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          by            ext p            constructor            · rintro ⟨q, rfl⟩ x y hxy              by_cases hx : q.weight x = 0              · exact Or.inl hx              by_cases hy : q.weight y = 0              · exact Or.inr hy              exact False.elim ((not_le_of_gt hxy)                (q.diameter x (Finsupp.mem_support_iff.mpr hx) y (Finsupp.mem_support_iff.mpr hy)))            · intro hp              let q : OAI.CoarseAssembly.Rips.Point X r :=                { weight := p.weight                  nonneg := p.nonneg                  total := p.total                  diameter := by                    intro x hx y hy                    by_contra hxy                    rcases hp x y (lt_of_not_ge hxy) with hx' | hy'                    · exact Finsupp.mem_support_iff.mp hx hx'                    · exact Finsupp.mem_support_iff.mp hy hy' }              exact ⟨q, by apply OAI.CoarseAssembly.Rips.Point.ext; rfl⟩      local_proof) h]      simp only [Set.ofPred_forall]      refine isClosed_iInter (fun x => isClosed_iInter (fun y => isClosed_iInter (fun _ => ?_)))      exact (isClosed_eq (OAI.CoarseAssembly.Rips.coordinate_continuous x) continuous_const).union        (isClosed_eq (OAI.CoarseAssembly.Rips.coordinate_continuous y) continuous_const)  exact {    toFun := OAI.CoarseAssembly.Rips.coarsen h    continuous_toFun := (OAI.CoarseAssembly.Rips.coarsen_closedEmbedding h).continuous    cocompact_tendsto' := (OAI.CoarseAssembly.Rips.coarsen_closedEmbedding h).tendsto_cocompact  }def coarsening (X : Type*) [PseudoMetricSpace X] : OAI.CoarseAssembly.Analytic.Coarsening := by  classical  exact {    space n := OAI.CoarseAssembly.Rips.Point X (n : ℝ)    topology _ := inferInstance    inclusion _ _ h := OAI.CoarseAssembly.Rips.inclusion (by exact_mod_cast h)    inclusion_self r _ := (    let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] (r : ℝ) (h : r ≤ r) :        OAI.CoarseAssembly.Rips.inclusion (X := X) h = CocompactMap.id (OAI.CoarseAssembly.Rips.Point X r) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in        open Topology in        by          apply CocompactMap.ext          intro p          apply OAI.CoarseAssembly.Rips.Point.ext          rfl    local_proof) r _    inclusion_comp _ _ _ _ _ := (    let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r s t : ℝ} (hrs : r ≤ s) (hst : s ≤ t) :        OAI.CoarseAssembly.Rips.inclusion (X := X) (hrs.trans hst) = (OAI.CoarseAssembly.Rips.inclusion hst).comp (OAI.CoarseAssembly.Rips.inclusion hrs) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in        open Topology in        by          apply CocompactMap.ext          intro p          apply OAI.CoarseAssembly.Rips.Point.ext          rfl    local_proof) _ _  }abbrev KX1 (X : Type*) [PseudoMetricSpace X] := (coarsening X).Homologyend CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen scoped BigOperatorsopen unitIntervalvariable {X : Type*} [PseudoMetricSpace X] {r : ℝ}def vertex (x : X) (hr : 0 ≤ r) : Point X r where  weight := Finsupp.single x 1  nonneg y := by    classical    simp only [Finsupp.single_apply]    split_ifs <;> norm_num  total := by simp  diameter y hy z hz := by    have hy' : y = x := by simpa using hy    have hz' : z = x := by simpa using hz    simpa [hy', hz'] using hrend CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen scoped BigOperatorsopen Topologyvariable {X : Type*} [PseudoMetricSpace X] [Fintype X] (r : ℝ)instance : CompactSpace (OAI.CoarseAssembly.Rips.Point X r) := by  classical  have OAI.CoarseAssembly.Rips.range_coordinates {X : Type _} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) :      Set.range (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) =        {f : X → ℝ | (∀ x, 0 ≤ f x) ∧ (∑ x, f x) = 1 ∧          ∀ x y, r < dist x y → f x = 0 ∨ f y = 0}  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open scoped BigOperators in    open Topology in    by      classical      ext f      constructor      · rintro ⟨p, rfl⟩        refine ⟨p.nonneg, ((      let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} [inst_local_3 : Fintype X] (p : OAI.CoarseAssembly.Rips.Point X r) : ∑ x : X, p.weight x = 1 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open scoped BigOperators in          open Topology in          by            rw [← p.total]            exact (p.weight.sum_fintype (fun _ t => t) (by simp)).symm      local_proof) p), ?_⟩        intro x y hxy        by_cases hx : p.weight x = 0        · exact Or.inl hx        by_cases hy : p.weight y = 0        · exact Or.inr hy        exact False.elim ((not_le_of_gt hxy)          (p.diameter x (Finsupp.mem_support_iff.mpr hx) y (Finsupp.mem_support_iff.mpr hy)))      · rintro ⟨hnn, ht, hd⟩        let p : OAI.CoarseAssembly.Rips.Point X r :=          { weight := Finsupp.equivFunOnFinite.symm f            nonneg := hnn            total := by              rw [Finsupp.sum_fintype _ _ (by simp)]              exact ht            diameter := by              intro x hx y hy              by_contra h              rcases hd x y (lt_of_not_ge h) with hx' | hy'              · exact Finsupp.mem_support_iff.mp hx hx'              · exact Finsupp.mem_support_iff.mp hy hy' }        exact ⟨p, rfl⟩  have OAI.CoarseAssembly.Rips.coordinates_closed {X : Type _} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) : IsClosed (Set.range (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)))  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open scoped BigOperators in    open Topology in    by      rw [OAI.CoarseAssembly.Rips.range_coordinates]      have hnn : IsClosed {f : X → ℝ | ∀ x, 0 ≤ f x} := by        simp only [Set.ofPred_forall]        exact isClosed_iInter fun x => isClosed_le continuous_const (continuous_apply x)      have ht : IsClosed {f : X → ℝ | (∑ x, f x) = 1} :=        isClosed_eq (continuous_finsetSum _ (fun x _ => continuous_apply x)) continuous_const      have hd : IsClosed {f : X → ℝ | ∀ x y, r < dist x y → f x = 0 ∨ f y = 0} := by        simp only [Set.ofPred_forall]        exact isClosed_iInter fun x => isClosed_iInter fun y => isClosed_iInter fun _ =>          (isClosed_eq (continuous_apply x) continuous_const).union            (isClosed_eq (continuous_apply y) continuous_const)      exact hnn.inter (ht.inter hd)  have OAI.CoarseAssembly.Rips.coordinates_compact {X : Type _} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) : IsCompact (Set.range (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)))  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open scoped BigOperators in    open Topology in    by      apply IsCompact.of_isClosed_subset (isCompact_Icc (a := (0 : X → ℝ)) (b := 1))        (OAI.CoarseAssembly.Rips.coordinates_closed r)      rintro f ⟨p, rfl⟩      refine ⟨p.nonneg, ?_⟩      intro x      calc        p.weight x ≤ ∑ y : X, p.weight y := Finset.single_le_sum (fun y _ => p.nonneg y)          (Finset.mem_univ x)        _ = 1 := ((      let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} [inst_local_3 : Fintype X] (p : OAI.CoarseAssembly.Rips.Point X r) : ∑ x : X, p.weight x = 1 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open scoped BigOperators in          open Topology in          by            rw [← p.total]            exact (p.weight.sum_fintype (fun _ t => t) (by simp)).symm      local_proof) p)  apply isCompact_univ_iff.mp  have he : IsEmbedding (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) :=    ⟨⟨rfl⟩, (  let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Function.Injective (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in      open Topology in      by        intro p q h        apply OAI.CoarseAssembly.Rips.Point.ext        exact Finsupp.ext (congrFun h)  local_proof)⟩  apply he.isCompact_iff.mpr  simpa only [Set.image_univ] using OAI.CoarseAssembly.Rips.coordinates_compact (X := X) rend CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticopen Topologyopen scoped ZeroAtInftyvariable {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y]  [CompactSpace X] [T2Space Y]def zeroExtension (e : X ↪ Y) (he : IsOpenEmbedding e) (f : C₀(X, ℂ)) : C₀(Y, ℂ) := by  classical  exact {    toFun := Function.extend e f 0    continuous_toFun := (    let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e)        (f : C₀(X, ℂ)) : Continuous (Function.extend e f 0) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        open Topology in        open scoped ZeroAtInfty in        by          have hs := HasCompactSupport.of_compactSpace (f : X → ℂ)          apply continuous_of_tsupport          intro y hy          obtain ⟨x, _, rfl⟩ := hs.tsupport_extend_zero_subset he.continuous hy          rw [← he.continuousAt_iff, Function.extend_comp e.injective]          exact f.continuous.continuousAt    local_proof) e he f    zero_at_infty' := ((HasCompactSupport.of_compactSpace (f : X → ℂ)).extend_zero      he.continuous).is_zero_at_infty  }def zeroExtensionHom (e : X ↪ Y) (he : IsOpenEmbedding e) :    C₀(X, ℂ) →⋆ₙₐ[ℂ] C₀(Y, ℂ) := by  classical  have extension_eval (f : C₀(X, ℂ)) (x : X) :      OAI.CoarseAssembly.Analytic.zeroExtension e he f (e x) = f x :=    e.injective.extend_apply _ _ x  exact {    toFun := OAI.CoarseAssembly.Analytic.zeroExtension e he    map_zero' := by      ext y      by_cases hy : y ∈ Set.range e      · obtain ⟨x, rfl⟩ := hy        simp [extension_eval]      · simp [(    let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e)        (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : OAI.CoarseAssembly.Analytic.zeroExtension e he f y = 0 :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        open Topology in        open scoped ZeroAtInfty in        Function.extend_apply' _ _ _ hy    local_proof) e he _ hy]    map_add' f g := by      ext y      by_cases hy : y ∈ Set.range e      · obtain ⟨x, rfl⟩ := hy        simp [extension_eval]      · simp [(    let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e)        (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : OAI.CoarseAssembly.Analytic.zeroExtension e he f y = 0 :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        open Topology in        open scoped ZeroAtInfty in        Function.extend_apply' _ _ _ hy    local_proof) e he _ hy]    map_mul' f g := by      ext y      by_cases hy : y ∈ Set.range e      · obtain ⟨x, rfl⟩ := hy        simp [extension_eval]      · simp [(    let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e)        (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : OAI.CoarseAssembly.Analytic.zeroExtension e he f y = 0 :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        open Topology in        open scoped ZeroAtInfty in        Function.extend_apply' _ _ _ hy    local_proof) e he _ hy]    map_smul' c f := by      ext y      by_cases hy : y ∈ Set.range e      · obtain ⟨x, rfl⟩ := hy        simp [extension_eval]      · simp [(    let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e)        (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : OAI.CoarseAssembly.Analytic.zeroExtension e he f y = 0 :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        open Topology in        open scoped ZeroAtInfty in        Function.extend_apply' _ _ _ hy    local_proof) e he _ hy]    map_star' f := by      ext y      by_cases hy : y ∈ Set.range e      · obtain ⟨x, rfl⟩ := hy        simp [extension_eval]      · simp [(    let local_proof {X : Type} {Y : Type} [inst_local_2 : TopologicalSpace X] [inst_local_3 : TopologicalSpace Y] [inst_local_4 : CompactSpace X] [inst_local_5 : T2Space Y] (e : X ↪ Y) (he : Topology.IsOpenEmbedding e)        (f : C₀(X, ℂ)) {y : Y} (hy : y ∉ Set.range e) : OAI.CoarseAssembly.Analytic.zeroExtension e he f y = 0 :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        open Topology in        open scoped ZeroAtInfty in        Function.extend_apply' _ _ _ hy    local_proof) e he _ hy]  }end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type*} [CStarAlgebra A]def cayleyDenominator (F : A) (hF : IsSelfAdjoint F) : Aˣ := by  classical  exact ((    let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :        IsUnit (F + algebraMap ℂ A Complex.I) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        by          have hn : -Complex.I ∉ spectrum ℂ F := by            intro h            have hi := hF.im_eq_zero_of_mem_spectrum h            simp at hi          have hu : IsUnit (algebraMap ℂ A (-Complex.I) - F) :=            not_not.mp (fun h => hn (spectrum.mem_iff.mpr h))          convert hu.neg using 1          simp only [map_neg, neg_sub, sub_neg_eq_add]    local_proof) F hF).unitdef cayleyUnitary (F : A) (hF : IsSelfAdjoint F) : unitary A := by  classical  have OAI.CoarseAssembly.Analytic.cayleyDenominator_val {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F + algebraMap ℂ A Complex.I  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    ((      let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :          IsUnit (F + algebraMap ℂ A Complex.I) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            have hn : -Complex.I ∉ spectrum ℂ F := by              intro h              have hi := hF.im_eq_zero_of_mem_spectrum h              simp at hi            have hu : IsUnit (algebraMap ℂ A (-Complex.I) - F) :=              not_not.mp (fun h => hn (spectrum.mem_iff.mpr h))            convert hu.neg using 1            simp only [map_neg, neg_sub, sub_neg_eq_add]      local_proof) F hF).unit_spec  have OAI.CoarseAssembly.Analytic.cayleyDenominator_star {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F - algebraMap ℂ A Complex.I  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_val, star_add, hF.star_eq]      simp only [← algebraMap_star_comm, Complex.star_def, Complex.conj_I, map_neg,        sub_eq_add_neg]  have OAI.CoarseAssembly.Analytic.cayleyDenominator_normal {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      Commute (star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val]      have hc : Commute (algebraMap ℂ A Complex.I) F := Algebra.commutes _ _      exact ((Commute.refl F).sub_left hc).add_right        (hc.symm.sub_left (Commute.refl _))  let b := OAI.CoarseAssembly.Analytic.cayleyDenominator F hF  refine ⟨(star b * b⁻¹ : Aˣ), (Units.mul_inv_mem_unitary (star b) b).mpr ?_⟩  apply Units.ext  change star (star (b : A)) * star (b : A) = star (b : A) * (b : A)  rw [star_star]  exact (OAI.CoarseAssembly.Analytic.cayleyDenominator_normal F hF).eq.symmdef rationalBoundaryUnitary (F : A) (hF : IsSelfAdjoint F) : unitary A :=  -(cayleyUnitary F hF * cayleyUnitary F hF)end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type*} [CStarAlgebra A]def boundedTransform (F : A) (hF : IsSelfAdjoint F) : A :=  (Complex.I / 2 : ℂ) • ((cayleyUnitary F hF : A) - star (cayleyUnitary F hF : A))sectionattribute [local instance 2000] instIsDomain instIsTorsionFreeOfIsDomainOfNoZeroSMulDivisorsendvariable {H : HilbertSpace}end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type} [CStarAlgebra A]def OddCycle.bounded (c : OAI.CoarseAssembly.Analytic.OddCycle A)    (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) : OAI.CoarseAssembly.Analytic.OddCycle A := by  classical  have OAI.CoarseAssembly.Analytic.cayleyDenominator_val {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F + algebraMap ℂ A Complex.I  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    ((      let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :          IsUnit (F + algebraMap ℂ A Complex.I) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            have hn : -Complex.I ∉ spectrum ℂ F := by              intro h              have hi := hF.im_eq_zero_of_mem_spectrum h              simp at hi            have hu : IsUnit (algebraMap ℂ A (-Complex.I) - F) :=              not_not.mp (fun h => hn (spectrum.mem_iff.mpr h))            convert hu.neg using 1            simp only [map_neg, neg_sub, sub_neg_eq_add]      local_proof) F hF).unit_spec  have OAI.CoarseAssembly.Analytic.cayleyDenominator_star {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F - algebraMap ℂ A Complex.I  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_val, star_add, hF.star_eq]      simp only [← algebraMap_star_comm, Complex.star_def, Complex.conj_I, map_neg,        sub_eq_add_neg]  have OAI.CoarseAssembly.Analytic.cayleyDenominator_normSquare {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F * F + 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val]      have hi : algebraMap ℂ A Complex.I * algebraMap ℂ A Complex.I = -1 := by        rw [← map_mul, Complex.I_mul_I, map_neg, map_one]      have hc := Algebra.commutes (R := ℂ) (A := A) Complex.I F      noncomm_ring [hc, hi]  have OAI.CoarseAssembly.Analytic.cayleyUnitary_mul_normSquare {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) *        ((OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) =        star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [(      let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :          (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) =          star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * (↑(OAI.CoarseAssembly.Analytic.cayleyDenominator F hF)⁻¹ : A) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          rfl      local_proof)]      calc        _ = star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) *            (((↑(OAI.CoarseAssembly.Analytic.cayleyDenominator F hF)⁻¹ : A) * (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) *              star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) := by noncomm_ring        _ = _ := by rw [Units.inv_mul, one_mul]  have OAI.CoarseAssembly.Analytic.cayleyDenominator_normal {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      Commute (star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val]      have hc : Commute (algebraMap ℂ A Complex.I) F := Algebra.commutes _ _      exact ((Commute.refl F).sub_left hc).add_right        (hc.symm.sub_left (Commute.refl _))  have OAI.CoarseAssembly.Analytic.star_cayleyUnitary_mul_normSquare {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      star (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) *        ((OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) =        (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      let b := OAI.CoarseAssembly.Analytic.cayleyDenominator F hF      have hc : Commute (b : A) (star (b : A)) := (OAI.CoarseAssembly.Analytic.cayleyDenominator_normal F hF).symm      rw [(      let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :          (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) =          star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * (↑(OAI.CoarseAssembly.Analytic.cayleyDenominator F hF)⁻¹ : A) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          rfl      local_proof), star_mul, star_star, ← Units.coe_star_inv]      change ((↑(star b)⁻¹ : A) * (b : A)) * ((b : A) * star (b : A)) = (b : A) * (b : A)      calc        _ = (↑(star b)⁻¹ : A) * ((b : A) * ((b : A) * star (b : A))) := by noncomm_ring        _ = (↑(star b)⁻¹ : A) * ((b : A) * (star (b : A) * (b : A))) := by rw [hc.eq]        _ = (↑(star b)⁻¹ : A) * (((b : A) * star (b : A)) * (b : A)) := by noncomm_ring        _ = (↑(star b)⁻¹ : A) * ((star (b : A) * (b : A)) * (b : A)) := by rw [hc.eq]        _ = ((↑(star b)⁻¹ : A) * star (b : A)) * ((b : A) * (b : A)) := by noncomm_ring        _ = _ := by rw [← Units.coe_star, Units.inv_mul, one_mul]  have OAI.CoarseAssembly.Analytic.boundedTransform_mul_normSquare {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      OAI.CoarseAssembly.Analytic.boundedTransform F hF *        ((OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) = (2 : ℂ) • F  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      unfold OAI.CoarseAssembly.Analytic.boundedTransform      rw [smul_mul_assoc, sub_mul, OAI.CoarseAssembly.Analytic.cayleyUnitary_mul_normSquare, OAI.CoarseAssembly.Analytic.star_cayleyUnitary_mul_normSquare]      have hp : star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) -          (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) =          (-4 * Complex.I : ℂ) • F := by        rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val, Algebra.smul_def]        simp only [map_mul, map_neg, map_ofNat]        have hc := Algebra.commutes (R := ℂ) (A := A) Complex.I F        noncomm_ring [hc]      rw [hp, smul_smul]      have hs : (Complex.I / 2) * (-4 * Complex.I) = (2 : ℂ) := by        calc          _ = -2 * (Complex.I * Complex.I) := by ring          _ = 2 := by rw [Complex.I_mul_I]; norm_num      rw [hs]  have OAI.CoarseAssembly.Analytic.boundedTransform_sub_compact {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (F : OAI.CoarseAssembly.Analytic.End H) (hF : IsSelfAdjoint F)      (hK : IsCompactOperator (F * F - 1 : OAI.CoarseAssembly.Analytic.End H)) :      IsCompactOperator (OAI.CoarseAssembly.Analytic.boundedTransform F hF - F : OAI.CoarseAssembly.Analytic.End H)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      let b := OAI.CoarseAssembly.Analytic.cayleyDenominator F hF      have hm : IsCompactOperator ((OAI.CoarseAssembly.Analytic.boundedTransform F hF - F) * ((b : OAI.CoarseAssembly.Analytic.End H) * star (b : OAI.CoarseAssembly.Analytic.End H))) := by        rw [sub_mul, OAI.CoarseAssembly.Analytic.boundedTransform_mul_normSquare, OAI.CoarseAssembly.Analytic.cayleyDenominator_normSquare]        have he : (2 : ℂ) • F - F * (F * F + 1) = -(F * (F * F - 1)) := by          rw [Algebra.smul_def]          simp only [map_ofNat]          noncomm_ring        rw [he]        exact ((      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :          IsCompactOperator (T * K) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          hK.clm_comp T      local_proof) hK F).neg      let v : (OAI.CoarseAssembly.Analytic.End H)ˣ := b * star b      change IsCompactOperator ((OAI.CoarseAssembly.Analytic.boundedTransform F hF - F) * (v : OAI.CoarseAssembly.Analytic.End H)) at hm      have hn := (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :          IsCompactOperator (K * T) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          hK.comp_clm T      local_proof) hm (↑v⁻¹ : OAI.CoarseAssembly.Analytic.End H)      rwa [mul_assoc, Units.mul_inv, mul_one] at hn  have OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A)      (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) :      IsCompactOperator (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator : OAI.CoarseAssembly.Analytic.End c.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      apply OAI.CoarseAssembly.Analytic.boundedTransform_sub_compact      simpa only [hπ, mul_one] using c.square_compact 1  have OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_star_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A)      (hπ : c.representation 1 = 1) (hs : IsSelfAdjoint c.operator) :      IsCompactOperator (star (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator) : OAI.CoarseAssembly.Analytic.End c.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [(((      let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :          IsSelfAdjoint (OAI.CoarseAssembly.Analytic.boundedTransform F hF) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star (OAI.CoarseAssembly.Analytic.boundedTransform F hF) = OAI.CoarseAssembly.Analytic.boundedTransform F hF            simp only [OAI.CoarseAssembly.Analytic.boundedTransform, star_smul, star_sub, star_star, Complex.star_def,              map_div₀, Complex.conj_I, map_ofNat, neg_div, neg_smul]            module      local_proof) c.operator hs).sub hs).star_eq]      exact (OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_compact c hπ hs)  exact {    space := c.space    representation := c.representation    operator := OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs    commutator_compact a := by      have h := (c.compactPerturb _ ((OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_compact c hπ hs))        ((OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_star_compact c hπ hs))).commutator_compact a      change IsCompactOperator ((c.operator + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator)) *        c.representation a - c.representation a * (c.operator +          (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator)) : OAI.CoarseAssembly.Analytic.End c.space) at h      have he : c.operator + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator) =          OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs := by abel      rwa [he] at h    square_compact a := by      have h := (c.compactPerturb _ ((OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_compact c hπ hs))        ((OAI.CoarseAssembly.Analytic.OddCycle.boundedTransform_star_compact c hπ hs))).square_compact a      change IsCompactOperator (((c.operator + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator)) *        (c.operator + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator)) - 1) * c.representation a :          OAI.CoarseAssembly.Analytic.End c.space) at h      have he : c.operator + (OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs - c.operator) =          OAI.CoarseAssembly.Analytic.boundedTransform c.operator hs := by abel      rwa [he] at h    adjoint_compact a := by      rw [((    let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :        IsSelfAdjoint (OAI.CoarseAssembly.Analytic.boundedTransform F hF) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        by          change star (OAI.CoarseAssembly.Analytic.boundedTransform F hF) = OAI.CoarseAssembly.Analytic.boundedTransform F hF          simp only [OAI.CoarseAssembly.Analytic.boundedTransform, star_smul, star_sub, star_star, Complex.star_def,            map_div₀, Complex.conj_I, map_ofNat, neg_div, neg_smul]          module    local_proof) c.operator hs).star_eq, sub_self, zero_mul]      exact isCompactOperator_zero  }end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type} [CStarAlgebra A]def OddCycle.unitalSelfAdjoint (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : OAI.CoarseAssembly.Analytic.OddCycle A := by  classical  have OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : IsSelfAdjoint c.cutDown.operator  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          c.cutDown.operator = OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change c.operator + (OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator - c.operator) = _            abel      local_proof) c)]      exact (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) :          IsSelfAdjoint (OAI.CoarseAssembly.Analytic.symmetricCutDown P F) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star ((1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P)) = _            rw [star_add, star_smul, star_trivial, star_add, star_star, star_sub, star_one, hP.star_eq]            rw [add_comm (star (P * F * P))]            rfl      local_proof) _ _ ((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          IsSelfAdjoint (c.representation 1) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star (c.representation 1) = c.representation 1            rw [← map_star, star_one]      local_proof) c)  have OAI.CoarseAssembly.Analytic.cutDown_complement {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :      c.cutDown.operator * (1 - c.cutDown.representation 1) = 1 - c.cutDown.representation 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      change (c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c) * (1 - c.representation 1) = 1 - c.representation 1      have he : c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c =          OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator := by unfold OAI.CoarseAssembly.Analytic.representedCorrection; abel      rw [he]      exact (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P)          (hPP : P * P = P) : OAI.CoarseAssembly.Analytic.symmetricCutDown P F * (1 - P) = 1 - P :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            have hzero : ∀ T : OAI.CoarseAssembly.Analytic.End H, P * T * P * (1 - P) = 0 := by              intro T              rw [mul_sub, mul_one, mul_assoc (P * T) P P, hPP, sub_self]            have hQ : (1 - P) * (1 - P) = 1 - P := by              calc                (1 - P) * (1 - P) = 1 - P - P + P * P := by noncomm_ring                _ = 1 - P := by rw [hPP]; abel            unfold OAI.CoarseAssembly.Analytic.symmetricCutDown            rw [add_mul, smul_mul_assoc, add_mul, hzero F,              star_mul, star_mul, hP.star_eq, ← mul_assoc, hzero (star F), add_zero, smul_zero, zero_add, hQ]      local_proof) _ _ ((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          IsSelfAdjoint (c.representation 1) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star (c.representation 1) = c.representation 1            rw [← map_star, star_one]      local_proof) c) ((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          c.representation 1 * c.representation 1 = c.representation 1 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            rw [← map_mul, one_mul]      local_proof) c)  have OAI.CoarseAssembly.Analytic.represented_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A)      (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) :      IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      apply (      let local_proof (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ)          (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) :          IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            have hz : (c.operator * c.operator - 1) * (1 - c.representation 1) = 0 := by              calc                _ = c.operator * (c.operator * (1 - c.representation 1)) -                    (1 - c.representation 1) := by noncomm_ring                _ = 0 := by rw [hQ, hQ, sub_self]            have he : c.operator * c.operator - 1 =                (c.operator * c.operator - 1) * c.representation 1 := by              exact sub_eq_zero.mp (by simpa only [mul_sub, mul_one] using hz)            rw [he]            exact c.square_compact 1      local_proof) c.scalarRestriction      change c.operator * (1 - c.representation (algebraMap ℂ A 1)) =        1 - c.representation (algebraMap ℂ A 1)      simpa only [map_one] using hQ  have OAI.CoarseAssembly.Analytic.cutDown_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :      IsCompactOperator (c.cutDown.operator * c.cutDown.operator - 1 : OAI.CoarseAssembly.Analytic.End c.cutDown.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    OAI.CoarseAssembly.Analytic.represented_square_compact c.cutDown (OAI.CoarseAssembly.Analytic.cutDown_complement c)  exact c.cutDown.characterExtension χ (OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint c) (OAI.CoarseAssembly.Analytic.cutDown_complement c)      (OAI.CoarseAssembly.Analytic.cutDown_square_compact c)variable {T : Type*} [TopologicalSpace T] {H : HilbertSpace}end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type} [CStarAlgebra A]def OddCycle.regularize (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) : OAI.CoarseAssembly.Analytic.OddCycle A := by  classical  have OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : IsSelfAdjoint c.cutDown.operator  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          c.cutDown.operator = OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change c.operator + (OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator - c.operator) = _            abel      local_proof) c)]      exact (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) :          IsSelfAdjoint (OAI.CoarseAssembly.Analytic.symmetricCutDown P F) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star ((1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P)) = _            rw [star_add, star_smul, star_trivial, star_add, star_star, star_sub, star_one, hP.star_eq]            rw [add_comm (star (P * F * P))]            rfl      local_proof) _ _ ((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          IsSelfAdjoint (c.representation 1) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star (c.representation 1) = c.representation 1            rw [← map_star, star_one]      local_proof) c)  have OAI.CoarseAssembly.Analytic.cutDown_complement {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :      c.cutDown.operator * (1 - c.cutDown.representation 1) = 1 - c.cutDown.representation 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      change (c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c) * (1 - c.representation 1) = 1 - c.representation 1      have he : c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c =          OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator := by unfold OAI.CoarseAssembly.Analytic.representedCorrection; abel      rw [he]      exact (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P)          (hPP : P * P = P) : OAI.CoarseAssembly.Analytic.symmetricCutDown P F * (1 - P) = 1 - P :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            have hzero : ∀ T : OAI.CoarseAssembly.Analytic.End H, P * T * P * (1 - P) = 0 := by              intro T              rw [mul_sub, mul_one, mul_assoc (P * T) P P, hPP, sub_self]            have hQ : (1 - P) * (1 - P) = 1 - P := by              calc                (1 - P) * (1 - P) = 1 - P - P + P * P := by noncomm_ring                _ = 1 - P := by rw [hPP]; abel            unfold OAI.CoarseAssembly.Analytic.symmetricCutDown            rw [add_mul, smul_mul_assoc, add_mul, hzero F,              star_mul, star_mul, hP.star_eq, ← mul_assoc, hzero (star F), add_zero, smul_zero, zero_add, hQ]      local_proof) _ _ ((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          IsSelfAdjoint (c.representation 1) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star (c.representation 1) = c.representation 1            rw [← map_star, star_one]      local_proof) c) ((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          c.representation 1 * c.representation 1 = c.representation 1 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            rw [← map_mul, one_mul]      local_proof) c)  have OAI.CoarseAssembly.Analytic.represented_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A)      (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) :      IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      apply (      let local_proof (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ)          (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) :          IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            have hz : (c.operator * c.operator - 1) * (1 - c.representation 1) = 0 := by              calc                _ = c.operator * (c.operator * (1 - c.representation 1)) -                    (1 - c.representation 1) := by noncomm_ring                _ = 0 := by rw [hQ, hQ, sub_self]            have he : c.operator * c.operator - 1 =                (c.operator * c.operator - 1) * c.representation 1 := by              exact sub_eq_zero.mp (by simpa only [mul_sub, mul_one] using hz)            rw [he]            exact c.square_compact 1      local_proof) c.scalarRestriction      change c.operator * (1 - c.representation (algebraMap ℂ A 1)) =        1 - c.representation (algebraMap ℂ A 1)      simpa only [map_one] using hQ  have OAI.CoarseAssembly.Analytic.cutDown_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :      IsCompactOperator (c.cutDown.operator * c.cutDown.operator - 1 : OAI.CoarseAssembly.Analytic.End c.cutDown.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    OAI.CoarseAssembly.Analytic.represented_square_compact c.cutDown (OAI.CoarseAssembly.Analytic.cutDown_complement c)  have OAI.CoarseAssembly.Analytic.completedRepresentation_one {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) :      OAI.CoarseAssembly.Analytic.completedRepresentation c χ 1 = 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      simp only [(      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) (a : A) :          OAI.CoarseAssembly.Analytic.completedRepresentation c χ a = c.representation a + χ a • (1 - c.representation 1) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          rfl      local_proof), map_one, one_smul]      abel  have OAI.CoarseAssembly.Analytic.characterExtension_unital {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ)      (hF : IsSelfAdjoint c.operator)      (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1)      (hsq : IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space)) :      (c.characterExtension χ hF hQ hsq).representation 1 = 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    OAI.CoarseAssembly.Analytic.completedRepresentation_one c χ  have OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_unital {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) :      (c.unitalSelfAdjoint χ).representation 1 = 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    OAI.CoarseAssembly.Analytic.characterExtension_unital (c.cutDown) χ (OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint c) (OAI.CoarseAssembly.Analytic.cutDown_complement c) (OAI.CoarseAssembly.Analytic.cutDown_square_compact c)  have OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) :      IsSelfAdjoint (c.unitalSelfAdjoint χ).operator  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint c  exact (c.unitalSelfAdjoint χ).bounded ((OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_unital c χ)) ((OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_selfAdjoint c χ))end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsvariable {X : Type} [PseudoMetricSpace X] [Fintype X] (r : ℝ)def sqrtCoordinate (x : X) : C(OAI.CoarseAssembly.Rips.Point X r, ℂ) := by  classical  have OAI.CoarseAssembly.Rips.coordinate_continuous {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} (x : X) :      Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => p.weight x)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    (continuous_apply x).comp (      let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Continuous (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          continuous_induced_dom      local_proof)  exact {    toFun p := (Real.sqrt (p.weight x) : ℂ)    continuous_toFun := Complex.continuous_ofReal.comp      (Real.continuous_sqrt.comp (OAI.CoarseAssembly.Rips.coordinate_continuous x))  }end CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {X H : Type*} [Fintype X] [DecidableEq X]  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]def partitionMap (a : X → H →L[ℂ] H) : H →L[ℂ] Module X H :=  ∑ x, (insert x).comp (a x)def partitionIsometry (a : X → H →L[ℂ] H)    (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) : H →ₗᵢ[ℂ] OAI.CoarseAssembly.DiscreteRoe.Module X H := by  classical  have OAI.CoarseAssembly.DiscreteRoe.coordinate_partitionMap {X : Type _} {H : Type _} [inst_local_2 : Fintype X] [inst_local_3 : DecidableEq X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] (a : X → H →L[ℂ] H) (x : X) :      (OAI.CoarseAssembly.DiscreteRoe.coordinate x).comp (OAI.CoarseAssembly.DiscreteRoe.partitionMap a) = a x := by    ext v    simp only [OAI.CoarseAssembly.DiscreteRoe.partitionMap,      ContinuousLinearMap.comp_apply, sum_apply, map_sum]    change (∑ y, (lp.single 2 y ((a y) v)) x) = (a x) v    simp [lp.single_apply]  have OAI.CoarseAssembly.DiscreteRoe.partitionMap_adjoint {X : Type _} {H : Type _} [inst_local_2 : Fintype X] [inst_local_3 : DecidableEq X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] (a : X → H →L[ℂ] H) :      (OAI.CoarseAssembly.DiscreteRoe.partitionMap a).adjoint = ∑ x, (a x).adjoint.comp (OAI.CoarseAssembly.DiscreteRoe.coordinate x)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      simp only [OAI.CoarseAssembly.DiscreteRoe.partitionMap, map_sum, ContinuousLinearMap.adjoint_comp, (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] (x : X) : (OAI.CoarseAssembly.DiscreteRoe.insert (H := H) x).adjoint = OAI.CoarseAssembly.DiscreteRoe.coordinate x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            ext v            apply ext_inner_left ℂ            intro h            rw [ContinuousLinearMap.adjoint_inner_right]            change inner ℂ (lp.single 2 x h) v = inner ℂ h (v x)            exact lp.inner_single_left (𝕜 := ℂ) x h v      local_proof)]  have OAI.CoarseAssembly.DiscreteRoe.partitionMap_adjoint_comp {X : Type _} {H : Type _} [inst_local_2 : Fintype X] [inst_local_3 : DecidableEq X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] (a : X → H →L[ℂ] H) :      (OAI.CoarseAssembly.DiscreteRoe.partitionMap a).adjoint.comp (OAI.CoarseAssembly.DiscreteRoe.partitionMap a) = ∑ x, (a x).adjoint.comp (a x)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      rw [OAI.CoarseAssembly.DiscreteRoe.partitionMap_adjoint, ContinuousLinearMap.finsetSum_comp]      apply Finset.sum_congr rfl      intro x _      rw [ContinuousLinearMap.comp_assoc, OAI.CoarseAssembly.DiscreteRoe.coordinate_partitionMap]  exact {    toLinearMap := (OAI.CoarseAssembly.DiscreteRoe.partitionMap a).toLinearMap    norm_map' := (OAI.CoarseAssembly.DiscreteRoe.partitionMap a).norm_map_iff_adjoint_comp_self.mpr      ((OAI.CoarseAssembly.DiscreteRoe.partitionMap_adjoint_comp a).trans hpart)  }end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {X H : Type*} [Fintype X] [DecidableEq X]  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]def constantBlock (F : H →L[ℂ] H) : Operator X H :=  blockOperator (fun _ : X => F) ‖F‖ (norm_nonneg _) (fun _ => le_rfl)def partitionCompression (a : X → H →L[ℂ] H) (F : H →L[ℂ] H) : H →L[ℂ] H :=  (partitionMap a).adjoint.comp ((constantBlock F).comp (partitionMap a))end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssemblyvariable {E H : Type*}  [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]def isometricExtension (V : E →ₗᵢ[ℂ] H) (F : E →L[ℂ] E) : H →L[ℂ] H :=  1 + operatorConjugationHom V (F - 1)end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X]  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]local instance : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := by  classical  exact ⟨(    let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : CompleteSpace H] : Continuous (fun T : OAI.CoarseAssembly.DiscreteRoe.Operator X H => star T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in        open scoped ZeroAtInfty CStarAlgebra in        by          exact (ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous    local_proof)⟩def algebraicRoe (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite) :    NonUnitalStarSubalgebra ℂ (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := by  classical  have OAI.CoarseAssembly.DiscreteRoe.Generator.zero {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] : OAI.CoarseAssembly.DiscreteRoe.Generator (0 : OAI.CoarseAssembly.DiscreteRoe.Operator X H)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      refine ⟨⟨0, le_rfl, fun x y _ => (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x y : X) : OAI.CoarseAssembly.DiscreteRoe.entry (0 : OAI.CoarseAssembly.DiscreteRoe.Operator X H) x y = 0 := by          simp [OAI.CoarseAssembly.DiscreteRoe.entry]      local_proof) x y⟩, ?_, ?_⟩      · intro x y        rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x y : X) : OAI.CoarseAssembly.DiscreteRoe.entry (0 : OAI.CoarseAssembly.DiscreteRoe.Operator X H) x y = 0 := by          simp [OAI.CoarseAssembly.DiscreteRoe.entry]      local_proof)]        exact isCompactOperator_zero      · rw [star_zero (OAI.CoarseAssembly.DiscreteRoe.Operator X H)]        intro x y        rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x y : X) : OAI.CoarseAssembly.DiscreteRoe.entry (0 : OAI.CoarseAssembly.DiscreteRoe.Operator X H) x y = 0 := by          simp [OAI.CoarseAssembly.DiscreteRoe.entry]      local_proof)]        exact isCompactOperator_zero  have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.add {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {r s : ℝ}      (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) :      OAI.CoarseAssembly.DiscreteRoe.PropagationLE (max r s) (T + S)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y hxy      rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) :          OAI.CoarseAssembly.DiscreteRoe.entry (T + S) x y = OAI.CoarseAssembly.DiscreteRoe.entry T x y + OAI.CoarseAssembly.DiscreteRoe.entry S x y :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            ext h            simp [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.comp_add, ContinuousLinearMap.add_comp]      local_proof), hT x y (lt_of_le_of_lt (le_max_left _ _) hxy),        hS x y (lt_of_le_of_lt (le_max_right _ _) hxy), add_zero]  have OAI.CoarseAssembly.DiscreteRoe.Generator.add {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) (hS : OAI.CoarseAssembly.DiscreteRoe.Generator S) :      OAI.CoarseAssembly.DiscreteRoe.Generator (T + S)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT      obtain ⟨⟨s, hs, hq⟩, hd, hds⟩ := hS      refine ⟨⟨max r s, le_trans hr (le_max_left _ _), (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.add hp hq)⟩, ?_, ?_⟩      · intro x y        rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) :          OAI.CoarseAssembly.DiscreteRoe.entry (T + S) x y = OAI.CoarseAssembly.DiscreteRoe.entry T x y + OAI.CoarseAssembly.DiscreteRoe.entry S x y :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            ext h            simp [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.comp_add, ContinuousLinearMap.add_comp]      local_proof)]        exact (hc x y).add (hd x y)      · rw [star_add T S]        intro x y        rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) :          OAI.CoarseAssembly.DiscreteRoe.entry (T + S) x y = OAI.CoarseAssembly.DiscreteRoe.entry T x y + OAI.CoarseAssembly.DiscreteRoe.entry S x y :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            ext h            simp [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.comp_add, ContinuousLinearMap.add_comp]      local_proof)]        exact (hcs x y).add (hds x y)  have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.smul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {r : ℝ}      (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (z : ℂ) : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (z • T)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y hxy      rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (c : ℂ) (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) :          OAI.CoarseAssembly.DiscreteRoe.entry (c • T) x y = c • OAI.CoarseAssembly.DiscreteRoe.entry T x y :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            ext h            simp [OAI.CoarseAssembly.DiscreteRoe.entry]      local_proof), hT x y hxy, smul_zero]  have OAI.CoarseAssembly.DiscreteRoe.Generator.smul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) (z : ℂ) : OAI.CoarseAssembly.DiscreteRoe.Generator (z • T)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT      refine ⟨⟨r, hr, (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.smul hp z)⟩, ?_, ?_⟩      · intro x y        rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (c : ℂ) (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) :          OAI.CoarseAssembly.DiscreteRoe.entry (c • T) x y = c • OAI.CoarseAssembly.DiscreteRoe.entry T x y :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            ext h            simp [OAI.CoarseAssembly.DiscreteRoe.entry]      local_proof)]        exact (hc x y).smul z      · rw [star_smul]        intro x y        rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (c : ℂ) (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) :          OAI.CoarseAssembly.DiscreteRoe.entry (c • T) x y = c • OAI.CoarseAssembly.DiscreteRoe.entry T x y :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            ext h            simp [OAI.CoarseAssembly.DiscreteRoe.entry]      local_proof)]        exact (hcs x y).smul (star z)  have OAI.CoarseAssembly.DiscreteRoe.entry_star {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) :      OAI.CoarseAssembly.DiscreteRoe.entry (star T) x y = star (OAI.CoarseAssembly.DiscreteRoe.entry T y x) := by    have hI (z : X) : (OAI.CoarseAssembly.DiscreteRoe.insert (H := H) z).adjoint =        OAI.CoarseAssembly.DiscreteRoe.coordinate z := by      ext v      apply ext_inner_left ℂ      intro h      rw [ContinuousLinearMap.adjoint_inner_right]      change inner ℂ (lp.single 2 z h) v = inner ℂ h (v z)      exact lp.inner_single_left (𝕜 := ℂ) z h v    simp only [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.star_eq_adjoint,      ContinuousLinearMap.adjoint_comp]    rw [hI x, ← hI y, ContinuousLinearMap.adjoint_adjoint]    rfl  have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H}      (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (star T)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y hxy      rw [OAI.CoarseAssembly.DiscreteRoe.entry_star, hT y x (by simpa [dist_comm] using hxy), star_zero]  have OAI.CoarseAssembly.DiscreteRoe.Generator.star {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) : OAI.CoarseAssembly.DiscreteRoe.Generator (star T)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT      exact ⟨⟨r, hr, (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star hp)⟩, hcs, by simpa only [star_star] using hc⟩  have OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (s : Finset X) (v : OAI.CoarseAssembly.DiscreteRoe.Module X H)      (hv : ∀ x, x ∉ s → v x = 0) :      v = ∑ x ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert x (v x)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      apply lp.ext      funext x      simp only [lp.coeFn_sum, Finset.sum_apply, (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), lp.coeFn_single]      rw [Finset.sum_pi_single]      by_cases hx : x ∈ s      · simp [hx]      · simp [hx, hv x hx]  have OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (s : Finset X)      (hs : ∀ z, z ∉ s → OAI.CoarseAssembly.DiscreteRoe.entry S z y = 0) :      OAI.CoarseAssembly.DiscreteRoe.entry (T * S) x y = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.entry T x z * OAI.CoarseAssembly.DiscreteRoe.entry S z y  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      ext h      have hv : S (OAI.CoarseAssembly.DiscreteRoe.insert y h) = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert z (OAI.CoarseAssembly.DiscreteRoe.entry S z y h) := by        apply OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum        intro z hz        have := DFunLike.congr_fun (hs z hz) h        simpa only [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) :          OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), zero_apply] using this      change OAI.CoarseAssembly.DiscreteRoe.coordinate x (T (S (OAI.CoarseAssembly.DiscreteRoe.insert y h))) = _      rw [hv, map_sum, map_sum]      simp only [sum_apply, mul_apply_eq_comp]      rfl  have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r s : ℝ} {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H}      (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) :      OAI.CoarseAssembly.DiscreteRoe.PropagationLE (r + s) (T * S)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y hxy      rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset        ((      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) :          ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            intro z hz            apply hT            simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz      local_proof) finiteBalls hS y)]      apply Finset.sum_eq_zero      intro z hz      have hzy : dist z y ≤ s := by        simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall] using hz      have hxz : r < dist x z := by        have htri := dist_triangle x z y        linarith      rw [hT x z hxz, zero_mul]  have OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {s : ℝ}      (hT : OAI.CoarseAssembly.DiscreteRoe.CompactEntries T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : OAI.CoarseAssembly.DiscreteRoe.CompactEntries (T * S)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y      rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset        ((      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) :          ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            intro z hz            apply hT            simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz      local_proof) finiteBalls hS y)]      apply (      let local_proof {H : Type _} [inst_local_1 : NormedAddCommGroup H] [inst_local_2 : InnerProductSpace ℂ H] {ι : Type _} (s : Finset ι) (A : ι → H →L[ℂ] H)          (hA : ∀ i ∈ s, IsCompactOperator (A i)) :          IsCompactOperator (∑ i ∈ s, A i : H →L[ℂ] H) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            exact (compactOperator (RingHom.id ℂ) H H).sum_mem hA      local_proof)      intro z _      exact (hT x z).comp_clm (OAI.CoarseAssembly.DiscreteRoe.entry S z y)  have OAI.CoarseAssembly.DiscreteRoe.Generator.mul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite)      {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) (hS : OAI.CoarseAssembly.DiscreteRoe.Generator S) : OAI.CoarseAssembly.DiscreteRoe.Generator (T * S)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      obtain ⟨⟨r, hr, hp⟩, hc, hcs⟩ := hT      obtain ⟨⟨s, hs, hq⟩, hd, hds⟩ := hS      exact ⟨⟨r + s, add_nonneg hr hs, (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul finiteBalls hp hq)⟩,        (OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left finiteBalls hc hq), by          rw [star_mul]          exact OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left finiteBalls hds (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star hp)⟩  exact {    carrier := {T | OAI.CoarseAssembly.DiscreteRoe.Generator T}    zero_mem' := OAI.CoarseAssembly.DiscreteRoe.Generator.zero    add_mem' := OAI.CoarseAssembly.DiscreteRoe.Generator.add    mul_mem' := OAI.CoarseAssembly.DiscreteRoe.Generator.mul finiteBalls    smul_mem' z _ hT := (OAI.CoarseAssembly.DiscreteRoe.Generator.smul hT z)    star_mem' := OAI.CoarseAssembly.DiscreteRoe.Generator.star  }end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X]  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]local instance : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := by  classical  exact ⟨(    let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : CompleteSpace H] : Continuous (fun T : OAI.CoarseAssembly.DiscreteRoe.Operator X H => star T) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in        open scoped ZeroAtInfty CStarAlgebra in        by          exact (ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous    local_proof)⟩local instance : IsScalarTower ℂ (Operator X H) (Operator X H) where  smul_assoc c T S := by ext v; simplocal instance : SMulCommClass ℂ (Operator X H) (Operator X H) where  smul_comm c T S := by ext v; simpdef RoeMultiplier (T : Operator X H) : Prop :=  ∀ S : algebra (X := X) (H := H),    T * S.val ∈ algebra (X := X) (H := H) ∧ S.val * T ∈ algebra (X := X) (H := H)def roeIdealizer : NonUnitalStarSubalgebra ℂ (Operator X H) where  carrier := {T | RoeMultiplier T}  zero_mem' S := by simp only [zero_mul, mul_zero]; exact ⟨zero_mem _, zero_mem _⟩  add_mem' hT hU S := by    rw [add_mul, mul_add]    exact ⟨add_mem (hT S).1 (hU S).1, add_mem (hT S).2 (hU S).2⟩  mul_mem' hT hU S := by    constructor    · rw [mul_assoc]      exact (hT ⟨_, (hU S).1⟩).1    · rw [← mul_assoc]      exact (hU ⟨_, (hT S).2⟩).2  smul_mem' z T hT S := by    rw [smul_mul_assoc, mul_smul_comm]    exact ⟨(algebra (X := X) (H := H)).smul_mem z (hT S).1,      (algebra (X := X) (H := H)).smul_mem z (hT S).2⟩  star_mem' hT S := by    have h := hT ⟨star S.val, star_mem S.property⟩    exact ⟨by simpa only [star_mul, star_star] using star_mem h.2,      by simpa only [star_mul, star_star] using star_mem h.1⟩end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {X H : Type*} [Fintype X] [DecidableEq X]  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]local instance spatialLocalizationContinuousAdd {H : Type*} [NormedAddCommGroup H] :    ContinuousAdd H := IsTopologicalAddGroup.toContinuousAddlocal instance spatialLocalizationRingHomCompTriple :    RingHomCompTriple (RingHom.id ℂ) (RingHom.id ℂ) (RingHom.id ℂ) :=  RingHomCompTriple.idslocal instance spatialLocalizationCompleteSpace {X H : Type*}    [NormedAddCommGroup H] [CompleteSpace H] : CompleteSpace (Module X H) := inferInstancedef localizedSpatialOperator (a : X → H →L[ℂ] H)    (hpart : ∑ x, (a x).adjoint.comp (a x) = 1) (F : H →L[ℂ] H) : Operator X H :=  isometricExtension (partitionIsometry a hpart) (partitionCompression a F)variable [PseudoMetricSpace X]end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen Analytic DiscreteRoevariable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X] (r : ℝ)def representedSqrt (c : OddCycle C(Point X r, ℂ)) (x : X) : End c.space :=  c.representation (sqrtCoordinate r x)def ripsSpatialOperator (c : OAI.CoarseAssembly.Analytic.OddCycle C(OAI.CoarseAssembly.Rips.Point X r, ℂ)) (hπ : c.representation 1 = 1) :    OAI.CoarseAssembly.DiscreteRoe.Operator X c.space := by  classical  have OAI.CoarseAssembly.Rips.sqrtCoordinate_square_sum {X : Type} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) :      ∑ x : X, OAI.CoarseAssembly.Rips.sqrtCoordinate r x * OAI.CoarseAssembly.Rips.sqrtCoordinate r x = 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    by      ext p      change (ContinuousMap.evalAlgHom ℂ ℂ p)        (∑ x : X, OAI.CoarseAssembly.Rips.sqrtCoordinate r x * OAI.CoarseAssembly.Rips.sqrtCoordinate r x) = 1      rw [map_sum]      simp only [map_mul]      change (∑ x : X, (Real.sqrt (p.weight x) : ℂ) * (Real.sqrt (p.weight x) : ℂ)) = 1      simp only [← Complex.ofReal_mul, Real.mul_self_sqrt (p.nonneg _)]      rw [← Complex.ofReal_sum, ((      let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} [inst_local_3 : Fintype X] (p : OAI.CoarseAssembly.Rips.Point X r) : ∑ x : X, p.weight x = 1 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open scoped BigOperators in          open Topology in          by            rw [← p.total]            exact (p.weight.sum_fintype (fun _ t => t) (by simp)).symm      local_proof) p), Complex.ofReal_one]  have OAI.CoarseAssembly.Rips.representedSqrt_adjoint {X : Type} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) (c : OAI.CoarseAssembly.Analytic.OddCycle C(OAI.CoarseAssembly.Rips.Point X r, ℂ)) (x : X) :      (OAI.CoarseAssembly.Rips.representedSqrt r c x).adjoint = OAI.CoarseAssembly.Rips.representedSqrt r c x  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Analytic DiscreteRoe in    by      exact (((      let local_proof {X : Type} [inst_local_1 : PseudoMetricSpace X] (r : ℝ) (x : X) :          IsSelfAdjoint (OAI.CoarseAssembly.Rips.sqrtCoordinate r x) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          by            ext p            simp [OAI.CoarseAssembly.Rips.sqrtCoordinate]      local_proof) r x).map c.representation).star_eq  have OAI.CoarseAssembly.Rips.representedSqrt_partition {X : Type} [inst_local_1 : PseudoMetricSpace X] [inst_local_2 : Fintype X] (r : ℝ) (c : OAI.CoarseAssembly.Analytic.OddCycle C(OAI.CoarseAssembly.Rips.Point X r, ℂ))      (hπ : c.representation 1 = 1) :      ∑ x, (OAI.CoarseAssembly.Rips.representedSqrt r c x).adjoint.comp (OAI.CoarseAssembly.Rips.representedSqrt r c x) = 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Analytic DiscreteRoe in    by      simp only [OAI.CoarseAssembly.Rips.representedSqrt_adjoint]      change (∑ x, c.representation (OAI.CoarseAssembly.Rips.sqrtCoordinate r x) *        c.representation (OAI.CoarseAssembly.Rips.sqrtCoordinate r x)) = 1      simp only [← map_mul, ← map_sum, OAI.CoarseAssembly.Rips.sqrtCoordinate_square_sum, hπ]  exact OAI.CoarseAssembly.DiscreteRoe.localizedSpatialOperator (OAI.CoarseAssembly.Rips.representedSqrt r c) (OAI.CoarseAssembly.Rips.representedSqrt_partition r c hπ) c.operatorend CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssemblyvariable {X Y H : Type*}variable [NormedAddCommGroup H] [NormedSpace ℂ H]attribute [local instance 1001] AddGroup.existsAddOfLEdef extendedFunction (e : X ↪ Y) (x : lp (fun _ : X => H) 2) : Y → H :=  Function.extend e x 0def inclusionVector (e : X ↪ Y) (x : lp (fun _ : X => H) 2) : lp (fun _ : Y => H) 2 := by  classical  have OAI.CoarseAssembly.extendedFunction_hasSum {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2) :      HasSum (fun y => ‖OAI.CoarseAssembly.extendedFunction e x y‖ ^ 2) (‖x‖ ^ 2)  :=    open OAI OAI.CoarseAssembly in    by      have hf : HasSum (fun a : X => ‖x a‖ ^ 2) (‖x‖ ^ 2) := by        rw [(      let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]          (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 :=        open OAI OAI.CoarseAssembly in          by            simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using              lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x      local_proof)]        exact ((      let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]          (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) :=        open OAI OAI.CoarseAssembly in          by            simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using              (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal)      local_proof) x).hasSum      apply (e.injective.hasSum_iff (fun y hy => by        rw [(      let local_proof {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2)          (y : Y) (hy : y ∉ Set.range e) : OAI.CoarseAssembly.extendedFunction e x y = 0 :=        open OAI OAI.CoarseAssembly in          Function.extend_apply' _ _ _ hy      local_proof) e x y hy, norm_zero, zero_pow (by decide : 2 ≠ 0)])).mp      convert hf using 1      funext a      exact congrArg (fun h : H => ‖h‖ ^ 2) ((      let local_proof {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2) (a : X) :          OAI.CoarseAssembly.extendedFunction e x (e a) = x a :=        open OAI OAI.CoarseAssembly in          e.injective.extend_apply _ _ _      local_proof) e x a)  exact ⟨OAI.CoarseAssembly.extendedFunction e x, by      apply memℓp_gen      simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using        (OAI.CoarseAssembly.extendedFunction_hasSum e x).summable⟩def inclusionIsometry (e : X ↪ Y) : lp (fun _ : X => H) 2 →ₗᵢ[ℂ] lp (fun _ : Y => H) 2 := by  classical  have OAI.CoarseAssembly.extendedFunction_hasSum {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2) :      HasSum (fun y => ‖OAI.CoarseAssembly.extendedFunction e x y‖ ^ 2) (‖x‖ ^ 2)  :=    open OAI OAI.CoarseAssembly in    by      have hf : HasSum (fun a : X => ‖x a‖ ^ 2) (‖x‖ ^ 2) := by        rw [(      let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]          (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 :=        open OAI OAI.CoarseAssembly in          by            simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using              lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x      local_proof)]        exact ((      let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]          (x : lp E 2) : Summable (fun j => ‖x j‖ ^ 2) :=        open OAI OAI.CoarseAssembly in          by            simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using              (lp.memℓp x).summable (by norm_num : 0 < (2 : ENNReal).toReal)      local_proof) x).hasSum      apply (e.injective.hasSum_iff (fun y hy => by        rw [(      let local_proof {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2)          (y : Y) (hy : y ∉ Set.range e) : OAI.CoarseAssembly.extendedFunction e x y = 0 :=        open OAI OAI.CoarseAssembly in          Function.extend_apply' _ _ _ hy      local_proof) e x y hy, norm_zero, zero_pow (by decide : 2 ≠ 0)])).mp      convert hf using 1      funext a      exact congrArg (fun h : H => ‖h‖ ^ 2) ((      let local_proof {X : Type _} {Y : Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] (e : X ↪ Y) (x : lp (fun _ : X => H) 2) (a : X) :          OAI.CoarseAssembly.extendedFunction e x (e a) = x a :=        open OAI OAI.CoarseAssembly in          e.injective.extend_apply _ _ _      local_proof) e x a)  exact {    toFun := OAI.CoarseAssembly.inclusionVector e    map_add' x z := by      apply lp.ext      funext y      by_cases hy : y ∈ Set.range e      · obtain ⟨a, rfl⟩ := hy        change extendedFunction e (x + z) (e a) = extendedFunction e x (e a) + extendedFunction e z (e a)        simp only [extendedFunction, e.injective.extend_apply]        rfl      · change extendedFunction e (x + z) y = extendedFunction e x y + extendedFunction e z y        simp only [extendedFunction, Function.extend_apply' _ _ _ hy, Pi.zero_apply, add_zero]    map_smul' c x := by      apply lp.ext      funext y      by_cases hy : y ∈ Set.range e      · obtain ⟨a, rfl⟩ := hy        change extendedFunction e (c • x) (e a) = c • extendedFunction e x (e a)        simp only [extendedFunction, e.injective.extend_apply]        rfl      · change extendedFunction e (c • x) y = c • extendedFunction e x y        simp only [extendedFunction, Function.extend_apply' _ _ _ hy, Pi.zero_apply, smul_zero]    norm_map' x := by      change ‖OAI.CoarseAssembly.inclusionVector e x‖ = ‖x‖      have hs : ‖OAI.CoarseAssembly.inclusionVector e x‖ ^ 2 = ‖x‖ ^ 2 := by        rw [(    let local_proof {J : Type _} {E : J → Type _} [∀ j, NormedAddCommGroup (E j)]        (x : lp E 2) : ‖x‖ ^ 2 = ∑' j, ‖x j‖ ^ 2 :=      open OAI OAI.CoarseAssembly in        by          simpa only [ENNReal.toReal_ofNat, Real.rpow_two] using            lp.norm_rpow_eq_tsum (p := 2) (by norm_num) x    local_proof)]        exact (OAI.CoarseAssembly.extendedFunction_hasSum e x).tsum_eq      nlinarith [norm_nonneg (OAI.CoarseAssembly.inclusionVector e x), norm_nonneg x]  }end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticattribute [local instance 1001] ChainCompletePartialOrder.toPartialOrder  HeytingAlgebra.toOrderBot AddGroup.existsAddOfLEdef ampleIsometry (H : OAI.CoarseAssembly.Analytic.HilbertSpace) : H →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2 := by  classical  have OAI.CoarseAssembly.Analytic.exists_ampleIsometry (H : OAI.CoarseAssembly.Analytic.HilbertSpace) :      Nonempty (H →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      obtain ⟨s, b, _⟩ := exists_hilbertBasis ℂ H      let : Countable s := (      let local_proof {H : Type _} [NormedAddCommGroup H]          [InnerProductSpace ℂ H] [SecondCountableTopology H] {ι : Type _} {v : ι → H}          (hv : Orthonormal ℂ v) : Countable ι :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            have hd : Pairwise (fun i j => Disjoint (Metric.ball (v i) (1 / 2 : ℝ))                (Metric.ball (v j) (1 / 2 : ℝ))) := by              intro i j hij              apply Set.disjoint_left.mpr              intro z hzi hzj              have hn : ‖v i - v j‖ ^ 2 = 2 := by                rw [@norm_sub_sq ℂ]                norm_num [hv.norm_eq_one, hv.inner_eq_zero hij]              have hzi' : dist (v i) z < 1 / 2 := by simpa only [Metric.mem_ball, dist_comm] using hzi              have hzj' : dist z (v j) < 1 / 2 := hzj              have hdist : dist (v i) (v j) < 1 := by linarith [dist_triangle (v i) z (v j)]              rw [dist_eq_norm] at hdist              nlinarith [norm_nonneg (v i - v j)]            exact hd.countable_of_isOpen_disjoint (fun _ => Metric.isOpen_ball)              (fun i => ⟨v i, Metric.mem_ball_self (by norm_num)⟩)      local_proof) b.orthonormal      obtain ⟨f, hf⟩ := exists_injective_nat s      exact ⟨(OAI.CoarseAssembly.inclusionIsometry (H := ℂ) ⟨f, hf⟩).comp b.repr.toLinearIsometry⟩  exact (OAI.CoarseAssembly.Analytic.exists_ampleIsometry H).someend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {X E H : Type*} [DecidableEq X]  [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]def coefficientIsometry (V : E →ₗᵢ[ℂ] H) : Module X E →ₗᵢ[ℂ] Module X H :=  blockIsometry (fun _ : X => V)variable [PseudoMetricSpace X]def coefficientExtension (V : E →ₗᵢ[ℂ] H) (T : Operator X E) : Operator X H :=  isometricExtension (coefficientIsometry V) Tend CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {V : ℕ → Type*} [∀ i, DecidableEq (V i)]  {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]def diagonalFamily (A : ∀ i, Operator (V i) H) (C : ℝ) (hC : 0 ≤ C)    (hA : ∀ i, ‖A i‖ ≤ C) : Operator (Sigma V) H :=  flattenOperator (blockOperator A C hC hA)variable [∀ i, MetricSpace (V i)] (o : ∀ i, V i)end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen Topologyvariable {X Y : Type*} [PseudoMetricSpace X] [PseudoMetricSpace Y]  {r : ℝ}def mapPoint (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y)    (p : Point X r) : Point Y r where  weight := p.weight.embDomain e  nonneg y := by    classical    by_cases hy : y ∈ Set.range e    · obtain ⟨x, rfl⟩ := hy      simpa using p.nonneg x    · rw [Finsupp.embDomain_of_notMem_range e p.weight y hy]  total := by simpa only [Finsupp.sum_embDomain] using p.total  diameter x hx y hy := by    rw [Finsupp.support_embDomain, Finset.mem_map] at hx hy    obtain ⟨u, hu, rfl⟩ := hx    obtain ⟨v, hv, rfl⟩ := hy    exact (he u v).trans (p.diameter u hu v hv)def unmapPoint (e : X ↪ Y) (he : Isometry e) (q : Point Y r)    (hq : ↑q.weight.support ⊆ Set.range e) : Point X r where  weight := q.weight.comapDomain e e.injective.injOn  nonneg x := by simpa only [Finsupp.comapDomain_apply] using q.nonneg (e x)  total := by    have hm := Finsupp.embDomain_comapDomain hq    have hs := congrArg (fun f : Y →₀ ℝ => f.sum (fun _ t => t)) hm    simpa only [Finsupp.sum_embDomain, q.total] using hs  diameter x hx y hy := by    rw [← he.dist_eq]    exact q.diameter (e x)      (by simpa only [Finsupp.mem_support_iff, Finsupp.comapDomain_apply] using hx) (e y)      (by simpa only [Finsupp.mem_support_iff, Finsupp.comapDomain_apply] using hy)end CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssemblyopen Topology Ripsvariable {V : ℕ → Type} [∀ j, MetricSpace (V j)]def separatedComponent (j : ℕ) : V j ↪ Sigma V := ⟨Sigma.mk j, sigma_mk_injective⟩end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssembly.TopologicalK1open CoarseAssembly.Analytic (Interval start finish)universe u v wvariable (R : Type u) [Ring R] [TopologicalSpace R]abbrev InvertibleMatrix (n : ℕ) := (Matrix (Fin n) (Fin n) R)ˣabbrev StableGL := Σ n : ℕ, InvertibleMatrix R ndef IsStabilization {n : ℕ} (g : InvertibleMatrix R n) (h : InvertibleMatrix R (n + 1)) : Prop :=  (h : Matrix (Fin (n + 1)) (Fin (n + 1)) R).submatrix finSumFinEquiv finSumFinEquiv =    Matrix.fromBlocks (g : Matrix (Fin n) (Fin n) R) 0 0      (1 : Matrix (Fin 1) (Fin 1) R)inductive Relation : FreeAbelianGroup (StableGL R) → Prop  | mul {n : ℕ} (g h : InvertibleMatrix R n) :      Relation (FreeAbelianGroup.of ⟨n, g * h⟩ -        (FreeAbelianGroup.of ⟨n, g⟩ + FreeAbelianGroup.of ⟨n, h⟩))  | stabilize {n : ℕ} (g : InvertibleMatrix R n) (h : InvertibleMatrix R (n + 1)) (hs : IsStabilization R g h) :      Relation (FreeAbelianGroup.of ⟨n, g⟩ - FreeAbelianGroup.of ⟨n + 1, h⟩)  | homotopy {n : ℕ} (c : Interval → InvertibleMatrix R n) (hc : Continuous c) :      Relation (FreeAbelianGroup.of ⟨n, c start⟩ - FreeAbelianGroup.of ⟨n, c finish⟩)def relations : AddSubgroup (FreeAbelianGroup (StableGL R)) :=  AddSubgroup.closure {z | Relation R z}abbrev Group := FreeAbelianGroup (StableGL R) ⧸ relations Rdef matrixClass {n : ℕ} (g : InvertibleMatrix R n) : Group R :=  QuotientAddGroup.mk (FreeAbelianGroup.of ⟨n, g⟩)variable {R}variable {S : Type v} {T : Type w} [Ring S] [TopologicalSpace S] [Ring T] [TopologicalSpace T]def mapGL (φ : R →+* S) (n : ℕ) : InvertibleMatrix R n →* InvertibleMatrix S n :=  Units.map φ.mapMatrix.toMonoidHomdef mapFree (φ : R →+* S) : FreeAbelianGroup (StableGL R) →+ Group S :=  FreeAbelianGroup.lift (fun g => matrixClass S (mapGL φ g.1 g.2))def map (φ : R →+* S) (hφ : Continuous φ) : OAI.CoarseAssembly.TopologicalK1.Group R →+ OAI.CoarseAssembly.TopologicalK1.Group S := by  classical  have OAI.CoarseAssembly.TopologicalK1.matrixClass_mul {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {n : ℕ} (g h : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) :      OAI.CoarseAssembly.TopologicalK1.matrixClass R (g * h) = OAI.CoarseAssembly.TopologicalK1.matrixClass R g + OAI.CoarseAssembly.TopologicalK1.matrixClass R h  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in    open OAI.CoarseAssembly.Analytic in    by      apply sub_eq_zero.mp      simpa only [OAI.CoarseAssembly.TopologicalK1.matrixClass, QuotientAddGroup.mk_sub, QuotientAddGroup.mk_add] using        (      let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {z : FreeAbelianGroup (OAI.CoarseAssembly.TopologicalK1.StableGL R)} (h : OAI.CoarseAssembly.TopologicalK1.Relation R z) :          (QuotientAddGroup.mk z : OAI.CoarseAssembly.TopologicalK1.Group R) = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in          open OAI.CoarseAssembly.Analytic in          (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure h)      local_proof) (.mul g h)  have OAI.CoarseAssembly.TopologicalK1.matrixClass_stabilize {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {n : ℕ} (g : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) (h : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R (n + 1))      (hs : OAI.CoarseAssembly.TopologicalK1.IsStabilization R g h) : OAI.CoarseAssembly.TopologicalK1.matrixClass R g = OAI.CoarseAssembly.TopologicalK1.matrixClass R h  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in    open OAI.CoarseAssembly.Analytic in    by      apply sub_eq_zero.mp      simpa only [OAI.CoarseAssembly.TopologicalK1.matrixClass, QuotientAddGroup.mk_sub] using (      let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {z : FreeAbelianGroup (OAI.CoarseAssembly.TopologicalK1.StableGL R)} (h : OAI.CoarseAssembly.TopologicalK1.Relation R z) :          (QuotientAddGroup.mk z : OAI.CoarseAssembly.TopologicalK1.Group R) = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in          open OAI.CoarseAssembly.Analytic in          (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure h)      local_proof) (.stabilize g h hs)  have OAI.CoarseAssembly.TopologicalK1.matrixClass_homotopy {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {n : ℕ} (c : OAI.CoarseAssembly.Analytic.Interval → OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) (hc : Continuous c) :      OAI.CoarseAssembly.TopologicalK1.matrixClass R (c OAI.CoarseAssembly.Analytic.start) = OAI.CoarseAssembly.TopologicalK1.matrixClass R (c OAI.CoarseAssembly.Analytic.finish)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in    open OAI.CoarseAssembly.Analytic in    by      apply sub_eq_zero.mp      simpa only [OAI.CoarseAssembly.TopologicalK1.matrixClass, QuotientAddGroup.mk_sub] using (      let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {z : FreeAbelianGroup (OAI.CoarseAssembly.TopologicalK1.StableGL R)} (h : OAI.CoarseAssembly.TopologicalK1.Relation R z) :          (QuotientAddGroup.mk z : OAI.CoarseAssembly.TopologicalK1.Group R) = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in          open OAI.CoarseAssembly.Analytic in          (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure h)      local_proof) (.homotopy c hc)  have OAI.CoarseAssembly.TopologicalK1.mapFree_relation {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {S : Type _} [inst_local_4 : Ring S] [inst_local_5 : TopologicalSpace S] (φ : R →+* S) (hφ : Continuous φ)      {z : FreeAbelianGroup (OAI.CoarseAssembly.TopologicalK1.StableGL R)} (hz : OAI.CoarseAssembly.TopologicalK1.Relation R z) : OAI.CoarseAssembly.TopologicalK1.mapFree φ z = 0  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in    open OAI.CoarseAssembly.Analytic in    by      cases hz with      | mul g h =>        simpa [OAI.CoarseAssembly.TopologicalK1.mapFree] using sub_eq_zero.mpr (OAI.CoarseAssembly.TopologicalK1.matrixClass_mul (OAI.CoarseAssembly.TopologicalK1.mapGL φ _ g) (OAI.CoarseAssembly.TopologicalK1.mapGL φ _ h))      | stabilize g h hs =>        simpa [OAI.CoarseAssembly.TopologicalK1.mapFree] using sub_eq_zero.mpr          (OAI.CoarseAssembly.TopologicalK1.matrixClass_stabilize _ _ ((      let local_proof {R : Type _} [inst_local_1 : Ring R] {S : Type _} [inst_local_3 : Ring S] (φ : R →+* S) {n : ℕ} (g : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) (h : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R (n + 1))          (hs : OAI.CoarseAssembly.TopologicalK1.IsStabilization R g h) : OAI.CoarseAssembly.TopologicalK1.IsStabilization S (OAI.CoarseAssembly.TopologicalK1.mapGL φ n g) (OAI.CoarseAssembly.TopologicalK1.mapGL φ (n + 1) h) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in          open OAI.CoarseAssembly.Analytic in          by            have heq := congrArg (fun M => Matrix.map M φ) hs            simpa [OAI.CoarseAssembly.TopologicalK1.IsStabilization, OAI.CoarseAssembly.TopologicalK1.mapGL, Matrix.fromBlocks_map, Matrix.submatrix_map] using heq      local_proof) φ g h hs))      | homotopy c hc =>        simpa [OAI.CoarseAssembly.TopologicalK1.mapFree] using sub_eq_zero.mpr          (OAI.CoarseAssembly.TopologicalK1.matrixClass_homotopy (fun t => OAI.CoarseAssembly.TopologicalK1.mapGL φ _ (c t)) (((      let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {S : Type _} [inst_local_4 : Ring S] [inst_local_5 : TopologicalSpace S] (φ : R →+* S) (hφ : Continuous φ) (n : ℕ) :          Continuous (OAI.CoarseAssembly.TopologicalK1.mapGL φ n) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in          open OAI.CoarseAssembly.Analytic in          by            apply Continuous.units_map            exact continuous_pi (fun i => continuous_pi (fun j =>              hφ.comp ((continuous_apply j).comp (continuous_apply i))))      local_proof) φ hφ _).comp hc))  exact QuotientAddGroup.lift (OAI.CoarseAssembly.TopologicalK1.relations R) (OAI.CoarseAssembly.TopologicalK1.mapFree φ)      ((AddSubgroup.closure_le _).2 (fun _ hz => OAI.CoarseAssembly.TopologicalK1.mapFree_relation φ hφ hz))end CoarseAssembly.TopologicalK1endendsectionnoncomputable sectionnamespace CoarseAssembly.TopologicalK1open Analyticvariable {A : Type*} [CStarAlgebra A]sectionattribute [-instance] LocallyConvexSpace.toPolynormableSpaceendend CoarseAssembly.TopologicalK1endendsectionnoncomputable sectionnamespace CoarseAssembly.OperatorKTheoryopen scoped CStarAlgebrauniverse u v wvariable (A : Type u) [NonUnitalCStarAlgebra A]def scalarMap : TopologicalK1.Group (Unitization ℂ A) →+ TopologicalK1.Group ℂ :=  TopologicalK1.map (Unitization.fstHom ℂ A).toRingHom Unitization.continuous_fstabbrev K1 := (scalarMap A).kervariable {A} {B : Type v} [NonUnitalCStarAlgebra B]variable {C : Type w} [NonUnitalCStarAlgebra C]def unitizationMap (φ : A →⋆ₙₐ[ℂ] B) :    TopologicalK1.Group (Unitization ℂ A) →+ TopologicalK1.Group (Unitization ℂ B) :=  TopologicalK1.map (Unitization.starMap φ).toRingHom (show Continuous (Unitization.starMap φ) from map_continuous _)def map (φ : A →⋆ₙₐ[ℂ] B) : OAI.CoarseAssembly.OperatorKTheory.K1 A →+ OAI.CoarseAssembly.OperatorKTheory.K1 B := by  classical  exact {    toFun x := ⟨OAI.CoarseAssembly.OperatorKTheory.unitizationMap φ x, by      change OAI.CoarseAssembly.OperatorKTheory.scalarMap B (OAI.CoarseAssembly.OperatorKTheory.unitizationMap φ x) = 0      rw [← AddMonoidHom.comp_apply, (    let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {B : Type _} [inst_local_3 : NonUnitalCStarAlgebra B] (φ : A →⋆ₙₐ[ℂ] B) :        (OAI.CoarseAssembly.OperatorKTheory.scalarMap B).comp (OAI.CoarseAssembly.OperatorKTheory.unitizationMap φ) = OAI.CoarseAssembly.OperatorKTheory.scalarMap A :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.OperatorKTheory in        open scoped CStarAlgebra in        by          apply QuotientAddGroup.addMonoidHom_ext          apply FreeAbelianGroup.lift_ext          rintro ⟨n, g⟩          change OAI.CoarseAssembly.TopologicalK1.matrixClass ℂ              (OAI.CoarseAssembly.TopologicalK1.mapGL (Unitization.fstHom ℂ B).toRingHom n                (OAI.CoarseAssembly.TopologicalK1.mapGL (Unitization.starMap φ).toRingHom n g)) =            OAI.CoarseAssembly.TopologicalK1.matrixClass ℂ              (OAI.CoarseAssembly.TopologicalK1.mapGL (Unitization.fstHom ℂ A).toRingHom n g)          congr 1          apply Units.ext          apply Matrix.ext          intro i j          change (Unitization.starMap φ ((g : Matrix (Fin n) (Fin n) (Unitization ℂ A)) i j)).fst =            ((g : Matrix (Fin n) (Fin n) (Unitization ℂ A)) i j).fst          simp [Unitization.starMap_apply, Unitization.algebraMap_eq_inl]    local_proof)]      exact x.property⟩    map_zero' := Subtype.ext ((OAI.CoarseAssembly.OperatorKTheory.unitizationMap φ).map_zero)    map_add' x y := Subtype.ext ((OAI.CoarseAssembly.OperatorKTheory.unitizationMap φ).map_add x y)  }end CoarseAssembly.OperatorKTheoryendendsectionnoncomputable sectionnamespace CoarseAssembly.OperatorKTheoryvariable {A : Type*} [CStarAlgebra A] (S : NonUnitalStarSubalgebra ℂ A)def relativePart (u : unitary A) (hu : (u : A) - 1 ∈ S) : S := ⟨(u : A) - 1, hu⟩def relativeUnitary (u : unitary A) (hu : (u : A) - 1 ∈ S) :    unitary (Unitization ℂ S) := by  classical  let r := OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu  refine ⟨1 + (r : Unitization ℂ S), ?_, ?_⟩  · apply Unitization.ext    · simp    · simpa using (  let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (S : NonUnitalStarSubalgebra ℂ A) (u : unitary A) (hu : (u : A) - 1 ∈ S) :      OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu + star (OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu) +      star (OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu) * OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu = 0 :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.OperatorKTheory in      by        apply Subtype.ext        change ((u : A) - 1) + star ((u : A) - 1) +          star ((u : A) - 1) * ((u : A) - 1) = 0        rw [star_sub, star_one]        have h := Unitary.coe_star_mul_self u        change star (u : A) * (u : A) = 1 at h        noncomm_ring [h]  local_proof) S u hu  · apply Unitization.ext    · simp    · simpa using (  let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (S : NonUnitalStarSubalgebra ℂ A) (u : unitary A) (hu : (u : A) - 1 ∈ S) :      star (OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu) + OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu +      OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu * star (OAI.CoarseAssembly.OperatorKTheory.relativePart S u hu) = 0 :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.OperatorKTheory in      by        apply Subtype.ext        change star ((u : A) - 1) + ((u : A) - 1) +          ((u : A) - 1) * star ((u : A) - 1) = 0        rw [star_sub, star_one]        have h := Unitary.coe_mul_star_self u        change (u : A) * star (u : A) = 1 at h        noncomm_ring [h]  local_proof) S u hudef relativeMatrix (u : unitary A) (hu : (u : A) - 1 ∈ S) :    TopologicalK1.InvertibleMatrix (Unitization ℂ S) 1 :=  Units.map (Matrix.scalar (Fin 1)).toMonoidHom (Unitary.toUnits (relativeUnitary S u hu))variable [hS : IsClosed (S : Set A)]def relativeClass (u : unitary A) (hu : (u : A) - 1 ∈ S) : OAI.CoarseAssembly.OperatorKTheory.K1 S := by  classical  have OAI.CoarseAssembly.TopologicalK1.matrixClass_mul {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {n : ℕ} (g h : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) :      OAI.CoarseAssembly.TopologicalK1.matrixClass R (g * h) = OAI.CoarseAssembly.TopologicalK1.matrixClass R g + OAI.CoarseAssembly.TopologicalK1.matrixClass R h  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in    open OAI.CoarseAssembly.Analytic in    by      apply sub_eq_zero.mp      simpa only [OAI.CoarseAssembly.TopologicalK1.matrixClass, QuotientAddGroup.mk_sub, QuotientAddGroup.mk_add] using        (      let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {z : FreeAbelianGroup (OAI.CoarseAssembly.TopologicalK1.StableGL R)} (h : OAI.CoarseAssembly.TopologicalK1.Relation R z) :          (QuotientAddGroup.mk z : OAI.CoarseAssembly.TopologicalK1.Group R) = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in          open OAI.CoarseAssembly.Analytic in          (QuotientAddGroup.eq_zero_iff z).2 (AddSubgroup.subset_closure h)      local_proof) (.mul g h)  have OAI.CoarseAssembly.TopologicalK1.matrixClass_one {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] (n : ℕ) : OAI.CoarseAssembly.TopologicalK1.matrixClass R (1 : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) = 0  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in    open OAI.CoarseAssembly.Analytic in    by      have h := OAI.CoarseAssembly.TopologicalK1.matrixClass_mul (1 : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) 1      simp only [one_mul] at h      exact (add_left_cancel ((add_zero _).trans h)).symm  have OAI.CoarseAssembly.OperatorKTheory.scalarMap_matrixClass {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {n : ℕ}      (g : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix (Unitization ℂ A) n) :      OAI.CoarseAssembly.OperatorKTheory.scalarMap A (OAI.CoarseAssembly.TopologicalK1.matrixClass (Unitization ℂ A) g) =        OAI.CoarseAssembly.TopologicalK1.matrixClass ℂ          (OAI.CoarseAssembly.TopologicalK1.mapGL (Unitization.fstHom ℂ A).toRingHom n g)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.OperatorKTheory in    open scoped CStarAlgebra in    (      let local_proof {R : Type _} [inst_local_1 : Ring R] [inst_local_2 : TopologicalSpace R] {S : Type _} [inst_local_4 : Ring S] [inst_local_5 : TopologicalSpace S] (φ : R →+* S) (hφ : Continuous φ) {n : ℕ} (g : OAI.CoarseAssembly.TopologicalK1.InvertibleMatrix R n) :          OAI.CoarseAssembly.TopologicalK1.map φ hφ (OAI.CoarseAssembly.TopologicalK1.matrixClass R g) = OAI.CoarseAssembly.TopologicalK1.matrixClass S (OAI.CoarseAssembly.TopologicalK1.mapGL φ n g) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.TopologicalK1 in          open OAI.CoarseAssembly.Analytic in          FreeAbelianGroup.lift_apply_of _ _      local_proof) _ _ _  exact ⟨OAI.CoarseAssembly.TopologicalK1.matrixClass (Unitization ℂ S) (OAI.CoarseAssembly.OperatorKTheory.relativeMatrix S u hu), by      rw [AddMonoidHom.mem_ker, OAI.CoarseAssembly.OperatorKTheory.scalarMap_matrixClass, (    let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (S : NonUnitalStarSubalgebra ℂ A) (u : unitary A) (hu : (u : A) - 1 ∈ S) :        OAI.CoarseAssembly.TopologicalK1.mapGL (Unitization.fstHom ℂ S).toRingHom 1 (OAI.CoarseAssembly.OperatorKTheory.relativeMatrix S u hu) = 1 :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.OperatorKTheory in        by          apply Units.ext          ext i j          have hij : i = j := Subsingleton.elim _ _          simp [OAI.CoarseAssembly.TopologicalK1.mapGL, OAI.CoarseAssembly.OperatorKTheory.relativeMatrix, OAI.CoarseAssembly.OperatorKTheory.relativeUnitary, Matrix.scalar_apply,            Unitary.val_toUnits_apply, hij]    local_proof),        OAI.CoarseAssembly.TopologicalK1.matrixClass_one]⟩end CoarseAssembly.OperatorKTheoryendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {X H : Type*} [DecidableEq X] [PseudoMetricSpace X]  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]def multiplierAlgebra : StarSubalgebra ℂ (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := by  classical  exact {    carrier := OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H)    add_mem' := (OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H)).add_mem    mul_mem' := (OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H)).mul_mem    star_mem' := fun h => star_mem h    algebraMap_mem' z := by      rw [Algebra.algebraMap_eq_smul_one]      exact (OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H)).smul_mem z (    let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] : (1 : OAI.CoarseAssembly.DiscreteRoe.Operator X H) ∈ OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in        by          intro S          constructor          · simpa only [one_mul] using S.property          · simpa only [mul_one] using S.property    local_proof)  }instance : CStarAlgebra (OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H)) := by  classical  have OAI.CoarseAssembly.DiscreteRoe.roeIdealizer_closed {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.roeIdealizer (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H))  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      simp only [OAI.CoarseAssembly.DiscreteRoe.roeIdealizer, OAI.CoarseAssembly.DiscreteRoe.RoeMultiplier, Set.ofPred_forall]      apply isClosed_iInter      intro S      exact ((      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩            exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _      local_proof).preimage (continuous_id.mul continuous_const)).inter        ((      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩            exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _      local_proof).preimage (continuous_const.mul continuous_id))  have OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra_closed {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] :      IsClosed (OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H))  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    OAI.CoarseAssembly.DiscreteRoe.roeIdealizer_closed  exact StarSubalgebra.cstarAlgebra _ (h_closed := OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra_closed)def multiplierRoeIdeal : TwoSidedIdeal (multiplierAlgebra (X := X) (H := H)) :=  TwoSidedIdeal.mk' {T | T.val ∈ algebra (X := X) (H := H)}    (algebra (X := X) (H := H)).zero_mem    (fun hT hS => (algebra (X := X) (H := H)).add_mem hT hS)    (fun hT => (algebra (X := X) (H := H)).neg_mem hT)    (fun {T S} hS => T.property ⟨S.val, hS⟩ |>.1)    (fun {T S} hT => S.property ⟨T.val, hT⟩ |>.2)def multiplierBoundaryUnitary (F : multiplierAlgebra (X := X) (H := H))    (hF : IsSelfAdjoint F) : unitary (Operator X H) :=  Unitary.map (StarMonoidHom.ofClass (multiplierAlgebra (X := X) (H := H)).subtype)    (Analytic.rationalBoundaryUnitary F hF)def multiplierBoundaryClass    (F : OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F)    (hdefect : F.val ^ 2 - 1 ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)) :    OAI.CoarseAssembly.OperatorKTheory.K1 (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)) := by  classical  have OAI.CoarseAssembly.Analytic.cayleyDenominator_val {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F + algebraMap ℂ A Complex.I  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    ((      let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :          IsUnit (F + algebraMap ℂ A Complex.I) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            have hn : -Complex.I ∉ spectrum ℂ F := by              intro h              have hi := hF.im_eq_zero_of_mem_spectrum h              simp at hi            have hu : IsUnit (algebraMap ℂ A (-Complex.I) - F) :=              not_not.mp (fun h => hn (spectrum.mem_iff.mpr h))            convert hu.neg using 1            simp only [map_neg, neg_sub, sub_neg_eq_add]      local_proof) F hF).unit_spec  have OAI.CoarseAssembly.Analytic.cayleyDenominator_star {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) = F - algebraMap ℂ A Complex.I  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_val, star_add, hF.star_eq]      simp only [← algebraMap_star_comm, Complex.star_def, Complex.conj_I, map_neg,        sub_eq_add_neg]  have OAI.CoarseAssembly.Analytic.cayleyDenominator_normal {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      Commute (star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)) (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val]      have hc : Commute (algebraMap ℂ A Complex.I) F := Algebra.commutes _ _      exact ((Commute.refl F).sub_left hc).add_right        (hc.symm.sub_left (Commute.refl _))  have OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary_defect {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :      ((OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary F hF : A) - 1) *          (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) ^ 2 = -2 * (F ^ 2 - 1)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      let b := OAI.CoarseAssembly.Analytic.cayleyDenominator F hF      have hc : Commute (star (b : A)) (b : A) := OAI.CoarseAssembly.Analytic.cayleyDenominator_normal F hF      have hci : Commute (star (b : A)) (↑b⁻¹ : A) := hc.units_inv_right      have he : (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) ^ 2 * (b : A) ^ 2 = star (b : A) ^ 2 := by        rw [(      let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :          (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) =          star (OAI.CoarseAssembly.Analytic.cayleyDenominator F hF : A) * (↑(OAI.CoarseAssembly.Analytic.cayleyDenominator F hF)⁻¹ : A) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          rfl      local_proof), hci.mul_pow, mul_assoc,          ← (Commute.refl (b : A)).units_inv_left.mul_pow, Units.inv_mul, one_pow, mul_one]      simp only [OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary, Unitary.coe_neg, Submonoid.coe_mul]      rw [← pow_two]      rw [sub_mul, neg_mul, he, one_mul]      rw [OAI.CoarseAssembly.Analytic.cayleyDenominator_star, OAI.CoarseAssembly.Analytic.cayleyDenominator_val]      have hI : (algebraMap ℂ A Complex.I) ^ 2 = -1 := by        rw [← map_pow, Complex.I_sq, map_neg, map_one]      have hcI := Algebra.commutes (R := ℂ) (A := A) Complex.I F      have hI' : algebraMap ℂ A Complex.I * algebraMap ℂ A Complex.I = -1 := by        simpa only [pow_two] using hI      noncomm_ring [hcI, hI']      norm_num  have OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary_sub_one_mem {A : Type _} [inst_local_1 : CStarAlgebra A] (I : TwoSidedIdeal A)      (F : A) (hF : IsSelfAdjoint F) (hdefect : F ^ 2 - 1 ∈ I) :      (OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary F hF : A) - 1 ∈ I  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      let b := OAI.CoarseAssembly.Analytic.cayleyDenominator F hF      have h : ((OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary F hF : A) - 1) * (b : A) ^ 2 ∈ I := by        rw [OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary_defect]        exact I.mul_mem_left _ _ hdefect      have h' := I.mul_mem_right _ ((↑b⁻¹ : A) ^ 2) h      have hc : Commute (b : A) (↑b⁻¹ : A) := (Commute.refl (b : A)).units_inv_right      simpa only [mul_assoc, ← hc.mul_pow, Units.mul_inv, one_pow, mul_one] using h'  have OAI.CoarseAssembly.DiscreteRoe.multiplierBoundaryUnitary_sub_one_mem {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H]      (F : OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H)) (hF : IsSelfAdjoint F)      (hdefect : F.val ^ 2 - 1 ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)) :      (OAI.CoarseAssembly.DiscreteRoe.multiplierBoundaryUnitary F hF : OAI.CoarseAssembly.DiscreteRoe.Operator X H) - 1 ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      have hF' : F ^ 2 - 1 ∈ OAI.CoarseAssembly.DiscreteRoe.multiplierRoeIdeal (X := X) (H := H) := by        rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] (T : OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H)) :          T ∈ OAI.CoarseAssembly.DiscreteRoe.multiplierRoeIdeal (X := X) (H := H) ↔ T.val ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          TwoSidedIdeal.mem_mk' _ _ _ _ _ _ T      local_proof)]        simpa using hdefect      have h := OAI.CoarseAssembly.Analytic.rationalBoundaryUnitary_sub_one_mem        (OAI.CoarseAssembly.DiscreteRoe.multiplierRoeIdeal (X := X) (H := H)) F hF hF'      rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H] (T : OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := X) (H := H)) :          T ∈ OAI.CoarseAssembly.DiscreteRoe.multiplierRoeIdeal (X := X) (H := H) ↔ T.val ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          TwoSidedIdeal.mem_mk' _ _ _ _ _ _ T      local_proof)] at h      exact h  exact OAI.CoarseAssembly.OperatorKTheory.relativeClass (hS := (    let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in        open scoped Topology in        by          let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩          exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _    local_proof)) (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H))      (OAI.CoarseAssembly.DiscreteRoe.multiplierBoundaryUnitary F hF) (OAI.CoarseAssembly.DiscreteRoe.multiplierBoundaryUnitary_sub_one_mem F hF hdefect)end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)]  [∀ i, DecidableEq (V i)] {H : Type*}  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]variable (o : ∀ i, V i) (A : ∀ i, Operator (V i) H)  (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C)  (r : ℝ) (hr : 0 ≤ r) (hp : ∀ i, PropagationLE r (A i))def separatedFamilyMultiplier :    letI := OAI.CoarseAssembly.separatedMetric o    OAI.CoarseAssembly.DiscreteRoe.multiplierAlgebra (X := Sigma V) (H := H) := by  classical  have OAI.CoarseAssembly.DiscreteRoe.entry_star {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) :      OAI.CoarseAssembly.DiscreteRoe.entry (star T) x y = star (OAI.CoarseAssembly.DiscreteRoe.entry T y x) := by    have hI (z : X) : (OAI.CoarseAssembly.DiscreteRoe.insert (H := H) z).adjoint =        OAI.CoarseAssembly.DiscreteRoe.coordinate z := by      ext v      apply ext_inner_left ℂ      intro h      rw [ContinuousLinearMap.adjoint_inner_right]      change inner ℂ (lp.single 2 z h) v = inner ℂ h (v z)      exact lp.inner_single_left (𝕜 := ℂ) z h v    simp only [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.star_eq_adjoint,      ContinuousLinearMap.adjoint_comp]    rw [hI x, ← hI y, ContinuousLinearMap.adjoint_adjoint]    rfl  have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H}      (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (star T)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y hxy      rw [OAI.CoarseAssembly.DiscreteRoe.entry_star, hT y x (by simpa [dist_comm] using hxy), star_zero]  have OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (s : Finset X) (v : OAI.CoarseAssembly.DiscreteRoe.Module X H)      (hv : ∀ x, x ∉ s → v x = 0) :      v = ∑ x ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert x (v x)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      apply lp.ext      funext x      simp only [lp.coeFn_sum, Finset.sum_apply, (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), lp.coeFn_single]      rw [Finset.sum_pi_single]      by_cases hx : x ∈ s      · simp [hx]      · simp [hx, hv x hx]  have OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (s : Finset X)      (hs : ∀ z, z ∉ s → OAI.CoarseAssembly.DiscreteRoe.entry S z y = 0) :      OAI.CoarseAssembly.DiscreteRoe.entry (T * S) x y = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.entry T x z * OAI.CoarseAssembly.DiscreteRoe.entry S z y  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      ext h      have hv : S (OAI.CoarseAssembly.DiscreteRoe.insert y h) = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert z (OAI.CoarseAssembly.DiscreteRoe.entry S z y h) := by        apply OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum        intro z hz        have := DFunLike.congr_fun (hs z hz) h        simpa only [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) :          OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), zero_apply] using this      change OAI.CoarseAssembly.DiscreteRoe.coordinate x (T (S (OAI.CoarseAssembly.DiscreteRoe.insert y h))) = _      rw [hv, map_sum, map_sum]      simp only [sum_apply, mul_apply_eq_comp]      rfl  have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r s : ℝ} {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H}      (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) :      OAI.CoarseAssembly.DiscreteRoe.PropagationLE (r + s) (T * S)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y hxy      rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset        ((      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) :          ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            intro z hz            apply hT            simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz      local_proof) finiteBalls hS y)]      apply Finset.sum_eq_zero      intro z hz      have hzy : dist z y ≤ s := by        simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall] using hz      have hxz : r < dist x z := by        have htri := dist_triangle x z y        linarith      rw [hT x z hxz, zero_mul]  have OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {s : ℝ}      (hT : OAI.CoarseAssembly.DiscreteRoe.CompactEntries T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : OAI.CoarseAssembly.DiscreteRoe.CompactEntries (T * S)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y      rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset        ((      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) :          ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            intro z hz            apply hT            simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz      local_proof) finiteBalls hS y)]      apply (      let local_proof {H : Type _} [inst_local_1 : NormedAddCommGroup H] [inst_local_2 : InnerProductSpace ℂ H] {ι : Type _} (s : Finset ι) (A : ι → H →L[ℂ] H)          (hA : ∀ i ∈ s, IsCompactOperator (A i)) :          IsCompactOperator (∑ i ∈ s, A i : H →L[ℂ] H) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            exact (compactOperator (RingHom.id ℂ) H H).sum_mem hA      local_proof)      intro z _      exact (hT x z).comp_clm (OAI.CoarseAssembly.DiscreteRoe.entry S z y)  have OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_right {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {s : ℝ}      (hS : OAI.CoarseAssembly.DiscreteRoe.CompactEntries S) (hprop : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) : OAI.CoarseAssembly.DiscreteRoe.CompactEntries (T * S)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y      rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset        ((      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) :          ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            intro z hz            apply hT            simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz      local_proof) finiteBalls hprop y)]      apply (      let local_proof {H : Type _} [inst_local_1 : NormedAddCommGroup H] [inst_local_2 : InnerProductSpace ℂ H] {ι : Type _} (s : Finset ι) (A : ι → H →L[ℂ] H)          (hA : ∀ i ∈ s, IsCompactOperator (A i)) :          IsCompactOperator (∑ i ∈ s, A i : H →L[ℂ] H) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            exact (compactOperator (RingHom.id ℂ) H H).sum_mem hA      local_proof)      intro z _      exact (hS z y).clm_comp (OAI.CoarseAssembly.DiscreteRoe.entry T x z)  have OAI.CoarseAssembly.DiscreteRoe.finitePropagation_multiplier {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H]      (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite)      {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {r : ℝ} (hr : 0 ≤ r) (hp : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) : OAI.CoarseAssembly.DiscreteRoe.RoeMultiplier T  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩      have hprod (S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (hS : OAI.CoarseAssembly.DiscreteRoe.Generator S) :          T * S ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) ∧ S * T ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) := by        obtain ⟨⟨s, hs, hq⟩, hc, hcs⟩ := hS        constructor        · apply (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) :          T ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          (NonUnitalStarSubalgebra.le_topologicalClosure _)              (NonUnitalStarAlgebra.subset_adjoin ℂ _ hT)      local_proof)          refine ⟨⟨r + s, add_nonneg hr hs, (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul finiteBalls hp hq)⟩,            (OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_right finiteBalls hc hq), ?_⟩          rw [star_mul]          exact OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left finiteBalls hcs (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star hp)        · apply (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) :          T ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          (NonUnitalStarSubalgebra.le_topologicalClosure _)              (NonUnitalStarAlgebra.subset_adjoin ℂ _ hT)      local_proof)          refine ⟨⟨s + r, add_nonneg hs hr, (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul finiteBalls hq hp)⟩,            (OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_left finiteBalls hc hp), ?_⟩          rw [star_mul]          exact OAI.CoarseAssembly.DiscreteRoe.CompactEntries.mul_right finiteBalls hcs (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.star hq)      have hclosed : IsClosed {S : OAI.CoarseAssembly.DiscreteRoe.Operator X H |          T * S ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) ∧ S * T ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H)} :=        ((      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩            exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _      local_proof).preimage (continuous_const.mul continuous_id)).inter          ((      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] : IsClosed (OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) : Set (OAI.CoarseAssembly.DiscreteRoe.Operator X H)) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩            exact NonUnitalStarSubalgebra.isClosed_topologicalClosure _      local_proof).preimage (continuous_id.mul continuous_const))      intro S      have hm : S.val ∈ (OAI.CoarseAssembly.DiscreteRoe.algebraicRoe (H := H) finiteBalls).topologicalClosure := by        rw [← (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] [inst_local_6 : CompleteSpace H]          (finiteBalls : ∀ x : X, ∀ r : ℝ, (Metric.closedBall x r).Finite)  [ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H)] :          OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) = (OAI.CoarseAssembly.DiscreteRoe.algebraicRoe (H := H) finiteBalls).topologicalClosure :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            let : ContinuousStar (OAI.CoarseAssembly.DiscreteRoe.Operator X H) := ⟨(ContinuousLinearMap.adjoint : OAI.CoarseAssembly.DiscreteRoe.Operator X H ≃ₗᵢ⋆[ℂ] OAI.CoarseAssembly.DiscreteRoe.Operator X H).continuous⟩            have he : NonUnitalStarAlgebra.adjoin ℂ {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H | OAI.CoarseAssembly.DiscreteRoe.Generator T} =                OAI.CoarseAssembly.DiscreteRoe.algebraicRoe (H := H) finiteBalls := by              apply le_antisymm              · exact NonUnitalStarAlgebra.adjoin_le (fun _ h => h)              · intro T hT                exact NonUnitalStarAlgebra.subset_adjoin ℂ _ hT            unfold OAI.CoarseAssembly.DiscreteRoe.algebra            rw [he]      local_proof) finiteBalls]        exact S.property      exact closure_minimal hprod hclosed hm  have OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_same {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)      (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (i : ℕ) (x y : V i) :      OAI.CoarseAssembly.DiscreteRoe.entry (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) ⟨i, x⟩ ⟨i, y⟩ = OAI.CoarseAssembly.DiscreteRoe.entry (A i) x y  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      ext v      simp only [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) :          OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), (      let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C)          (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) (x : V i) :          OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v ⟨i, x⟩ = A i (OAI.CoarseAssembly.rowVector v i) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          rfl      local_proof), (      let local_proof {I : Type _} {Q : I → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : DecidableEq I] [inst_local_5 : (i : I) → DecidableEq (Q i)] (i : I) (q : Q i) (h : H) :          OAI.CoarseAssembly.rowVector (lp.single 2 ⟨i, q⟩ h) i = lp.single 2 q h :=        open OAI OAI.CoarseAssembly in          by            apply lp.ext            funext r            change lp.single (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h ⟨i, r⟩ =              lp.single (E := fun _ : Q i => H) 2 q h r            by_cases hr : r = q            · subst r; simp            · have hn : (⟨i, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := by                intro he                cases he                exact hr rfl              simp [hr, hn]      local_proof)]  have OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_ne {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)      (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) {i j : ℕ} (hij : i ≠ j)      (x : V i) (y : V j) :      OAI.CoarseAssembly.DiscreteRoe.entry (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) ⟨i, x⟩ ⟨j, y⟩ = 0  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      ext v      simp only [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) :          OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), (      let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C)          (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) (x : V i) :          OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v ⟨i, x⟩ = A i (OAI.CoarseAssembly.rowVector v i) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          rfl      local_proof), (      let local_proof {I : Type _} {Q : I → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : DecidableEq I] [inst_local_5 : (i : I) → DecidableEq (Q i)] {i j : I} (hji : j ≠ i) (q : Q i) (h : H) :          OAI.CoarseAssembly.rowVector (lp.single 2 ⟨i, q⟩ h) j = 0 :=        open OAI OAI.CoarseAssembly in          by            apply lp.ext            funext r            have hn : (⟨j, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := fun he => hji (congrArg Sigma.fst he)            change lp.single (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h ⟨j, r⟩ = 0            exact lp.single_apply_ne (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h hn      local_proof) hij, map_zero,        lp.coeFn_zero, Pi.zero_apply, zero_apply]  have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_propagation {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : (i : ℕ) → MetricSpace (V i)] (o : (i : ℕ) → V i) (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)      (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (r : ℝ)      (hp : ∀ i, OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (A i)) :      letI := OAI.CoarseAssembly.separatedMetric o      OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      let := OAI.CoarseAssembly.separatedMetric o      rintro ⟨i, x⟩ ⟨j, y⟩ hxy      by_cases hij : i = j      · subst j        rw [OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_same]        apply hp i x y        simpa only [show dist (⟨i, x⟩ : Sigma V) ⟨i, y⟩ = dist x y from          (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof) o i x y] using hxy      · exact OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_ne A C hC hA hij x y  have OAI.CoarseAssembly.separatedDist_indices {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (x y : Sigma V) (hxy : x.1 ≠ y.1)      {R : ℝ} (hR : OAI.CoarseAssembly.separatedDist o x y ≤ R) : (x.1 : ℝ) ≤ R ∧ (y.1 : ℝ) ≤ R  :=    open OAI OAI.CoarseAssembly in    by      rcases x with ⟨i, x⟩      rcases y with ⟨j, y⟩      rw [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hxy] at hR      have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i      have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j      constructor <;> linarith [dist_nonneg (x := x) (y := o i), dist_nonneg (x := o j) (y := y)]  have OAI.CoarseAssembly.separated_closedBall_finite {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] [inst_local_2 : (j : ℕ) → Fintype (V j)] [∀ j, Fintype (V j)]      (o : ∀ j, V j) (x : Sigma V) (r : ℝ) :      letI := OAI.CoarseAssembly.separatedMetric o      Set.Finite {y : Sigma V | dist x y ≤ r}  :=    open OAI OAI.CoarseAssembly in    open Topology Rips in    by      classical      let := OAI.CoarseAssembly.separatedMetric o      let m := max (x.1 + 1) (⌈r⌉₊ + 1)      let s : Finset (Sigma V) := (Finset.range m).sigma (fun _ => Finset.univ)      apply s.finite_toSet.subset      intro y hy      have hm : y.1 < m := by        by_cases hxy : x.1 = y.1        · dsimp [m]          omega        · have hb := (OAI.CoarseAssembly.separatedDist_indices o x y hxy hy).2          have hc : y.1 ≤ ⌈r⌉₊ := by exact_mod_cast hb.trans (Nat.le_ceil r)          dsimp [m]          omega      exact Finset.mem_sigma.mpr ⟨Finset.mem_range.mpr hm, Finset.mem_univ _⟩  have OAI.CoarseAssembly.DiscreteRoe.separatedMetric_closedBall_finite {V : ℕ → Type} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] [inst_local_2 : (i : ℕ) → Fintype (V i)] (o : ∀ i, V i) (x : Sigma V) (r : ℝ) :      letI := OAI.CoarseAssembly.separatedMetric o      (Metric.closedBall x r).Finite  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      let := OAI.CoarseAssembly.separatedMetric o      simpa only [Metric.closedBall, dist_comm] using OAI.CoarseAssembly.separated_closedBall_finite o x r  let := OAI.CoarseAssembly.separatedMetric o  exact ⟨OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA,    OAI.CoarseAssembly.DiscreteRoe.finitePropagation_multiplier (OAI.CoarseAssembly.DiscreteRoe.separatedMetric_closedBall_finite o) hr      (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_propagation o A C hC hA r hp)⟩-- The self-contained construction includes its support proofs.def separatedFamilyBoundary (hself : ∀ i, IsSelfAdjoint (A i))    (hsq : ∀ i, IsCompactOperator ((A i * A i - (1 : OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)).toFun)) :    letI := OAI.CoarseAssembly.separatedMetric o    OAI.CoarseAssembly.OperatorKTheory.K1 (OAI.CoarseAssembly.DiscreteRoe.algebra (X := Sigma V) (H := H)) := by  classical  have OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (s : Finset X) (v : OAI.CoarseAssembly.DiscreteRoe.Module X H)      (hv : ∀ x, x ∉ s → v x = 0) :      v = ∑ x ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert x (v x)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      apply lp.ext      funext x      simp only [lp.coeFn_sum, Finset.sum_apply, (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), lp.coeFn_single]      rw [Finset.sum_pi_single]      by_cases hx : x ∈ s      · simp [hx]      · simp [hx, hv x hx]  have OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (s : Finset X)      (hs : ∀ z, z ∉ s → OAI.CoarseAssembly.DiscreteRoe.entry S z y = 0) :      OAI.CoarseAssembly.DiscreteRoe.entry (T * S) x y = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.entry T x z * OAI.CoarseAssembly.DiscreteRoe.entry S z y  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      ext h      have hv : S (OAI.CoarseAssembly.DiscreteRoe.insert y h) = ∑ z ∈ s, OAI.CoarseAssembly.DiscreteRoe.insert z (OAI.CoarseAssembly.DiscreteRoe.entry S z y h) := by        apply OAI.CoarseAssembly.DiscreteRoe.vector_eq_sum        intro z hz        have := DFunLike.congr_fun (hs z hz) h        simpa only [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) :          OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (x : X) (h : H) : OAI.CoarseAssembly.DiscreteRoe.insert x h = lp.single 2 x h :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), zero_apply] using this      change OAI.CoarseAssembly.DiscreteRoe.coordinate x (T (S (OAI.CoarseAssembly.DiscreteRoe.insert y h))) = _      rw [hv, map_sum, map_sum]      simp only [sum_apply, mul_apply_eq_comp]      rfl  have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r s : ℝ} {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H}      (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) :      OAI.CoarseAssembly.DiscreteRoe.PropagationLE (r + s) (T * S)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y hxy      rw [OAI.CoarseAssembly.DiscreteRoe.entry_mul_of_finite_column T S x y (finiteBalls y s).toFinset        ((      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : PseudoMetricSpace X] (finiteBalls : ∀ (x : X) (r : ℝ), Set.Finite (Metric.closedBall x r)) {r : ℝ} {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (y : X) :          ∀ z, z ∉ (finiteBalls y r).toFinset → OAI.CoarseAssembly.DiscreteRoe.entry T z y = 0 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            intro z hz            apply hT            simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall, not_le] using hz      local_proof) finiteBalls hS y)]      apply Finset.sum_eq_zero      intro z hz      have hzy : dist z y ≤ s := by        simpa only [Set.Finite.mem_toFinset, Metric.mem_closedBall] using hz      have hxz : r < dist x z := by        have htri := dist_triangle x z y        linarith      rw [hT x z hxz, zero_mul]  have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.add {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] {T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {r s : ℝ}      (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (hS : OAI.CoarseAssembly.DiscreteRoe.PropagationLE s S) :      OAI.CoarseAssembly.DiscreteRoe.PropagationLE (max r s) (T + S)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y hxy      rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T S : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) :          OAI.CoarseAssembly.DiscreteRoe.entry (T + S) x y = OAI.CoarseAssembly.DiscreteRoe.entry T x y + OAI.CoarseAssembly.DiscreteRoe.entry S x y :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            ext h            simp [OAI.CoarseAssembly.DiscreteRoe.entry, ContinuousLinearMap.comp_add, ContinuousLinearMap.add_comp]      local_proof), hT x y (lt_of_le_of_lt (le_max_left _ _) hxy),        hS x y (lt_of_le_of_lt (le_max_right _ _) hxy), add_zero]  have OAI.CoarseAssembly.DiscreteRoe.PropagationLE.smul {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} {r : ℝ}      (hT : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r T) (z : ℂ) : OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (z • T)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y hxy      rw [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (c : ℂ) (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) :          OAI.CoarseAssembly.DiscreteRoe.entry (c • T) x y = c • OAI.CoarseAssembly.DiscreteRoe.entry T x y :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          by            ext h            simp [OAI.CoarseAssembly.DiscreteRoe.entry]      local_proof), hT x y hxy, smul_zero]  have OAI.CoarseAssembly.DiscreteRoe.propagationLE_one {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : PseudoMetricSpace X] [inst_local_4 : NormedAddCommGroup H] [inst_local_5 : InnerProductSpace ℂ H] : OAI.CoarseAssembly.DiscreteRoe.PropagationLE 0 (1 : OAI.CoarseAssembly.DiscreteRoe.Operator X H)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      intro x y hxy      have hne : x ≠ y := by intro h; simp [h] at hxy      ext v      simp [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) :          OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), lp.single_apply, hne]  have OAI.CoarseAssembly.blockOperator_adjoint {I : Type _} {E : I → Type _} {F : I → Type _} [inst_local_3 : (i : I) → NormedAddCommGroup (E i)] [inst_local_4 : (i : I) → InnerProductSpace ℂ (E i)] [inst_local_5 : ∀ (i : I), CompleteSpace (E i)] [inst_local_6 : (i : I) → NormedAddCommGroup (F i)] [inst_local_7 : (i : I) → InnerProductSpace ℂ (F i)] [inst_local_8 : ∀ (i : I), CompleteSpace (F i)] (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C)      (hA : ∀ i, ‖A i‖ ≤ C) :      (OAI.CoarseAssembly.blockOperator A C hC hA).adjoint =        OAI.CoarseAssembly.blockOperator (fun i => (A i).adjoint) C hC          (fun i => (LinearIsometryEquiv.norm_map ContinuousLinearMap.adjoint _).trans_le (hA i))  :=    open OAI OAI.CoarseAssembly in    open scoped Topology in    by      symm      apply (ContinuousLinearMap.eq_adjoint_iff _ _).mpr      intro x y      simp only [lp.inner_eq_tsum, (      let local_proof {ι : Type _} {E : ι → Type _} {F : ι → Type _} [inst_local_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_local_4 : (i : ι) → NormedSpace ℂ (E i)] [inst_local_5 : (i : ι) → NormedAddCommGroup (F i)] [inst_local_6 : (i : ι) → NormedSpace ℂ (F i)] (A : ∀ i, E i →L[ℂ] F i) (C : ℝ) (hC : 0 ≤ C)          (hA : ∀ i, ‖A i‖ ≤ C) (x : lp E 2) (i : ι) :          OAI.CoarseAssembly.blockOperator A C hC hA x i = A i (x i) :=        open OAI OAI.CoarseAssembly in          open Filter in          open scoped Topology in          rfl      local_proof)]      exact tsum_congr (fun i => ContinuousLinearMap.adjoint_inner_left (A i) (y i) (x i))  have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_selfAdjoint {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : CompleteSpace H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)      (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (hself : ∀ i, IsSelfAdjoint (A i)) :      IsSelfAdjoint (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      have hb : IsSelfAdjoint (OAI.CoarseAssembly.blockOperator A C hC hA) := by        change (OAI.CoarseAssembly.blockOperator A C hC hA).adjoint = _        rw [OAI.CoarseAssembly.blockOperator_adjoint]        apply ContinuousLinearMap.ext        intro v        apply lp.ext        funext i        change (A i).adjoint (v i) = A i (v i)        have hi : (A i).adjoint = A i := (hself i).star_eq        exact DFunLike.congr_fun hi (v i)      rw [OAI.CoarseAssembly.DiscreteRoe.diagonalFamily, (      let local_proof {I : Type _} {Q : I → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H]          (A : lp (fun i => lp (fun _ : Q i => H) 2) 2 →L[ℂ]          lp (fun i => lp (fun _ : Q i => H) 2) 2) :          OAI.CoarseAssembly.flattenOperator A = OAI.CoarseAssembly.operatorConjugation          (OAI.CoarseAssembly.flattenEquiv (Q := Q) (H := H)).toLinearIsometry A :=        open OAI OAI.CoarseAssembly in          open scoped Topology in          by            let e := OAI.CoarseAssembly.flattenEquiv (Q := Q) (H := H)            have he : e.toLinearIsometry.toContinuousLinearMap.adjoint =                e.symm.toLinearIsometry.toContinuousLinearMap := e.adjoint_eq_symm            unfold OAI.CoarseAssembly.flattenOperator OAI.CoarseAssembly.operatorConjugation            rw [he]      local_proof)]      exact hb.map (OAI.CoarseAssembly.operatorConjugationHom (OAI.CoarseAssembly.flattenEquiv (Q := V) (H := H)).toLinearIsometry)  have OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_same {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)      (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (i : ℕ) (x y : V i) :      OAI.CoarseAssembly.DiscreteRoe.entry (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) ⟨i, x⟩ ⟨i, y⟩ = OAI.CoarseAssembly.DiscreteRoe.entry (A i) x y  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      ext v      simp only [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) :          OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), (      let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C)          (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) (x : V i) :          OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v ⟨i, x⟩ = A i (OAI.CoarseAssembly.rowVector v i) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          rfl      local_proof), (      let local_proof {I : Type _} {Q : I → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : DecidableEq I] [inst_local_5 : (i : I) → DecidableEq (Q i)] (i : I) (q : Q i) (h : H) :          OAI.CoarseAssembly.rowVector (lp.single 2 ⟨i, q⟩ h) i = lp.single 2 q h :=        open OAI OAI.CoarseAssembly in          by            apply lp.ext            funext r            change lp.single (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h ⟨i, r⟩ =              lp.single (E := fun _ : Q i => H) 2 q h r            by_cases hr : r = q            · subst r; simp            · have hn : (⟨i, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := by                intro he                cases he                exact hr rfl              simp [hr, hn]      local_proof)]  have OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_ne {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)      (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) {i j : ℕ} (hij : i ≠ j)      (x : V i) (y : V j) :      OAI.CoarseAssembly.DiscreteRoe.entry (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) ⟨i, x⟩ ⟨j, y⟩ = 0  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      ext v      simp only [(      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] (T : OAI.CoarseAssembly.DiscreteRoe.Operator X H) (x y : X) (h : H) :          OAI.CoarseAssembly.DiscreteRoe.entry T x y h = T (lp.single 2 y h) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          rfl      local_proof), (      let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C)          (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) (x : V i) :          OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v ⟨i, x⟩ = A i (OAI.CoarseAssembly.rowVector v i) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          rfl      local_proof), (      let local_proof {I : Type _} {Q : I → Type _} {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : DecidableEq I] [inst_local_5 : (i : I) → DecidableEq (Q i)] {i j : I} (hji : j ≠ i) (q : Q i) (h : H) :          OAI.CoarseAssembly.rowVector (lp.single 2 ⟨i, q⟩ h) j = 0 :=        open OAI OAI.CoarseAssembly in          by            apply lp.ext            funext r            have hn : (⟨j, r⟩ : Sigma Q) ≠ ⟨i, q⟩ := fun he => hji (congrArg Sigma.fst he)            change lp.single (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h ⟨j, r⟩ = 0            exact lp.single_apply_ne (E := fun _ : Sigma Q => H) 2 ⟨i, q⟩ h hn      local_proof) hij, map_zero,        lp.coeFn_zero, Pi.zero_apply, zero_apply]  have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_propagation {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : (i : ℕ) → MetricSpace (V i)] (o : (i : ℕ) → V i) (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)      (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) (r : ℝ)      (hp : ∀ i, OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (A i)) :      letI := OAI.CoarseAssembly.separatedMetric o      OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      let := OAI.CoarseAssembly.separatedMetric o      rintro ⟨i, x⟩ ⟨j, y⟩ hxy      by_cases hij : i = j      · subst j        rw [OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_same]        apply hp i x y        simpa only [show dist (⟨i, x⟩ : Sigma V) ⟨i, y⟩ = dist x y from          (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof) o i x y] using hxy      · exact OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_ne A C hC hA hij x y  have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_defect {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : CompleteSpace H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)      (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C) :      OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA * OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA - 1 =        OAI.CoarseAssembly.DiscreteRoe.diagonalFamily (fun i => A i * A i - 1) (C * C + 1) (by positivity)          (fun i => (    let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : CompleteSpace H] (A : OAI.CoarseAssembly.DiscreteRoe.Operator (V 0) H) (C : ℝ) (hC : 0 ≤ C)        (hA : ‖A‖ ≤ C) : ‖A * A - 1‖ ≤ C * C + 1 :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in        by          calc            ‖A * A - 1‖ ≤ ‖A * A‖ + ‖(1 : OAI.CoarseAssembly.DiscreteRoe.Operator (V 0) H)‖ := norm_sub_le _ _            _ ≤ (‖A‖ * ‖A‖) + 1 := add_le_add (norm_mul_le _ _) ContinuousLinearMap.norm_id_le            _ ≤ C * C + 1 := by gcongr    @local_proof) (V := fun _ => V i) (A i) C hC (hA i))  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      apply ContinuousLinearMap.ext      intro v      apply lp.ext      funext z      rcases z with ⟨i, x⟩      simp only [sub_apply, mul_apply_eq_comp, one_apply_eq_self, lp.coeFn_sub, Pi.sub_apply,        (      let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C)          (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) (x : V i) :          OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v ⟨i, x⟩ = A i (OAI.CoarseAssembly.rowVector v i) x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          rfl      local_proof), (      let local_proof {V : ℕ → Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : 0 ≤ C)          (hA : ∀ i, ‖A i‖ ≤ C) (v : OAI.CoarseAssembly.DiscreteRoe.Module (Sigma V) H) (i : ℕ) :          OAI.CoarseAssembly.rowVector (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA v) i = A i (OAI.CoarseAssembly.rowVector v i) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          by            apply lp.ext            rfl      local_proof)]      rfl  have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_compactEntries {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] [inst_local_5 : CompleteSpace H] (A : ∀ i, OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)      (C : ℝ) (hC : 0 ≤ C) (hA : ∀ i, ‖A i‖ ≤ C)      (hsq : ∀ i, IsCompactOperator ((A i * A i - (1 : OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)).toFun)) :      OAI.CoarseAssembly.DiscreteRoe.CompactEntries (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA * OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA - 1)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      rw [OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_defect]      rintro ⟨i, x⟩ ⟨j, y⟩      by_cases hij : i = j      · subst j        rw [OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_same]        exact (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : DecidableEq X] [inst_local_3 : NormedAddCommGroup H] [inst_local_4 : InnerProductSpace ℂ H] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : IsCompactOperator T) :          OAI.CoarseAssembly.DiscreteRoe.CompactEntries T :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          fun x y => (hT.comp_clm (OAI.CoarseAssembly.DiscreteRoe.insert y)).clm_comp (OAI.CoarseAssembly.DiscreteRoe.coordinate x)      local_proof) (hsq i) x y      · rw [OAI.CoarseAssembly.DiscreteRoe.entry_diagonalFamily_ne _ _ _ _ hij]        exact isCompactOperator_zero  have OAI.CoarseAssembly.separatedDist_indices {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (x y : Sigma V) (hxy : x.1 ≠ y.1)      {R : ℝ} (hR : OAI.CoarseAssembly.separatedDist o x y ≤ R) : (x.1 : ℝ) ≤ R ∧ (y.1 : ℝ) ≤ R  :=    open OAI OAI.CoarseAssembly in    by      rcases x with ⟨i, x⟩      rcases y with ⟨j, y⟩      rw [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hxy] at hR      have hi : (0 : ℝ) ≤ i := Nat.cast_nonneg i      have hj : (0 : ℝ) ≤ j := Nat.cast_nonneg j      constructor <;> linarith [dist_nonneg (x := x) (y := o i), dist_nonneg (x := o j) (y := y)]  have OAI.CoarseAssembly.separated_closedBall_finite {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] [inst_local_2 : (j : ℕ) → Fintype (V j)] [∀ j, Fintype (V j)]      (o : ∀ j, V j) (x : Sigma V) (r : ℝ) :      letI := OAI.CoarseAssembly.separatedMetric o      Set.Finite {y : Sigma V | dist x y ≤ r}  :=    open OAI OAI.CoarseAssembly in    open Topology Rips in    by      classical      let := OAI.CoarseAssembly.separatedMetric o      let m := max (x.1 + 1) (⌈r⌉₊ + 1)      let s : Finset (Sigma V) := (Finset.range m).sigma (fun _ => Finset.univ)      apply s.finite_toSet.subset      intro y hy      have hm : y.1 < m := by        by_cases hxy : x.1 = y.1        · dsimp [m]          omega        · have hb := (OAI.CoarseAssembly.separatedDist_indices o x y hxy hy).2          have hc : y.1 ≤ ⌈r⌉₊ := by exact_mod_cast hb.trans (Nat.le_ceil r)          dsimp [m]          omega      exact Finset.mem_sigma.mpr ⟨Finset.mem_range.mpr hm, Finset.mem_univ _⟩  have OAI.CoarseAssembly.DiscreteRoe.separatedMetric_closedBall_finite {V : ℕ → Type} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] [inst_local_2 : (i : ℕ) → Fintype (V i)] (o : ∀ i, V i) (x : Sigma V) (r : ℝ) :      letI := OAI.CoarseAssembly.separatedMetric o      (Metric.closedBall x r).Finite  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      let := OAI.CoarseAssembly.separatedMetric o      simpa only [Metric.closedBall, dist_comm] using OAI.CoarseAssembly.separated_closedBall_finite o x r  have OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_mem_roe {V : ℕ → Type} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] [inst_local_2 : (i : ℕ) → Fintype (V i)] [inst_local_3 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_5 : NormedAddCommGroup H] [inst_local_6 : InnerProductSpace ℂ H] [inst_local_7 : CompleteSpace H] (o : (i : ℕ) → V i) (A : (i : ℕ) → OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : LE.le 0 C) (hA : ∀ (i : ℕ), LE.le (Norm.norm (A i)) C) (r : ℝ) (hr : LE.le 0 r) (hp : ∀ (i : ℕ), OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (A i)) (hself : ∀ i, IsSelfAdjoint (A i))      (hsq : ∀ i, IsCompactOperator ((A i * A i - (1 : OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H)).toFun)) :      letI := OAI.CoarseAssembly.separatedMetric o      (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA) ^ 2 - 1 ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := Sigma V) (H := H)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      let := OAI.CoarseAssembly.separatedMetric o      have hT := OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_propagation o A C hC hA r hp      have hdef : OAI.CoarseAssembly.DiscreteRoe.PropagationLE (r + r) (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA ^ 2 - 1) := by        have hm := OAI.CoarseAssembly.DiscreteRoe.PropagationLE.mul (OAI.CoarseAssembly.DiscreteRoe.separatedMetric_closedBall_finite o) hT hT        have hn := OAI.CoarseAssembly.DiscreteRoe.PropagationLE.smul (OAI.CoarseAssembly.DiscreteRoe.propagationLE_one (X := Sigma V) (H := H)) (-1 : ℂ)        have hh := (OAI.CoarseAssembly.DiscreteRoe.PropagationLE.add hm hn)        have he : (-1 : ℂ) • (1 : OAI.CoarseAssembly.DiscreteRoe.Operator (Sigma V) H) = -(1 : OAI.CoarseAssembly.DiscreteRoe.Operator (Sigma V) H) := by          ext v          simp        rw [he] at hh        simpa only [pow_two, sub_eq_add_neg,          max_eq_left (add_nonneg hr hr)] using hh      have hc : OAI.CoarseAssembly.DiscreteRoe.CompactEntries (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA ^ 2 - 1) := by        simpa only [pow_two] using OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_compactEntries A C hC hA hsq      have hs : IsSelfAdjoint (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily A C hC hA ^ 2 - 1) := by        have hs' := (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_selfAdjoint A C hC hA hself).pow 2        have hi : IsSelfAdjoint (1 : OAI.CoarseAssembly.DiscreteRoe.Operator (Sigma V) H) := IsSelfAdjoint.one _        exact @IsSelfAdjoint.sub (OAI.CoarseAssembly.DiscreteRoe.Operator (Sigma V) H) inferInstance inferInstance _ _ hs' hi      exact (      let local_proof {X : Type _} {H : Type _} [inst_local_2 : NormedAddCommGroup H] [inst_local_3 : InnerProductSpace ℂ H] [inst_local_4 : DecidableEq X] [inst_local_5 : CompleteSpace H] [inst_local_6 : PseudoMetricSpace X] {T : OAI.CoarseAssembly.DiscreteRoe.Operator X H} (hT : OAI.CoarseAssembly.DiscreteRoe.Generator T) :          T ∈ OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in          open scoped Topology in          (NonUnitalStarSubalgebra.le_topologicalClosure _)              (NonUnitalStarAlgebra.subset_adjoin ℂ _ hT)      local_proof) ⟨⟨r + r, add_nonneg hr hr, hdef⟩, hc, by rwa [hs.star_eq]⟩  have OAI.CoarseAssembly.DiscreteRoe.separatedFamilyMultiplier_selfAdjoint {V : ℕ → Type} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] [inst_local_2 : (i : ℕ) → Fintype (V i)] [inst_local_3 : (i : ℕ) → DecidableEq (V i)] {H : Type _} [inst_local_5 : NormedAddCommGroup H] [inst_local_6 : InnerProductSpace ℂ H] [inst_local_7 : CompleteSpace H] (o : (i : ℕ) → V i) (A : (i : ℕ) → OAI.CoarseAssembly.DiscreteRoe.Operator (V i) H) (C : ℝ) (hC : LE.le 0 C) (hA : ∀ (i : ℕ), LE.le (Norm.norm (A i)) C) (r : ℝ) (hr : LE.le 0 r) (hp : ∀ (i : ℕ), OAI.CoarseAssembly.DiscreteRoe.PropagationLE r (A i)) (hself : ∀ i, IsSelfAdjoint (A i)) :      letI := OAI.CoarseAssembly.separatedMetric o      IsSelfAdjoint (OAI.CoarseAssembly.DiscreteRoe.separatedFamilyMultiplier o A C hC hA r hr hp)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.DiscreteRoe in    by      let := OAI.CoarseAssembly.separatedMetric o      apply Subtype.ext      exact (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_selfAdjoint A C hC hA hself).star_eq  let := OAI.CoarseAssembly.separatedMetric o  exact OAI.CoarseAssembly.DiscreteRoe.multiplierBoundaryClass (OAI.CoarseAssembly.DiscreteRoe.separatedFamilyMultiplier o A C hC hA r hr hp)    (OAI.CoarseAssembly.DiscreteRoe.separatedFamilyMultiplier_selfAdjoint o A C hC hA r hr hp hself)    (OAI.CoarseAssembly.DiscreteRoe.diagonalFamily_square_mem_roe o A C hC hA r hr hp hself hsq)end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {X H : Type*} [Fintype X] [DecidableEq X]  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]def partitionConjugate (a : X → H →L[ℂ] H) (F : H →L[ℂ] H) : Operator X H :=  (partitionMap a).comp (F.comp (partitionMap a).adjoint)variable [PseudoMetricSpace X]end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoevariable {X H : Type*} [Fintype X] [DecidableEq X]  [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]attribute [local instance] spatialLocalizationContinuousAdd spatialLocalizationRingHomCompTriple  spatialLocalizationCompleteSpacevariable [PseudoMetricSpace X]end CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type} [NonUnitalCStarAlgebra A] {ι : Type*} [Fintype ι]def localizedOperator (c : OddCycle A) (a : ι → A) : End c.space :=  ∑ i, c.representation (a i) * c.operator * c.representation (a i)def localizedCycle (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : ι → A)    (hF : IsSelfAdjoint c.operator) (ha : ∀ i, IsSelfAdjoint (a i))    (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) : OAI.CoarseAssembly.Analytic.OddCycle A := by  classical  have OAI.CoarseAssembly.Analytic.localizedOperator_sub_compact {A : Type} [inst_local_1 : NonUnitalCStarAlgebra A] {ι : Type _} [inst_local_3 : Fintype ι] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : ι → A)      (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) :      IsCompactOperator (OAI.CoarseAssembly.Analytic.localizedOperator c a - c.operator)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [(      let local_proof {A : Type} [inst_local_1 : NonUnitalCStarAlgebra A] {ι : Type _} [inst_local_3 : Fintype ι] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : ι → A)          (hpart : ∑ i, c.representation (a i) * c.representation (a i) = 1) :          OAI.CoarseAssembly.Analytic.localizedOperator c a - c.operator =          ∑ i, c.representation (a i) *          (c.operator * c.representation (a i) - c.representation (a i) * c.operator) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            calc              OAI.CoarseAssembly.Analytic.localizedOperator c a - c.operator = OAI.CoarseAssembly.Analytic.localizedOperator c a -                  (∑ i, c.representation (a i) * c.representation (a i)) * c.operator := by                rw [hpart, one_mul]              _ = ∑ i, (c.representation (a i) * c.operator * c.representation (a i) -                  (c.representation (a i) * c.representation (a i)) * c.operator) := by                rw [OAI.CoarseAssembly.Analytic.localizedOperator, Finset.sum_mul, ← Finset.sum_sub_distrib]              _ = _ := by                apply Finset.sum_congr rfl                intro i _                noncomm_ring      local_proof) c a hpart]      exact (compactOperator (RingHom.id ℂ) c.space c.space).sum_mem        (fun i _ => (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} {K : OAI.CoarseAssembly.Analytic.End H} (hK : IsCompactOperator K) (T : OAI.CoarseAssembly.Analytic.End H) :          IsCompactOperator (T * K) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          hK.clm_comp T      local_proof) (c.commutator_compact (a i)) _)  exact c.compactPerturb (OAI.CoarseAssembly.Analytic.localizedOperator c a - c.operator)      (OAI.CoarseAssembly.Analytic.localizedOperator_sub_compact c a hpart) (by        rw [(((    let local_proof {A : Type} [inst_local_1 : NonUnitalCStarAlgebra A] {ι : Type _} [inst_local_3 : Fintype ι] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (a : ι → A)        (hF : IsSelfAdjoint c.operator) (ha : ∀ i, IsSelfAdjoint (a i)) :        IsSelfAdjoint (OAI.CoarseAssembly.Analytic.localizedOperator c a) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in        isSelfAdjoint_sum _ (fun i _ => hF.conjugate_self ((ha i).map c.representation))    local_proof) c a hF ha).sub hF).star_eq]        exact OAI.CoarseAssembly.Analytic.localizedOperator_sub_compact c a hpart)end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen Analytic DiscreteRoevariable {X : Type} [PseudoMetricSpace X] [Fintype X] [DecidableEq X]def ampleRipsOperator (r : ℝ) (c : OddCycle C(Point X r, ℂ))    (hπ : c.representation 1 = 1) : Operator X (lp (fun _ : ℕ => ℂ) 2) :=  coefficientExtension (ampleIsometry c.space) (ripsSpatialOperator r c hπ)variable {V : ℕ → Type} [∀ i, MetricSpace (V i)] [∀ i, Fintype (V i)]  [∀ i, DecidableEq (V i)]-- The self-contained construction includes its support proofs.def ampleRipsFamilyBoundary (o : ∀ i, V i) (r : ℝ) (hr : 0 ≤ r)    (c : ∀ i, OAI.CoarseAssembly.Analytic.OddCycle C(OAI.CoarseAssembly.Rips.Point (V i) r, ℂ)) (hπ : ∀ i, (c i).representation 1 = 1)    (hF : ∀ i, IsSelfAdjoint (c i).operator)    (C : ℝ) (hC : 0 ≤ C) (hnorm : ∀ i, ‖(c i).operator‖ ≤ C) :    letI := OAI.CoarseAssembly.separatedMetric o    OAI.CoarseAssembly.OperatorKTheory.K1 (OAI.CoarseAssembly.DiscreteRoe.algebra (X := Sigma V) (H := lp (fun _ : ℕ => ℂ) 2)) := by  classical  have extensionProperties {E H : Type} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]      [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]      (W : E →ₗᵢ[ℂ] H) (T : E →L[ℂ] E) (hTs : IsSelfAdjoint T)      (hTc : IsCompactOperator (T * T - (1 : E →L[ℂ] E))) :      let A := isometricExtension W T      ‖A‖ ≤ ‖T‖ + 2 ∧ IsSelfAdjoint A ∧ IsCompactOperator (A * A - (1 : H →L[ℂ] H)) := by    intro A    let q := operatorConjugationHom W    have h1 : ‖(1 : E →L[ℂ] E)‖ ≤ 1 := ContinuousLinearMap.norm_id_le    have hd : ‖T - 1‖ ≤ ‖T‖ + 1 := (norm_sub_le _ _).trans (add_le_add le_rfl h1)    have hq : ‖q (T - 1)‖ ≤ ‖T - 1‖ := NonUnitalStarAlgHom.norm_apply_le q (T - 1)    have hn : ‖A‖ ≤ ‖T‖ + 2 := by      change ‖1 + q (T - 1)‖ ≤ ‖T‖ + 2      calc        ‖1 + q (T - 1)‖ ≤ ‖(1 : H →L[ℂ] H)‖ + ‖q (T - 1)‖ := norm_add_le _ _        _ ≤ 1 + (‖T‖ + 1) := add_le_add ContinuousLinearMap.norm_id_le (hq.trans hd)        _ = ‖T‖ + 2 := by ring    have hs : IsSelfAdjoint A := (IsSelfAdjoint.one (H →L[ℂ] H)).add      ((hTs.sub (IsSelfAdjoint.one (E →L[ℂ] E))).map q)    have hpoly : (T - 1) * (T - 1) + (T - 1) + (T - 1) = T * T - 1 := by noncomm_ring    have heq : A * A - 1 = operatorConjugation W (T * T - 1) := calc      A * A - 1 = q (T - 1) * q (T - 1) + q (T - 1) + q (T - 1) := by        change (1 + q (T - 1)) * (1 + q (T - 1)) - 1 = _        noncomm_ring      _ = q ((T - 1) * (T - 1) + (T - 1) + (T - 1)) := by rw [map_add, map_add, map_mul]      _ = q (T * T - 1) := congrArg q hpoly      _ = operatorConjugation W (T * T - 1) := rfl    have hc : IsCompactOperator (operatorConjugation W (T * T - 1)) :=      (hTc.comp_clm W.toContinuousLinearMap.adjoint).clm_comp W.toContinuousLinearMap    exact ⟨hn, hs, heq.symm ▸ hc⟩  have spatialProperties {X E H : Type} [Fintype X] [DecidableEq X] [PseudoMetricSpace X]      [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E]      [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]      (W : E →ₗᵢ[ℂ] H) (a : X → E →L[ℂ] E) (hpart : ∑ x, (a x).adjoint.comp (a x) = 1)      (F : E →L[ℂ] E) (hFs : IsSelfAdjoint F) (radius : ℝ) (hradius : 0 ≤ radius)      (ha : ∀ x, (a x).adjoint = a x)      (hsupport : ∀ x y, radius < dist x y → a x * a y = 0)      (hcompact : (∀ v : E, partitionCompression a F v = ∑ x : X, (a x).adjoint (F ((a x) v))) →        IsCompactOperator (partitionCompression a F * partitionCompression a F - (1 : E →L[ℂ] E))) :      let K := partitionCompression a F      let P := partitionIsometry a hpart      let S := isometricExtension P K      let U := coefficientIsometry (X := X) W      let A := isometricExtension U S      ‖A‖ ≤ ‖F‖ + 4 ∧ IsSelfAdjoint A ∧ PropagationLE (radius + radius) A ∧      IsCompactOperator (A * A - (1 : Module X H →L[ℂ] Module X H)) := by    intro K P S U A    have hblock : ‖constantBlock (X := X) F‖ ≤ ‖F‖ := by      unfold constantBlock blockOperator      generalize_proofs (config := {maxDepth := 0})      apply LinearMap.mkContinuous_norm_le      assumption    have hPn : ‖partitionMap a‖ ≤ 1 := P.norm_toContinuousLinearMap_le    have hPsn : ‖(partitionMap a).adjoint‖ ≤ 1 := by      simpa only [ContinuousLinearMap.adjoint.norm_map] using hPn    have hP0 : 0 ≤ ‖partitionMap a‖ := (partitionMap a).opNorm_nonneg    have hB0 : 0 ≤ ‖constantBlock (X := X) F‖ := (constantBlock (X := X) F).opNorm_nonneg    have hF0 : 0 ≤ ‖F‖ := F.opNorm_nonneg    have hKn : ‖K‖ ≤ ‖F‖ := calc      ‖K‖ ≤ ‖(partitionMap a).adjoint‖ * (‖constantBlock (X := X) F‖ * ‖partitionMap a‖) :=        (ContinuousLinearMap.opNorm_comp_le _ _).trans          (mul_le_mul_of_nonneg_left (ContinuousLinearMap.opNorm_comp_le _ _) (partitionMap a).adjoint.opNorm_nonneg)      _ ≤ 1 * (‖F‖ * 1) := mul_le_mul hPsn (mul_le_mul hblock hPn hP0 hF0)        (mul_nonneg hB0 hP0) zero_le_one      _ = ‖F‖ := by simp only [one_mul, mul_one]    have coordP (x : X) : (coordinate x).comp (partitionMap a) = a x := by      ext v      simp only [partitionMap, ContinuousLinearMap.comp_apply, sum_apply, map_sum]      change (∑ y : X, (lp.single 2 y ((a y) v)) x) = (a x) v      simp [lp.single_apply]    have partAdjApply (v : Module X E) : (partitionMap a).adjoint v = ∑ x : X, (a x).adjoint (v x) := by      apply ext_inner_left ℂ      intro h      rw [ContinuousLinearMap.adjoint_inner_right]      change inner ℂ ((∑ x : X, (DiscreteRoe.insert x).comp (a x)) h) v =        inner ℂ h (∑ x : X, (a x).adjoint (v x))      simp only [sum_apply, ContinuousLinearMap.comp_apply, sum_inner, inner_sum]      apply Finset.sum_congr rfl      intro x _      change inner ℂ (lp.single (E := fun _ : X => E) 2 x ((a x) h)) v = _      exact (lp.inner_single_left (𝕜 := ℂ) (G := fun _ : X => E) x ((a x) h) v).trans        (ContinuousLinearMap.adjoint_inner_right (a x) h (v x)).symm    have KApply (v : E) : K v = ∑ x : X, (a x).adjoint (F ((a x) v)) := by      change (partitionMap a).adjoint (constantBlock F (partitionMap a v)) = _      rw [partAdjApply]      apply Finset.sum_congr rfl      intro x _      change (a x).adjoint (F ((partitionMap a v) x)) = (a x).adjoint (F ((a x) v))      exact congrArg (fun h => (a x).adjoint (F h)) (DFunLike.congr_fun (coordP x) v)    have hKs : IsSelfAdjoint K := by      have hKeq : K = ∑ x : X, (a x).adjoint.comp (F.comp (a x)) := by        apply ContinuousLinearMap.ext        intro v        simpa only [sum_apply, ContinuousLinearMap.comp_apply] using KApply v      rw [hKeq]      exact isSelfAdjoint_sum _ (fun x _ => hFs.conjugate' (a x))    have partAdjSingle (y : X) (h : E) : (partitionMap a).adjoint (lp.single 2 y h) = (a y).adjoint h := by      rw [partAdjApply]      calc        (∑ z : X, (a z).adjoint ((lp.single (E := fun _ : X => E) 2 y h) z)) =            (a y).adjoint ((lp.single (E := fun _ : X => E) 2 y h) y) := by          apply Finset.sum_eq_single          · intro z _ hzy            rw [lp.single_apply_ne (E := fun _ : X => E) 2 y h hzy, map_zero]          · intro hy            exact (hy (Finset.mem_univ y)).elim        _ = (a y).adjoint h := congrArg (a y).adjoint (lp.single_apply_self (E := fun _ : X => E) 2 y h)    have entryConjApply (T : E →L[ℂ] E) (x y : X) (h : E) :        entry (partitionConjugate a T) x y h = a x (T ((a y).adjoint h)) := by      have hy : (partitionMap a).adjoint (lp.single 2 y h) = (a y).adjoint h := partAdjSingle y h      have hx : (partitionMap a (T ((a y).adjoint h))) x = a x (T ((a y).adjoint h)) :=        DFunLike.congr_fun (coordP x) (T ((a y).adjoint h))      change (partitionMap a (T ((partitionMap a).adjoint (lp.single 2 y h)))) x = _      exact (congrArg (fun v : E => (partitionMap a (T v)) x) hy).trans hx    have hSp : PropagationLE (radius + radius) S := by      intro x y hxy      let L : Operator X E := partitionConjugate a K      let Q : Operator X E := partitionConjugate a 1      have hne : x ≠ y := by        intro h        subst y        exact (not_lt_of_ge (add_nonneg hradius hradius)) (by simpa only [dist_self] using hxy)      apply ContinuousLinearMap.ext      intro h      have hLv : L (lp.single 2 y h) x = 0 := by        change entry (partitionConjugate a K) x y h = 0        rw [entryConjApply, ha y, KApply]        simp only [map_sum]        apply Finset.sum_eq_zero        intro z _        rw [ha z]        by_cases hxz : radius < dist x z        · exact DFunLike.congr_fun (hsupport x z hxz) (F ((a z) ((a y) h)))        · have hzy : radius < dist z y := by            by_contra hz            exact (not_le_of_gt hxy) ((dist_triangle x z y).trans              (add_le_add (le_of_not_gt hxz) (le_of_not_gt hz)))          have hzyv : a z (a y h) = 0 := DFunLike.congr_fun (hsupport z y hzy) h          simp only [hzyv, map_zero]      have hQv : Q (lp.single 2 y h) x = 0 := by        change entry (partitionConjugate a 1) x y h = 0        rw [entryConjApply, ha y, one_apply_eq_self]        exact DFunLike.congr_fun (hsupport x y ((le_add_of_nonneg_right hradius).trans_lt hxy)) h      have h1v : (lp.single (E := fun _ : X => E) 2 y h) x = 0 :=        lp.single_apply_ne (E := fun _ : X => E) 2 y h hne      change (lp.single (E := fun _ : X => E) 2 y h) x +        (partitionMap a ((K - 1) ((partitionMap a).adjoint (lp.single 2 y h)))) x = 0      rw [sub_apply, one_apply_eq_self, map_sub]      change (lp.single (E := fun _ : X => E) 2 y h) x +        (L (lp.single 2 y h) x - Q (lp.single 2 y h) x) = 0      rw [h1v, hLv, hQv, sub_self, add_zero]    have hAp : PropagationLE (radius + radius) A := by      intro x y hxy      have hne : x ≠ y := by        intro h        subst y        exact (not_lt_of_ge (add_nonneg hradius hradius)) (by simpa only [dist_self] using hxy)      apply ContinuousLinearMap.ext      intro h      have hU : U.toContinuousLinearMap.adjoint (lp.single 2 y h) =          lp.single 2 y (W.toContinuousLinearMap.adjoint h) := by        apply ext_inner_left ℂ        intro v        calc          inner ℂ v (U.toContinuousLinearMap.adjoint (lp.single 2 y h)) =              inner ℂ (U.toContinuousLinearMap v) (lp.single 2 y h) :=            ContinuousLinearMap.adjoint_inner_right _ _ _          _ = inner ℂ (W (v y)) h := lp.inner_single_right (𝕜 := ℂ)            (G := fun _ : X => H) y h (U.toContinuousLinearMap v)          _ = inner ℂ (v y) (W.toContinuousLinearMap.adjoint h) :=            (ContinuousLinearMap.adjoint_inner_right W.toContinuousLinearMap (v y) h).symm          _ = inner ℂ v (lp.single 2 y (W.toContinuousLinearMap.adjoint h)) :=            (lp.inner_single_right (𝕜 := ℂ) (G := fun _ : X => E) y              (W.toContinuousLinearMap.adjoint h) v).symm      have hSv : S (lp.single 2 y (W.toContinuousLinearMap.adjoint h)) x = 0 :=        DFunLike.congr_fun (hSp x y hxy) (W.toContinuousLinearMap.adjoint h)      have hs : (lp.single (E := fun _ : X => E) 2 y (W.toContinuousLinearMap.adjoint h)) x = 0 :=        lp.single_apply_ne (E := fun _ : X => E) 2 y (W.toContinuousLinearMap.adjoint h) hne      have ht : (lp.single (E := fun _ : X => H) 2 y h) x = 0 :=        lp.single_apply_ne (E := fun _ : X => H) 2 y h hne      change ((lp.single (E := fun _ : X => H) 2 y h) +        U.toContinuousLinearMap ((S - 1) (U.toContinuousLinearMap.adjoint (lp.single 2 y h)))) x = 0      rw [hU]      change (lp.single (E := fun _ : X => H) 2 y h) x +        W (S (lp.single 2 y (W.toContinuousLinearMap.adjoint h)) x -          (lp.single (E := fun _ : X => E) 2 y (W.toContinuousLinearMap.adjoint h)) x) = 0      rw [ht, hSv, hs, sub_self, map_zero, add_zero]    have hKc := hcompact KApply    have first := extensionProperties P K hKs hKc    have second := extensionProperties U S first.2.1 first.2.2    have hSn : ‖S‖ ≤ ‖F‖ + 2 := first.1.trans (add_le_add hKn le_rfl)    have hAn : ‖A‖ ≤ ‖F‖ + 4 := calc      ‖A‖ ≤ ‖S‖ + 2 := second.1      _ ≤ (‖F‖ + 2) + 2 := add_le_add hSn le_rfl      _ = ‖F‖ + 4 := by ring    exact ⟨hAn, second.2.1, hAp, second.2.2⟩  let Good (i : ℕ) (Z : Operator (V i) (lp (fun _ : ℕ => ℂ) 2)) : Prop :=    ‖Z‖ ≤ ‖(c i).operator‖ + 4 ∧ IsSelfAdjoint Z ∧ PropagationLE (r + r) Z ∧    IsCompactOperator (Z * Z - (1 : Operator (V i) (lp (fun _ : ℕ => ℂ) 2)))  have properties (i : ℕ) : let T := ampleRipsOperator r (c i) (hπ i); Good i T := by    intro T    let cycle := c i    let a : V i → cycle.space →L[ℂ] cycle.space := representedSqrt r cycle    let F : cycle.space →L[ℂ] cycle.space := cycle.operator    let W : cycle.space →ₗᵢ[ℂ] lp (fun _ : ℕ => ℂ) 2 := ampleIsometry cycle.space    have hFi : IsSelfAdjoint F := hF i    have hπi : cycle.representation 1 = 1 := hπ i    have hsqrt (x : V i) : IsSelfAdjoint (sqrtCoordinate r x) := by      ext p      simp [sqrtCoordinate]    have hsum : ∑ x : V i, sqrtCoordinate r x * sqrtCoordinate r x = 1 := by      ext p      change (ContinuousMap.evalAlgHom ℂ ℂ p) (∑ x : V i, sqrtCoordinate r x * sqrtCoordinate r x) = 1      rw [map_sum]      simp only [map_mul]      change (∑ x : V i, (Real.sqrt (p.weight x) : ℂ) * (Real.sqrt (p.weight x) : ℂ)) = 1      simp only [← Complex.ofReal_mul, Real.mul_self_sqrt (p.nonneg _)]      have htotal : ∑ x : V i, p.weight x = 1 := by        rw [← p.total]        exact (p.weight.sum_fintype (fun _ t => t) (by simp)).symm      rw [← Complex.ofReal_sum, htotal, Complex.ofReal_one]    have hadj (x : V i) : (a x).adjoint = a x := by      change (cycle.representation (sqrtCoordinate r x)).adjoint = cycle.representation (sqrtCoordinate r x)      exact ((hsqrt x).map cycle.representation).star_eq    have hrep : ∑ x : V i, a x * a x = 1 := by      change (∑ x : V i, cycle.representation (sqrtCoordinate r x) *        cycle.representation (sqrtCoordinate r x)) = 1      simp only [← map_mul, ← map_sum, hsum, hπi]    have hpart : ∑ x : V i, (a x).adjoint.comp (a x) = 1 := by      change (∑ x : V i, (a x).adjoint * a x) = 1      simpa only [hadj] using hrep    have support (x y : V i) (hxy : r < dist x y) : a x * a y = 0 := by      have hz : sqrtCoordinate r x * sqrtCoordinate r y = 0 := by        ext p        have hp : p.weight x = 0 ∨ p.weight y = 0 := by          by_contra h          push Not at h          exact (not_le_of_gt hxy) (p.diameter x (Finsupp.mem_support_iff.mpr h.1)            y (Finsupp.mem_support_iff.mpr h.2))        rcases hp with hx | hy        · simp [sqrtCoordinate, hx]        · simp [sqrtCoordinate, hy]      change cycle.representation (sqrtCoordinate r x) * cycle.representation (sqrtCoordinate r y) = 0      exact (map_mul cycle.representation _ _).symm.trans        ((congrArg cycle.representation hz).trans (map_zero cycle.representation))    have hcompact (KApply : ∀ v : cycle.space, partitionCompression a F v =        ∑ x : V i, (a x).adjoint (F ((a x) v))) :        IsCompactOperator (partitionCompression a F * partitionCompression a F -          (1 : cycle.space →L[ℂ] cycle.space)) := by      let K := partitionCompression a F      let G := localizedOperator cycle (sqrtCoordinate r)      have hKloc : K = G := by        apply ContinuousLinearMap.ext        intro v        change partitionCompression a F v = G v        rw [KApply]        change (∑ x : V i, (a x).adjoint (F ((a x) v))) =          (∑ x : V i, cycle.representation (sqrtCoordinate r x) * F * cycle.representation (sqrtCoordinate r x)) v        simp only [sum_apply, hadj]        apply Finset.sum_congr rfl        intro x _        rfl      let d := localizedCycle cycle (sqrtCoordinate r) hFi hsqrt hrep      have hd := d.square_compact 1      change IsCompactOperator (((F + (G - F)) * (F + (G - F)) - (1 : cycle.space →L[ℂ] cycle.space)) *        cycle.representation 1) at hd      have hsumFG : F + (G - F) = G := by abel      have hGc : IsCompactOperator (G * G - (1 : cycle.space →L[ℂ] cycle.space)) := by        simpa only [hsumFG, hπi, mul_one] using hd      exact (congrArg (fun Q : cycle.space →L[ℂ] cycle.space => Q * Q - 1) hKloc).symm ▸ hGc    let K := partitionCompression a F    let P := partitionIsometry a hpart    let S := isometricExtension P K    let U := coefficientIsometry (X := V i) W    let A := isometricExtension U S    have facts := spatialProperties W a hpart F hFi r hr hadj support hcompact    have result : Good i A := facts    have hAeq : A = T := rfl    rw [← hAeq]    exact result  exact separatedFamilyBoundary o (fun i => ampleRipsOperator r (c i) (hπ i))    (C + 4) (add_nonneg hC (by norm_num))    (fun i => (properties i).1.trans (add_le_add (hnorm i) le_rfl))    (r + r) (add_nonneg hr hr) (fun i => (properties i).2.2.1)    (fun i => (properties i).2.1) (fun i => (properties i).2.2.2)end CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssembly.DiscreteRoeuniverse sourceUniverse targetUniverse coefficientUniverselocal instance inclusionExponentFact : Fact (1 ≤ (2 : ENNReal)) := ⟨one_le_two⟩variable {X : Type sourceUniverse} {Y : Type targetUniverse} {H : Type coefficientUniverse}  [sourceDecidable : DecidableEq X] [targetDecidable : DecidableEq Y]  [coefficientNormed : NormedAddCommGroup H] [coefficientInner : InnerProductSpace ℂ H]  [coefficientComplete : CompleteSpace H]variable [sourceMetric : PseudoMetricSpace X] [targetMetric : PseudoMetricSpace Y]-- The self-contained construction includes its support proofs.def inclusionHom (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) :    OAI.CoarseAssembly.DiscreteRoe.algebra (X := X) (H := H) →⋆ₙₐ[ℂ] OAI.CoarseAssembly.DiscreteRoe.algebra (X := Y) (H := H) := by  classical  let V : Module X H →ₗᵢ[ℂ] Module Y H := inclusionIsometry e  let φ : Operator X H →⋆ₙₐ[ℂ] Operator Y H := operatorConjugationHom V  have vector_apply (v : Module X H) (x : X) : V v (e x) = v x := by    change extendedFunction e v (e x) = v x    exact e.injective.extend_apply _ _ _  have vector_zero (v : Module X H) (y : Y) (hy : y ∉ Set.range e) : V v y = 0 := by    change extendedFunction e v y = 0    exact Function.extend_apply' _ _ _ hy  have isometry_single (x : X) (h : H) : V (lp.single 2 x h) = lp.single 2 (e x) h := by    apply lp.ext    funext y    by_cases hy : y ∈ Set.range e    · obtain ⟨z, rfl⟩ := hy      rw [vector_apply]      simp only [lp.single_apply, Pi.single_apply, e.injective.eq_iff]    · rw [vector_zero _ y hy]      exact (lp.single_apply_ne (E := fun _ : Y => H) 2 (e x) h        (fun hxy => hy ⟨x, hxy.symm⟩)).symm  have adjoint_apply (v : Module Y H) (x : X) : V.toContinuousLinearMap.adjoint v x = v (e x) := by    apply ext_inner_left ℂ    intro h    calc      inner ℂ h (V.toContinuousLinearMap.adjoint v x) =          inner ℂ (lp.single 2 x h) (V.toContinuousLinearMap.adjoint v) :=        (lp.inner_single_left (𝕜 := ℂ) (G := fun _ : X => H) x h          (V.toContinuousLinearMap.adjoint v)).symm      _ = inner ℂ (V.toContinuousLinearMap (lp.single 2 x h)) v :=        ContinuousLinearMap.adjoint_inner_right _ _ _      _ = inner ℂ (lp.single 2 (e x) h) v :=        congrArg (fun w => inner ℂ w v) (isometry_single x h)      _ = inner ℂ h (v (e x)) := lp.inner_single_left (𝕜 := ℂ) (G := fun _ : Y => H) (e x) h v  have entry_eq (T : Operator X H) (x y : X) : entry (φ T) (e x) (e y) = entry T x y := by    ext h    change V (T (V.toContinuousLinearMap.adjoint (lp.single 2 (e y) h))) (e x) =      T (lp.single 2 y h) x    have hadj : V.toContinuousLinearMap.adjoint (V (lp.single 2 y h)) = lp.single 2 y h := by      simpa only [ContinuousLinearMap.comp_apply, one_apply_eq_self,        LinearIsometry.coe_toContinuousLinearMap] using        DFunLike.congr_fun V.adjoint_comp_self (lp.single 2 y h)    rw [← isometry_single y h, hadj]    exact vector_apply _ x  have entry_row_zero (T : Operator X H) (x y : Y) (hx : x ∉ Set.range e) :      entry (φ T) x y = 0 := by    ext h    change V (T (V.toContinuousLinearMap.adjoint (lp.single 2 y h))) x = 0    exact vector_zero _ x hx  have entry_col_zero (T : Operator X H) (x y : Y) (hy : y ∉ Set.range e) :      entry (φ T) x y = 0 := by    ext h    have hz : V.toContinuousLinearMap.adjoint (lp.single 2 y h) = 0 := by      apply lp.ext      funext z      rw [adjoint_apply]      exact lp.single_apply_ne (E := fun _ : Y => H) 2 y h (fun hzy => hy ⟨z, hzy⟩)    change V (T (V.toContinuousLinearMap.adjoint (lp.single 2 y h))) x = 0    rw [hz, map_zero, map_zero]    rfl  have compact_congr {S T : H →L[ℂ] H} (h : S = T) (hT : IsCompactOperator T.toFun) :      IsCompactOperator S.toFun := by    cases h    exact hT  have compact {T : Operator X H} (hT : CompactEntries T) : CompactEntries (φ T) := by    intro x y    by_cases hx : x ∈ Set.range e    · obtain ⟨a, rfl⟩ := hx      by_cases hy : y ∈ Set.range e      · obtain ⟨b, rfl⟩ := hy        exact compact_congr (entry_eq T a b) (hT a b)      · exact compact_congr (entry_col_zero T _ _ hy)          (show IsCompactOperator (0 : H →L[ℂ] H).toFun from isCompactOperator_zero)    · exact compact_congr (entry_row_zero T _ _ hx)        (show IsCompactOperator (0 : H →L[ℂ] H).toFun from isCompactOperator_zero)  have propagation {T : Operator X H} {r : ℝ} (hT : PropagationLE r T) : PropagationLE r (φ T) := by    intro x y hxy    by_cases hx : x ∈ Set.range e    · obtain ⟨a, rfl⟩ := hx      by_cases hy : y ∈ Set.range e      · obtain ⟨b, rfl⟩ := hy        exact (entry_eq T a b).trans (hT a b (hxy.trans_le (he a b)))      · exact entry_col_zero T _ _ hy    · exact entry_row_zero T _ _ hx  have generator {T : Operator X H} (hT : Generator T) : Generator (φ T) := by    obtain ⟨⟨r, hr, hprop⟩, hc, hcs⟩ := hT    refine ⟨⟨r, hr, propagation hprop⟩, compact hc, ?_⟩    simpa only [map_star] using compact hcs  have hφ : Continuous φ := by    change Continuous (fun T : Operator X H =>      V.toContinuousLinearMap.comp (T.comp V.toContinuousLinearMap.adjoint))    exact continuous_const.clm_comp (continuous_id.clm_comp continuous_const)  have hgen (T : Operator X H) (hT : Generator T) : φ T ∈ algebra (X := Y) (H := H) :=    (NonUnitalStarSubalgebra.le_topologicalClosure _)      (NonUnitalStarAlgebra.subset_adjoin ℂ _ (generator hT))  refine conjugationHom V ?_  intro T hT  change φ T ∈ algebra (X := Y) (H := H)  let SX : Set (Operator X H) :=    (NonUnitalStarAlgebra.adjoin ℂ {T : Operator X H | Generator T} : Set (Operator X H))  let SY : Set (Operator Y H) := (algebra (X := Y) (H := H) : Set (Operator Y H))  have hclosed : IsClosed SY := by    change IsClosed (closure ((NonUnitalStarAlgebra.adjoin ℂ      {T : Operator Y H | Generator T}) : Set (Operator Y H)))    exact isClosed_closure  have hle : NonUnitalStarAlgebra.adjoin ℂ {T : Operator X H | Generator T} ≤      (algebra (X := Y) (H := H)).comap φ := NonUnitalStarAlgebra.adjoin_le hgen  have hmap : SX ⊆ φ ⁻¹' SY := hle  have ht : T ∈ closure SX := hT  exact (closure_minimal hmap (hclosed.preimage hφ)) htend CoarseAssembly.DiscreteRoeendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type} [NonUnitalCStarAlgebra A] {c d e : OddCycle A}attribute [-instance] PositiveLinearMap.instContinuousLinearMapClassComplexOfLinearMapClassOfOrderHomClassend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen Analytic DiscreteRoe Filter Topologyvariable (Q : ℕ → Type) [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)]  [∀ i, DecidableEq (Q i)] (r : ℝ)structure ControlledCycleFamily where  cycle : ∀ i, OddCycle C(Point (Q i) r, ℂ)  unital : ∀ i, (cycle i).representation 1 = 1  selfAdjoint : ∀ i, IsSelfAdjoint (cycle i).operator  bound : ℝ  bound_nonneg : 0 ≤ bound  norm_le : ∀ i, ‖(cycle i).operator‖ ≤ boundvariable {Q r}def ControlledCycleFamily.boundary (c : ControlledCycleFamily Q r)    (o : ∀ i, Q i) (hr : 0 ≤ r) :    letI := separatedMetric o    OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) :=  ampleRipsFamilyBoundary o r hr c.cycle c.unital c.selfAdjoint    c.bound c.bound_nonneg c.norm_leend CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen Analytic DiscreteRoevariable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)]  [∀ i, DecidableEq (Q i)] {r : ℝ}def regularizedFamily (c : ∀ i, OAI.CoarseAssembly.Analytic.OddCycle C(OAI.CoarseAssembly.Rips.Point (Q i) r, ℂ))    (χ : ∀ i, C(OAI.CoarseAssembly.Rips.Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ) : OAI.CoarseAssembly.Rips.ControlledCycleFamily Q r := by  classical  have OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) : IsSelfAdjoint c.cutDown.operator  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      rw [((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          c.cutDown.operator = OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change c.operator + (OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator - c.operator) = _            abel      local_proof) c)]      exact (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P) :          IsSelfAdjoint (OAI.CoarseAssembly.Analytic.symmetricCutDown P F) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star ((1 / 2 : ℝ) • (P * F * P + star (P * F * P)) + (1 - P)) = _            rw [star_add, star_smul, star_trivial, star_add, star_star, star_sub, star_one, hP.star_eq]            rw [add_comm (star (P * F * P))]            rfl      local_proof) _ _ ((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          IsSelfAdjoint (c.representation 1) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star (c.representation 1) = c.representation 1            rw [← map_star, star_one]      local_proof) c)  have OAI.CoarseAssembly.Analytic.cutDown_complement {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :      c.cutDown.operator * (1 - c.cutDown.representation 1) = 1 - c.cutDown.representation 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      change (c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c) * (1 - c.representation 1) = 1 - c.representation 1      have he : c.operator + OAI.CoarseAssembly.Analytic.representedCorrection c =          OAI.CoarseAssembly.Analytic.symmetricCutDown (c.representation 1) c.operator := by unfold OAI.CoarseAssembly.Analytic.representedCorrection; abel      rw [he]      exact (      let local_proof {H : OAI.CoarseAssembly.Analytic.HilbertSpace} (P F : OAI.CoarseAssembly.Analytic.End H) (hP : IsSelfAdjoint P)          (hPP : P * P = P) : OAI.CoarseAssembly.Analytic.symmetricCutDown P F * (1 - P) = 1 - P :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            have hzero : ∀ T : OAI.CoarseAssembly.Analytic.End H, P * T * P * (1 - P) = 0 := by              intro T              rw [mul_sub, mul_one, mul_assoc (P * T) P P, hPP, sub_self]            have hQ : (1 - P) * (1 - P) = 1 - P := by              calc                (1 - P) * (1 - P) = 1 - P - P + P * P := by noncomm_ring                _ = 1 - P := by rw [hPP]; abel            unfold OAI.CoarseAssembly.Analytic.symmetricCutDown            rw [add_mul, smul_mul_assoc, add_mul, hzero F,              star_mul, star_mul, hP.star_eq, ← mul_assoc, hzero (star F), add_zero, smul_zero, zero_add, hQ]      local_proof) _ _ ((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          IsSelfAdjoint (c.representation 1) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star (c.representation 1) = c.representation 1            rw [← map_star, star_one]      local_proof) c) ((      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :          c.representation 1 * c.representation 1 = c.representation 1 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            rw [← map_mul, one_mul]      local_proof) c)  have OAI.CoarseAssembly.Analytic.represented_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A)      (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) :      IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      apply (      let local_proof (c : OAI.CoarseAssembly.Analytic.OddCycle ℂ)          (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1) :          IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            have hz : (c.operator * c.operator - 1) * (1 - c.representation 1) = 0 := by              calc                _ = c.operator * (c.operator * (1 - c.representation 1)) -                    (1 - c.representation 1) := by noncomm_ring                _ = 0 := by rw [hQ, hQ, sub_self]            have he : c.operator * c.operator - 1 =                (c.operator * c.operator - 1) * c.representation 1 := by              exact sub_eq_zero.mp (by simpa only [mul_sub, mul_one] using hz)            rw [he]            exact c.square_compact 1      local_proof) c.scalarRestriction      change c.operator * (1 - c.representation (algebraMap ℂ A 1)) =        1 - c.representation (algebraMap ℂ A 1)      simpa only [map_one] using hQ  have OAI.CoarseAssembly.Analytic.cutDown_square_compact {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) :      IsCompactOperator (c.cutDown.operator * c.cutDown.operator - 1 : OAI.CoarseAssembly.Analytic.End c.cutDown.space)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    OAI.CoarseAssembly.Analytic.represented_square_compact c.cutDown (OAI.CoarseAssembly.Analytic.cutDown_complement c)  have OAI.CoarseAssembly.Analytic.completedRepresentation_one {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) :      OAI.CoarseAssembly.Analytic.completedRepresentation c χ 1 = 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    by      simp only [(      let local_proof {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) (a : A) :          OAI.CoarseAssembly.Analytic.completedRepresentation c χ a = c.representation a + χ a • (1 - c.representation 1) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          rfl      local_proof), map_one, one_smul]      abel  have OAI.CoarseAssembly.Analytic.characterExtension_unital {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ)      (hF : IsSelfAdjoint c.operator)      (hQ : c.operator * (1 - c.representation 1) = 1 - c.representation 1)      (hsq : IsCompactOperator (c.operator * c.operator - 1 : OAI.CoarseAssembly.Analytic.End c.space)) :      (c.characterExtension χ hF hQ hsq).representation 1 = 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    OAI.CoarseAssembly.Analytic.completedRepresentation_one c χ  have OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_unital {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) :      (c.unitalSelfAdjoint χ).representation 1 = 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    OAI.CoarseAssembly.Analytic.characterExtension_unital (c.cutDown) χ (OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint c) (OAI.CoarseAssembly.Analytic.cutDown_complement c) (OAI.CoarseAssembly.Analytic.cutDown_square_compact c)  have OAI.CoarseAssembly.Analytic.OddCycle.regularize_unital {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) :      (c.regularize χ).representation 1 = 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    (OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_unital c χ)  have OAI.CoarseAssembly.Analytic.OddCycle.unitalSelfAdjoint_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) :      IsSelfAdjoint (c.unitalSelfAdjoint χ).operator  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    OAI.CoarseAssembly.Analytic.cutDown_selfAdjoint c  have OAI.CoarseAssembly.Analytic.OddCycle.regularize_selfAdjoint {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) :      IsSelfAdjoint (c.regularize χ).operator  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    (      let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :          IsSelfAdjoint (OAI.CoarseAssembly.Analytic.boundedTransform F hF) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            change star (OAI.CoarseAssembly.Analytic.boundedTransform F hF) = OAI.CoarseAssembly.Analytic.boundedTransform F hF            simp only [OAI.CoarseAssembly.Analytic.boundedTransform, star_smul, star_sub, star_star, Complex.star_def,              map_div₀, Complex.conj_I, map_ofNat, neg_div, neg_smul]            module      local_proof) _ _  have OAI.CoarseAssembly.Analytic.OddCycle.regularize_norm_le {A : Type} [inst_local_1 : CStarAlgebra A] (c : OAI.CoarseAssembly.Analytic.OddCycle A) (χ : A →⋆ₐ[ℂ] ℂ) :      ‖(c.regularize χ).operator‖ ≤ 1  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    (      let local_proof {A : Type _} [inst_local_1 : CStarAlgebra A] (F : A) (hF : IsSelfAdjoint F) :          ‖OAI.CoarseAssembly.Analytic.boundedTransform F hF‖ ≤ 1 :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            nontriviality A            unfold OAI.CoarseAssembly.Analytic.boundedTransform            rw [norm_smul, norm_div, Complex.norm_I, Complex.norm_ofNat]            have hn := norm_sub_le (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A) (star (OAI.CoarseAssembly.Analytic.cayleyUnitary F hF : A))            rw [norm_star, CStarRing.norm_coe_unitary] at hn            nlinarith      local_proof) _ _  exact {    cycle i := (c i).regularize (χ i)    unital i := (OAI.CoarseAssembly.Analytic.OddCycle.regularize_unital (c i) (χ i))    selfAdjoint i := (OAI.CoarseAssembly.Analytic.OddCycle.regularize_selfAdjoint (c i) (χ i))    bound := 1    bound_nonneg := zero_le_one    norm_le i := (OAI.CoarseAssembly.Analytic.OddCycle.regularize_norm_le (c i) (χ i))  }end CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B]attribute [-instance] PositiveLinearMap.instContinuousLinearMapClassComplexOfLinearMapClassOfOrderHomClassvariable {H K : HilbertSpace}end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {H K : HilbertSpace}attribute [-instance] PositiveLinearMap.instContinuousLinearMapClassComplexOfLinearMapClassOfOrderHomClassvariable {A : Type} [CStarAlgebra A] {c d : OddCycle A}end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A : Type} [CStarAlgebra A] {c d e : OddCycle A}attribute [-instance] PositiveLinearMap.instContinuousLinearMapClassComplexOfLinearMapClassOfOrderHomClassend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {A B : Type*} [CStarAlgebra A] [CStarAlgebra B]attribute [-instance] PositiveLinearMap.instContinuousLinearMapClassComplexOfLinearMapClassOfOrderHomClassvariable {R : Type} [CStarAlgebra R] {c d e : OddCycle R}end CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable (H : ℕ → HilbertSpace)attribute [-instance] StarOrderedRing.toExistsAddOfLE CStarModule.toInnerend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen Analytic DiscreteRoevariable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)]  [∀ i, DecidableEq (Q i)] {r : ℝ} {A : Type} [NonUnitalCStarAlgebra A]def analyticFamilyIndexFree (o : ∀ i, Q i) (hr : 0 ≤ r)    (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ)    (η : ∀ i, C(Point (Q i) r, ℂ) →⋆ₙₐ[ℂ] A) :    letI := separatedMetric o    letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) :=      inferInstance    FreeAbelianGroup (OddCycle A) →+      OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) :=  FreeAbelianGroup.lift (fun c => (regularizedFamily (fun i => c.precomp (η i)) χ).boundary o hr)def analyticFamilyIndex (o : ∀ i, Q i) (hr : 0 ≤ r)    (χ : ∀ i, C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ)    (η : ∀ i, C(Point (Q i) r, ℂ) →⋆ₙₐ[ℂ] A) :    letI := separatedMetric o    letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) :=      inferInstance    OddK A →+ OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := by  classical  letI := separatedMetric o  letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) :=    inferInstance  exact if h : relations A ≤ (analyticFamilyIndexFree o hr χ η).ker then    QuotientAddGroup.lift (relations A) (analyticFamilyIndexFree o hr χ η) h  else 0end CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssemblyopen Topology Ripsvariable {V : ℕ → Type} [∀ j, MetricSpace (V j)]  {Z : ℕ → Type} [∀ j, TopologicalSpace (Z j)] [∀ j, CompactSpace (Z j)]def separatedRipsMap (o : ∀ j, V j) (r : ℝ) (j : ℕ) :    letI := OAI.CoarseAssembly.separatedMetric o    OAI.CoarseAssembly.Rips.Point (V j) r → OAI.CoarseAssembly.Rips.Point (Sigma V) r := by  classical  have OAI.CoarseAssembly.separatedComponent_isometry {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] (o : ∀ j, V j) (j : ℕ) :      letI := OAI.CoarseAssembly.separatedMetric o      Isometry (OAI.CoarseAssembly.separatedComponent (V := V) j)  :=    open OAI OAI.CoarseAssembly in    open Topology Rips in    by      let := OAI.CoarseAssembly.separatedMetric o      apply Isometry.of_dist_eq      intro x y      exact (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof) o j x y  let := OAI.CoarseAssembly.separatedMetric o  exact OAI.CoarseAssembly.Rips.mapPoint (OAI.CoarseAssembly.separatedComponent j)    (fun x y => ((OAI.CoarseAssembly.separatedComponent_isometry o j).dist_eq x y).le)variable [∀ j, Fintype (V j)]end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssemblyopen Topology Rips Analyticvariable {V : ℕ → Type} [∀ j, MetricSpace (V j)] [∀ j, Fintype (V j)]  {Z : ℕ → Type} [∀ j, TopologicalSpace (Z j)] [∀ j, CompactSpace (Z j)]def separatedRipsEmbedding (o : ∀ j, V j) (r : ℝ) (j : ℕ) :    letI := OAI.CoarseAssembly.separatedMetric o    OAI.CoarseAssembly.Rips.Point (V j) r ↪ OAI.CoarseAssembly.Rips.Point (Sigma V) r := by  classical  have OAI.CoarseAssembly.Rips.mapPoint_injective {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) : Function.Injective (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    by      intro p q h      apply OAI.CoarseAssembly.Rips.Point.ext      apply Finsupp.ext      intro x      have hx := congrArg (fun p : OAI.CoarseAssembly.Rips.Point Y r => p.weight (e x)) h      simpa only [(      let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) (p : OAI.CoarseAssembly.Rips.Point X r) (x : X) :          (OAI.CoarseAssembly.Rips.mapPoint e he p).weight (e x) = p.weight x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          Finsupp.embDomain_apply_self e p.weight x      local_proof)] using hx  have OAI.CoarseAssembly.separatedComponent_isometry {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] (o : ∀ j, V j) (j : ℕ) :      letI := OAI.CoarseAssembly.separatedMetric o      Isometry (OAI.CoarseAssembly.separatedComponent (V := V) j)  :=    open OAI OAI.CoarseAssembly in    open Topology Rips in    by      let := OAI.CoarseAssembly.separatedMetric o      apply Isometry.of_dist_eq      intro x y      exact (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof) o j x y  let := OAI.CoarseAssembly.separatedMetric o  exact ⟨OAI.CoarseAssembly.separatedRipsMap o r j, OAI.CoarseAssembly.Rips.mapPoint_injective (OAI.CoarseAssembly.separatedComponent j)    (fun x y => ((OAI.CoarseAssembly.separatedComponent_isometry o j).dist_eq x y).le)⟩end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticopen scoped ZeroAtInfty CStarAlgebravariable {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y]  [CompactSpace X]def compactFunctionLift : C(X, ℂ) →⋆ₙₐ[ℂ] C₀(X, ℂ) where  toFun := ZeroAtInftyContinuousMap.ContinuousMap.liftZeroAtInfty  map_zero' := rfl  map_add' _ _ := rfl  map_mul' _ _ := rfl  map_smul' _ _ := rfl  map_star' _ := rflend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen Analytic DiscreteRoeopen scoped ZeroAtInftyvariable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)]  [∀ i, DecidableEq (Q i)]def lateRipsFunctionHom (o : ∀ i, Q i) (r : ℝ) (i : ℕ) :    letI := OAI.CoarseAssembly.separatedMetric o    C(OAI.CoarseAssembly.Rips.Point (Q i) r, ℂ) →⋆ₙₐ[ℂ] C₀(OAI.CoarseAssembly.Rips.Point (Sigma Q) r, ℂ) := by  classical  have OAI.CoarseAssembly.Rips.coordinate_continuous {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} (x : X) :      Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => p.weight x)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    (continuous_apply x).comp (      let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Continuous (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          continuous_induced_dom      local_proof)  have OAI.CoarseAssembly.Rips.mapPoint_range_open {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he : Isometry e)      (hsep : ∀ x y, y ∉ Set.range e → r < dist (e x) y) :      IsOpen (Set.range (OAI.CoarseAssembly.Rips.mapPoint (r := r) e (fun x y => (he.dist_eq x y).le)))  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    by      rw [(      let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he : Isometry e) :          Set.range (OAI.CoarseAssembly.Rips.mapPoint (r := r) e (fun x y => (he.dist_eq x y).le)) =          {q : OAI.CoarseAssembly.Rips.Point Y r | ↑q.weight.support ⊆ Set.range e} :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          by            classical            ext q            constructor            · rintro ⟨p, rfl⟩ y hy              rw [OAI.CoarseAssembly.Rips.mapPoint, Finsupp.support_embDomain, Finset.mem_coe, Finset.mem_map] at hy              obtain ⟨x, _, rfl⟩ := hy              exact ⟨x, rfl⟩            · intro hq              refine ⟨OAI.CoarseAssembly.Rips.unmapPoint e he q hq, ?_⟩              apply OAI.CoarseAssembly.Rips.Point.ext              exact Finsupp.embDomain_comapDomain hq      local_proof) e he]      apply isOpen_iff_mem_nhds.mpr      intro q hq      obtain ⟨y, hy⟩ := ((      let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} (p : OAI.CoarseAssembly.Rips.Point X r) : ∃ x, 0 < p.weight x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open scoped BigOperators in          open Topology in          by            classical            by_contra! h            have hz : p.weight = 0 := by              ext x              exact le_antisymm (h x) (p.nonneg x)            have ht := p.total            simp [hz] at ht      local_proof) q)      obtain ⟨x, rfl⟩ := hq (Finsupp.mem_support_iff.mpr (ne_of_gt hy))      have hnhds : {p : OAI.CoarseAssembly.Rips.Point Y r | 0 < p.weight (e x)} ∈ 𝓝 q :=        (isOpen_lt continuous_const (OAI.CoarseAssembly.Rips.coordinate_continuous (e x))).mem_nhds hy      apply Filter.mem_of_superset hnhds      intro p hp y hy      by_contra hnot      exact (not_le_of_gt (hsep x y hnot))        (p.diameter (e x) (Finsupp.mem_support_iff.mpr (ne_of_gt hp)) y hy)  have OAI.CoarseAssembly.Rips.mapPoint_continuous {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) : Continuous (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    by      classical      apply continuous_induced_rng.mpr      apply continuous_pi      intro y      change Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => OAI.CoarseAssembly.Rips.coordinates (OAI.CoarseAssembly.Rips.mapPoint e he p) y)      by_cases hy : y ∈ Set.range e      · obtain ⟨x, rfl⟩ := hy        simpa only [OAI.CoarseAssembly.Rips.coordinates, OAI.CoarseAssembly.Rips.mapPoint, Finsupp.embDomain_apply_self] using          OAI.CoarseAssembly.Rips.coordinate_continuous (r := r) x      · have hz : (fun p : OAI.CoarseAssembly.Rips.Point X r => OAI.CoarseAssembly.Rips.coordinates (OAI.CoarseAssembly.Rips.mapPoint e he p) y) = fun _ => 0 := by          funext p          exact Finsupp.embDomain_of_notMem_range e p.weight y hy        rw [hz]        exact continuous_const  have OAI.CoarseAssembly.Rips.mapPoint_injective {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) : Function.Injective (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    by      intro p q h      apply OAI.CoarseAssembly.Rips.Point.ext      apply Finsupp.ext      intro x      have hx := congrArg (fun p : OAI.CoarseAssembly.Rips.Point Y r => p.weight (e x)) h      simpa only [(      let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) (p : OAI.CoarseAssembly.Rips.Point X r) (x : X) :          (OAI.CoarseAssembly.Rips.mapPoint e he p).weight (e x) = p.weight x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          Finsupp.embDomain_apply_self e p.weight x      local_proof)] using hx  have OAI.CoarseAssembly.Rips.mapPoint_closedEmbedding {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} [inst_local_5 : Fintype X] [Fintype X] (e : X ↪ Y) (he) :      Topology.IsClosedEmbedding (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    (OAI.CoarseAssembly.Rips.mapPoint_continuous e he).isClosedEmbedding (OAI.CoarseAssembly.Rips.mapPoint_injective e he)  have OAI.CoarseAssembly.separatedComponent_isometry {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] (o : ∀ j, V j) (j : ℕ) :      letI := OAI.CoarseAssembly.separatedMetric o      Isometry (OAI.CoarseAssembly.separatedComponent (V := V) j)  :=    open OAI OAI.CoarseAssembly in    open Topology Rips in    by      let := OAI.CoarseAssembly.separatedMetric o      apply Isometry.of_dist_eq      intro x y      exact (      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) (i : ℕ) (x y : V i) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨i, y⟩ = dist x y :=        open OAI OAI.CoarseAssembly in          dite_eq_left rfl      local_proof) o j x y  have OAI.CoarseAssembly.separatedComponent_separation {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] (o : ∀ j, V j) (j : ℕ) (r : ℝ) (hj : r < j) :      letI := OAI.CoarseAssembly.separatedMetric o      ∀ x y, y ∉ Set.range (OAI.CoarseAssembly.separatedComponent (V := V) j) →        r < dist (OAI.CoarseAssembly.separatedComponent j x) y  :=    open OAI OAI.CoarseAssembly in    open Topology Rips in    by      let := OAI.CoarseAssembly.separatedMetric o      rintro x ⟨k, y⟩ hy      have hjk : j ≠ k := by        rintro rfl        exact hy ⟨y, rfl⟩      change r < OAI.CoarseAssembly.separatedDist o ⟨j, x⟩ ⟨k, y⟩      rw [(      let local_proof {V : ℕ → Type _} [inst_local_1 : (i : ℕ) → MetricSpace (V i)] (o : ∀ i, V i) {i j : ℕ} (h : i ≠ j)          (x : V i) (y : V j) :          OAI.CoarseAssembly.separatedDist o ⟨i, x⟩ ⟨j, y⟩ =          dist x (o i) + ((i : ℝ) + (j : ℝ) + 2) + dist (o j) y :=        open OAI OAI.CoarseAssembly in          dite_eq_right h      local_proof) o hjk]      have hk : (0 : ℝ) ≤ k := Nat.cast_nonneg k      linarith [dist_nonneg (x := x) (y := o j), dist_nonneg (x := o k) (y := y)]  have OAI.CoarseAssembly.lateRipsComponent_openEmbedding {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] [inst_local_2 : (j : ℕ) → Fintype (V j)] [∀ j, Fintype (V j)]      (o : ∀ j, V j) (j : ℕ) (r : ℝ) (hj : r < j) :      letI := OAI.CoarseAssembly.separatedMetric o      Topology.IsOpenEmbedding (OAI.CoarseAssembly.Rips.mapPoint (r := r) (OAI.CoarseAssembly.separatedComponent (V := V) j)        (fun x y => ((OAI.CoarseAssembly.separatedComponent_isometry o j).dist_eq x y).le))  :=    open OAI OAI.CoarseAssembly in    open Topology Rips in    by      let := OAI.CoarseAssembly.separatedMetric o      exact        { toIsEmbedding := (OAI.CoarseAssembly.Rips.mapPoint_closedEmbedding _ _).isEmbedding          isOpen_range := OAI.CoarseAssembly.Rips.mapPoint_range_open _ (OAI.CoarseAssembly.separatedComponent_isometry o j)            (OAI.CoarseAssembly.separatedComponent_separation o j r hj) }  have OAI.CoarseAssembly.separatedRipsEmbedding_open {V : ℕ → Type} [inst_local_1 : (j : ℕ) → MetricSpace (V j)] [inst_local_2 : (j : ℕ) → Fintype (V j)] (o : ∀ j, V j) (r : ℝ) (j : ℕ) (hj : r < j) :      letI := OAI.CoarseAssembly.separatedMetric o      Topology.IsOpenEmbedding (OAI.CoarseAssembly.separatedRipsEmbedding o r j)  :=    open OAI OAI.CoarseAssembly in    open Topology Rips Analytic in    OAI.CoarseAssembly.lateRipsComponent_openEmbedding o j r hj  let := OAI.CoarseAssembly.separatedMetric o  exact if hi : r < i then    (OAI.CoarseAssembly.Analytic.zeroExtensionHom (OAI.CoarseAssembly.separatedRipsEmbedding o r i) (OAI.CoarseAssembly.separatedRipsEmbedding_open o r i hi)).comp      OAI.CoarseAssembly.Analytic.compactFunctionLift    else 0def ripsPointCharacter (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) (i : ℕ) :    C(Point (Q i) r, ℂ) →⋆ₐ[ℂ] ℂ :=  ContinuousMap.evalStarAlgHom ℂ ℂ (vertex (r := r) (o i) hr)def separatedRipsIndex (o : ∀ i, Q i) (r : ℝ) (hr : 0 ≤ r) :    letI := separatedMetric o    letI : Ring (Unitization ℂ (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2))) :=      inferInstance    LocallyFiniteK1 (Point (Sigma Q) r) →+      OperatorKTheory.K1 (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) :=  analyticFamilyIndex o hr (ripsPointCharacter o r hr) (lateRipsFunctionHom o r)end CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {H : HilbertSpace}attribute [-instance] T5Space.toT1Space T4Space.toT1Space  TopologicalSpace.PseudoMetrizableSpace.toMetrizableSpace  TopologicalSpace.metrizableSpace_of_t3_secondCountable  TopologicalSpace.IsCompletelyMetrizableSpace.instMetrizableSpaceend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {H : HilbertSpace}attribute [-instance] IsUniformAddGroup.isTopologicalAddGroup  IsLeftUniformAddGroup.toIsTopologicalAddGroup  IsRightUniformAddGroup.toIsTopologicalAddGroupattribute [-instance] TopologicalSpace.PseudoMetrizableSpace.toMetrizableSpace  TopologicalSpace.metrizableSpace_of_t3_secondCountable  TopologicalSpace.IsCompletelyMetrizableSpace.instMetrizableSpaceend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticvariable {H : HilbertSpace}attribute [-instance] IsUniformAddGroup.isTopologicalAddGroup  IsLeftUniformAddGroup.toIsTopologicalAddGroup  IsRightUniformAddGroup.toIsTopologicalAddGroupend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Analyticuniverse u vstructure CoarseningMorphism (C D : Coarsening.{u}) where  atScale : ∀ r, CocompactMap (C.space r) (D.space r)  compatible : ∀ r s h,    (atScale s).comp (C.inclusion r s h) = (D.inclusion r s h).comp (atScale r)structure CompatibleIndexFamily (C : Coarsening.{u}) (A : Type v)    [NonUnitalCStarAlgebra A] where  atScale : ∀ r, LocallyFiniteK1 (C.space r) →+ OperatorKTheory.K1 A  compatible : ∀ r s h a, atScale s (C.map r s h a) = atScale r anamespace CompatibleIndexFamilyvariable {C D : Coarsening.{u}} {A B : Type v}variable [NonUnitalCStarAlgebra A] [NonUnitalCStarAlgebra B]def assembly (I : CompatibleIndexFamily C A) : C.Homology →+ OperatorKTheory.K1 A :=  AddCommGroup.DirectLimit.lift _ _ _ I.atScale I.compatibleend CompatibleIndexFamilyend CoarseAssembly.Analyticendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen Analytic DiscreteRoevariable {Q : ℕ → Type} [∀ i, MetricSpace (Q i)] [∀ i, Fintype (Q i)]  [∀ i, DecidableEq (Q i)]def separatedIndexFamily (o : ∀ i, Q i) :    letI := separatedMetric o    CompatibleIndexFamily (coarsening (Sigma Q))      (algebra (X := Sigma Q) (H := lp (fun _ : ℕ => ℂ) 2)) := by  let := separatedMetric o  classical  let f := fun n : ℕ => separatedRipsIndex o n (Nat.cast_nonneg n)  exact if h : ∀ r s h a,      f s ((coarsening (Sigma Q)).map r s h a) = f r a then    { atScale := f, compatible := h }  else    { atScale := fun _ => 0, compatible := by intros; rfl }end CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssembly.Analytic.CompatibleIndexFamilyuniverse u vvariable {C D : Coarsening.{u}} {A B : Type v}  [NonUnitalCStarAlgebra A] [NonUnitalCStarAlgebra B]def transport (I : OAI.CoarseAssembly.Analytic.CompatibleIndexFamily C A) (f : OAI.CoarseAssembly.Analytic.CoarseningMorphism D C)    (φ : A →⋆ₙₐ[ℂ] B) : OAI.CoarseAssembly.Analytic.CompatibleIndexFamily D B := by  classical  have OAI.CoarseAssembly.Analytic.pushforward_comp {X : Type _} {Y : Type _} {Z : Type _} [inst_local_3 : TopologicalSpace X] [inst_local_4 : TopologicalSpace Y] [inst_local_5 : TopologicalSpace Z] (f : CocompactMap X Y) (g : CocompactMap Y Z) :      OAI.CoarseAssembly.Analytic.pushforward (g.comp f) = (OAI.CoarseAssembly.Analytic.pushforward g).comp (OAI.CoarseAssembly.Analytic.pushforward f)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in    open scoped ZeroAtInfty in    by      rw [OAI.CoarseAssembly.Analytic.pushforward, (      let local_proof {X : Type _} {Y : Type _} {Z : Type _} [inst_local_3 : TopologicalSpace X] [inst_local_4 : TopologicalSpace Y] [inst_local_5 : TopologicalSpace Z] (f : CocompactMap X Y) (g : CocompactMap Y Z) :          OAI.CoarseAssembly.Analytic.pullback (g.comp f) = (OAI.CoarseAssembly.Analytic.pullback f).comp (OAI.CoarseAssembly.Analytic.pullback g) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          open scoped ZeroAtInfty in          by            ext a x            rfl      local_proof), (      let local_proof {A : Type _} [inst_local_1 : NonUnitalCStarAlgebra A] {B : Type _} {C : Type _} [inst_local_4 : NonUnitalCStarAlgebra B] [inst_local_5 : NonUnitalCStarAlgebra C] (φ : B →⋆ₙₐ[ℂ] A) (ψ : C →⋆ₙₐ[ℂ] B) :          OAI.CoarseAssembly.Analytic.precomp (φ.comp ψ) = (OAI.CoarseAssembly.Analytic.precomp ψ).comp (OAI.CoarseAssembly.Analytic.precomp φ) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic in          by            apply QuotientAddGroup.addMonoidHom_ext            apply FreeAbelianGroup.lift_ext            intro c            rfl      local_proof)]      rfl  have OAI.CoarseAssembly.Analytic.CoarseningMorphism.pushforward_compatible {C : OAI.CoarseAssembly.Analytic.Coarsening} {D : OAI.CoarseAssembly.Analytic.Coarsening} (f : OAI.CoarseAssembly.Analytic.CoarseningMorphism C D) (r s : ℕ) (h : r ≤ s) :      (OAI.CoarseAssembly.Analytic.pushforward (f.atScale s)).comp (C.map r s h) =        (D.map r s h).comp (OAI.CoarseAssembly.Analytic.pushforward (f.atScale r))  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Analytic OAI.CoarseAssembly.Analytic.CoarseningMorphism in    by      change (OAI.CoarseAssembly.Analytic.pushforward (f.atScale s)).comp (OAI.CoarseAssembly.Analytic.pushforward (C.inclusion r s h)) =        (OAI.CoarseAssembly.Analytic.pushforward (D.inclusion r s h)).comp (OAI.CoarseAssembly.Analytic.pushforward (f.atScale r))      rw [← OAI.CoarseAssembly.Analytic.pushforward_comp, ← OAI.CoarseAssembly.Analytic.pushforward_comp, f.compatible]  exact {    atScale r := (OAI.CoarseAssembly.OperatorKTheory.map φ).comp ((I.atScale r).comp (OAI.CoarseAssembly.Analytic.pushforward (f.atScale r)))    compatible r s hrs a := by      have hf := DFunLike.congr_fun ((OAI.CoarseAssembly.Analytic.CoarseningMorphism.pushforward_compatible f r s hrs)) a      change OAI.CoarseAssembly.Analytic.pushforward (f.atScale s) (D.map r s hrs a) =        C.map r s hrs (OAI.CoarseAssembly.Analytic.pushforward (f.atScale r) a) at hf      change OAI.CoarseAssembly.OperatorKTheory.map φ (I.atScale s (OAI.CoarseAssembly.Analytic.pushforward (f.atScale s) (D.map r s hrs a))) = _      rw [hf, I.compatible]      rfl  }end CoarseAssembly.Analytic.CompatibleIndexFamilyendendsectionnoncomputable sectionnamespace CoarseAssembly.Ripsopen Topologyuniverse uvariable {X Y : Type u} [PseudoMetricSpace X] [PseudoMetricSpace Y] {r : ℝ}def embeddingMap (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) (r : ℝ) :    CocompactMap (OAI.CoarseAssembly.Rips.Point X r) (OAI.CoarseAssembly.Rips.Point Y r) := by  classical  have OAI.CoarseAssembly.Rips.coordinate_continuous {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} (x : X) :      Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => p.weight x)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    (continuous_apply x).comp (      let local_proof {X : Type _} [inst_local_1 : PseudoMetricSpace X] {r : ℝ} : Continuous (OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r)) :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          continuous_induced_dom      local_proof)  have OAI.CoarseAssembly.Rips.mapPoint_continuous {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) : Continuous (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    by      classical      apply continuous_induced_rng.mpr      apply continuous_pi      intro y      change Continuous (fun p : OAI.CoarseAssembly.Rips.Point X r => OAI.CoarseAssembly.Rips.coordinates (OAI.CoarseAssembly.Rips.mapPoint e he p) y)      by_cases hy : y ∈ Set.range e      · obtain ⟨x, rfl⟩ := hy        simpa only [OAI.CoarseAssembly.Rips.coordinates, OAI.CoarseAssembly.Rips.mapPoint, Finsupp.embDomain_apply_self] using          OAI.CoarseAssembly.Rips.coordinate_continuous (r := r) x      · have hz : (fun p : OAI.CoarseAssembly.Rips.Point X r => OAI.CoarseAssembly.Rips.coordinates (OAI.CoarseAssembly.Rips.mapPoint e he p) y) = fun _ => 0 := by          funext p          exact Finsupp.embDomain_of_notMem_range e p.weight y hy        rw [hz]        exact continuous_const  have OAI.CoarseAssembly.Rips.mapPoint_injective {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) : Function.Injective (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    by      intro p q h      apply OAI.CoarseAssembly.Rips.Point.ext      apply Finsupp.ext      intro x      have hx := congrArg (fun p : OAI.CoarseAssembly.Rips.Point Y r => p.weight (e x)) h      simpa only [(      let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) (p : OAI.CoarseAssembly.Rips.Point X r) (x : X) :          (OAI.CoarseAssembly.Rips.mapPoint e he p).weight (e x) = p.weight x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          Finsupp.embDomain_apply_self e p.weight x      local_proof)] using hx  have OAI.CoarseAssembly.Rips.mapPoint_embedding {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) :      IsEmbedding (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    by      refine ⟨IsInducing.of_comp (OAI.CoarseAssembly.Rips.mapPoint_continuous e he)        (show Continuous (fun p : OAI.CoarseAssembly.Rips.Point Y r => fun x : X => p.weight (e x)) from          continuous_pi (fun x => OAI.CoarseAssembly.Rips.coordinate_continuous (e x))) ?_, OAI.CoarseAssembly.Rips.mapPoint_injective e he⟩      have hcomp : (fun p : OAI.CoarseAssembly.Rips.Point Y r => fun x : X => p.weight (e x)) ∘ OAI.CoarseAssembly.Rips.mapPoint e he =          OAI.CoarseAssembly.Rips.coordinates (X := X) (r := r) := by        funext p x        exact (      let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) (p : OAI.CoarseAssembly.Rips.Point X r) (x : X) :          (OAI.CoarseAssembly.Rips.mapPoint e he p).weight (e x) = p.weight x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          Finsupp.embDomain_apply_self e p.weight x      local_proof) e he p x      rw [hcomp]      exact ⟨rfl⟩  have OAI.CoarseAssembly.Rips.range_mapPoint {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) :      Set.range (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he) =        {q : OAI.CoarseAssembly.Rips.Point Y r | (∀ y, y ∉ Set.range e → q.weight y = 0) ∧          ∀ x z, r < dist x z → q.weight (e x) = 0 ∨ q.weight (e z) = 0}  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    by      classical      ext q      constructor      · rintro ⟨p, rfl⟩        refine ⟨fun y hy => Finsupp.embDomain_of_notMem_range e p.weight y hy, ?_⟩        intro x z hxz        simp only [(      let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y) (he) (p : OAI.CoarseAssembly.Rips.Point X r) (x : X) :          (OAI.CoarseAssembly.Rips.mapPoint e he p).weight (e x) = p.weight x :=        open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in          open Topology in          Finsupp.embDomain_apply_self e p.weight x      local_proof)]        by_cases hx : p.weight x = 0        · exact Or.inl hx        by_cases hz : p.weight z = 0        · exact Or.inr hz        exact False.elim ((not_le_of_gt hxz)          (p.diameter x (Finsupp.mem_support_iff.mpr hx) z (Finsupp.mem_support_iff.mpr hz)))      · rintro ⟨hs, hd⟩        have hsupport : ↑q.weight.support ⊆ Set.range e := by          intro y hy          by_contra hn          exact Finsupp.mem_support_iff.mp hy (hs y hn)        let p : OAI.CoarseAssembly.Rips.Point X r :=          { weight := q.weight.comapDomain e e.injective.injOn            nonneg x := q.nonneg (e x)            total := by              have hm := Finsupp.embDomain_comapDomain (f := e) hsupport              have ht := congrArg (fun f : Y →₀ ℝ => f.sum (fun _ t => t)) hm              simpa only [Finsupp.sum_embDomain, q.total] using ht            diameter := by              intro x hx z hz              by_contra hxz              rcases hd x z (lt_of_not_ge hxz) with hx' | hz'              · exact Finsupp.mem_support_iff.mp hx hx'              · exact Finsupp.mem_support_iff.mp hz hz' }        refine ⟨p, ?_⟩        apply OAI.CoarseAssembly.Rips.Point.ext        exact Finsupp.embDomain_comapDomain (f := e) hsupport  have OAI.CoarseAssembly.Rips.mapPoint_properEmbedding {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} (e : X ↪ Y)      (he : ∀ x y, dist (e x) (e y) ≤ dist x y) :      Topology.IsClosedEmbedding (OAI.CoarseAssembly.Rips.mapPoint (r := r) e he)  :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in    open Topology in    by      refine ⟨OAI.CoarseAssembly.Rips.mapPoint_embedding e he, ?_⟩      rw [OAI.CoarseAssembly.Rips.range_mapPoint e he]      have hs : IsClosed {q : OAI.CoarseAssembly.Rips.Point Y r | ∀ y, y ∉ Set.range e → q.weight y = 0} := by        simp only [Set.ofPred_forall]        exact isClosed_iInter fun y => isClosed_iInter fun _ =>          isClosed_eq (OAI.CoarseAssembly.Rips.coordinate_continuous y) continuous_const      have hd : IsClosed {q : OAI.CoarseAssembly.Rips.Point Y r | ∀ x z, r < dist x z →          q.weight (e x) = 0 ∨ q.weight (e z) = 0} := by        simp only [Set.ofPred_forall]        exact isClosed_iInter fun x => isClosed_iInter fun z => isClosed_iInter fun _ =>          (isClosed_eq (OAI.CoarseAssembly.Rips.coordinate_continuous (e x)) continuous_const).union            (isClosed_eq (OAI.CoarseAssembly.Rips.coordinate_continuous (e z)) continuous_const)      exact hs.inter hd  exact {    toFun := OAI.CoarseAssembly.Rips.mapPoint e he    continuous_toFun := OAI.CoarseAssembly.Rips.mapPoint_continuous e he    cocompact_tendsto' := (OAI.CoarseAssembly.Rips.mapPoint_properEmbedding e he).tendsto_cocompact  }def embeddingCoarsening (e : X ↪ Y) (he : ∀ x y, dist (e x) (e y) ≤ dist x y) :    OAI.CoarseAssembly.Analytic.CoarseningMorphism (OAI.CoarseAssembly.Rips.coarsening X) (OAI.CoarseAssembly.Rips.coarsening Y) := by  classical  exact {    atScale r := OAI.CoarseAssembly.Rips.embeddingMap e he r    compatible r s hrs := by      apply CocompactMap.ext      intro p      exact ((    let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] {r : ℝ} {s : ℝ} (hrs : r ≤ s) (e : X ↪ Y) (he)        (p : OAI.CoarseAssembly.Rips.Point X r) : OAI.CoarseAssembly.Rips.coarsen hrs (OAI.CoarseAssembly.Rips.mapPoint e he p) = OAI.CoarseAssembly.Rips.mapPoint e he (OAI.CoarseAssembly.Rips.coarsen hrs p) :=      open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in        open Topology in        by          apply OAI.CoarseAssembly.Rips.Point.ext          rfl    local_proof) (by exact_mod_cast hrs : (r : ℝ) ≤ (s : ℝ)) e he p).symm  }end CoarseAssembly.Ripsendendsectionnoncomputable sectionnamespace CoarseAssemblyopen Congruence Analytic DiscreteRoelocal instance boundaryAssemblyMetric1 : MetricSpace VertexUnion := vertexUnionMetric elementaryMoves chosenHolonomyUnitdef TotalRoe : Type := algebra (X := VertexUnion) (H := AmpleSpace)instance : NonUnitalCStarAlgebra OAI.CoarseAssembly.TotalRoe := by  classical  exact inferInstanceAs (NonUnitalCStarAlgebra (OAI.CoarseAssembly.DiscreteRoe.algebra (X := OAI.CoarseAssembly.VertexUnion) (H := OAI.CoarseAssembly.AmpleSpace)))end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssemblyopen Congruence Rips Analyticabbrev FiberedUnion := (j : ℕ) × FiberVertex jvariable (S : Finset ArithmeticGroup)  (boundary : ∀ j, (fiberedGraph S chosenHolonomyUnit j).Walk    (fiberBoundaryBase j) (fiberBoundaryBase j))end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssemblyopen Congruence Rips Analyticlocal instance boundaryLoopMetric7 : MetricSpace FiberedUnion := componentUnionMetric elementaryMoves chosenHolonomyUnitlocal instance boundaryLoopMetric8 : MetricSpace VertexUnion := vertexUnionMetric elementaryMoves chosenHolonomyUnitdef totalToFiber : VertexUnion ≃ FiberedUnion :=  Equiv.sigmaAssoc (fun j u => Quotient (discDepth j u))def totalToFiberCoarsening : OAI.CoarseAssembly.Analytic.CoarseningMorphism (OAI.CoarseAssembly.Rips.coarsening OAI.CoarseAssembly.VertexUnion) (OAI.CoarseAssembly.Rips.coarsening OAI.CoarseAssembly.FiberedUnion) := by  classical  exact OAI.CoarseAssembly.Rips.embeddingCoarsening OAI.CoarseAssembly.totalToFiber.toEmbedding (fun x y => ((    let local_proof (x y : OAI.CoarseAssembly.VertexUnion) : dist (OAI.CoarseAssembly.totalToFiber x) (OAI.CoarseAssembly.totalToFiber y) = dist x y :=      open OAI OAI.CoarseAssembly in        open Congruence Rips Analytic in        rfl    local_proof) x y).le)end CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssemblyopen Analytic DiscreteRoe Rips Congruencelocal instance constructedFiberComponentEq (i : ℕ) : DecidableEq (FiberVertex i) := Classical.decEq _local instance constructedFiberComponentMetric (i : ℕ) : MetricSpace (FiberVertex i) :=  componentMetric elementaryMoves chosenHolonomyUnit ilocal instance constructedTotalMetric : MetricSpace VertexUnion :=  vertexUnionMetric elementaryMoves chosenHolonomyUnitdef fiberReindexRoeHom :    (letI := OAI.CoarseAssembly.separatedMetric OAI.CoarseAssembly.fiberBoundaryBase;      OAI.CoarseAssembly.DiscreteRoe.algebra (X := Sigma OAI.CoarseAssembly.FiberVertex) (H := OAI.CoarseAssembly.AmpleSpace)) →⋆ₙₐ[ℂ] OAI.CoarseAssembly.TotalRoe := by  classical  let := OAI.CoarseAssembly.separatedMetric OAI.CoarseAssembly.fiberBoundaryBase  exact OAI.CoarseAssembly.DiscreteRoe.inclusionHom (X := Sigma OAI.CoarseAssembly.FiberVertex) (Y := OAI.CoarseAssembly.VertexUnion) (H := OAI.CoarseAssembly.AmpleSpace) OAI.CoarseAssembly.totalToFiber.symm.toEmbedding    (fun x y => (((  let local_proof {X : Type _} {Y : Type _} [inst_local_2 : PseudoMetricSpace X] [inst_local_3 : PseudoMetricSpace Y] (e : X ≃ Y) (he : Isometry e) : Isometry e.symm :=    open OAI OAI.CoarseAssembly OAI.CoarseAssembly.Rips in      open Analytic in      by        apply Isometry.of_dist_eq        intro x y        simpa only [Equiv.apply_symm_apply] using (he.dist_eq (e.symm x) (e.symm y)).symm  local_proof) OAI.CoarseAssembly.totalToFiber (Isometry.of_dist_eq (  let local_proof (x y : OAI.CoarseAssembly.VertexUnion) : dist (OAI.CoarseAssembly.totalToFiber x) (OAI.CoarseAssembly.totalToFiber y) = dist x y :=    open OAI OAI.CoarseAssembly in      open Congruence Rips Analytic in      rfl  local_proof))).dist_eq x y).le)def constructedTotalIndex : CompatibleIndexFamily (coarsening VertexUnion) TotalRoe :=  (separatedIndexFamily (Q := FiberVertex) fiberBoundaryBase).transport totalToFiberCoarsening fiberReindexRoeHomend CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssemblyopen Congruence Rips Analyticlocal instance constructedConclusionMetric : MetricSpace VertexUnion :=  vertexUnionMetric elementaryMoves chosenHolonomyUnitdef constructedCoarseAssembly : KX1 VertexUnion →+ OperatorKTheory.K1 TotalRoe :=  constructedTotalIndex.assemblyend CoarseAssemblyendendsectionnoncomputable sectionnamespace CoarseAssemblyopen Congruence Rips Analyticlocal instance unconditionalConclusionMetric : MetricSpace VertexUnion :=  vertexUnionMetric elementaryMoves chosenHolonomyUnittheorem bounded_geometry_graph_counterexample_unconditional :    (∀ j, Finite (FiberVertex j) ∧      (fiberedGraph elementaryMoves chosenHolonomyUnit j).Connected) ∧    (∃ D : ℕ, ∀ j (x : FiberVertex j),      Nat.card {y // (fiberedGraph elementaryMoves chosenHolonomyUnit j).Adj x y} ≤ D) ∧    ProperSpace VertexUnion ∧ UniformFiniteBalls VertexUnion ∧      (∀ x y : VertexUnion, x ≠ y → 1 ≤ dist x y) ∧      ∃ α : KX1 VertexUnion,        (∀ n : ℤ, n ≠ 0 → n • α ≠ 0) ∧ constructedCoarseAssembly α = 0 ∧        (1 : ℚ) ⊗ₜ[ℤ] α ≠ 0 ∧        ¬ Function.Injective constructedCoarseAssembly ∧        ¬ Function.Injective (constructedCoarseAssembly.toIntLinearMap.lTensor ℚ) := by  sorryend CoarseAssemblyendendend OAI

Every extracted statement of the accompanying papers

The statements the atlas extracted automatically from each accompanying paper’s TeX source, with links to the full sources.

A counterexample to the coarse Novikov conjecture

Theorem

\mu_X(\alpha)=0\quad\text{in }K_1(C^*(X)).

Consequently, ordinary coarse assembly for X fails to be injective both integrally and after tensoring its domain and target with \Q.

Section 1, Introduction Read it in the paper TeX source, line 49

Show the TeX

There is a uniformly discrete bounded-geometry metric space $X$, which is a
coarse disjoint union of finite connected graphs of uniformly bounded degree,
and an infinite-order element $\alpha\in KX_1(X)$ such that
\[
 \mu_X(\alpha)=0\quad\text{in }K_1(C^*(X)).
\]
Consequently, ordinary coarse assembly for $X$ fails to be injective both
integrally and after tensoring its domain and target with $\Q$.

Configuration and file facts

File: lean/ComparatorChallenges/CoarseAssembly.lean
OpenAI’s Lean catalogue: OpenAI’s Lean catalogue does not list this as a main result; the release’s Lean notes for family 307 link it.
Solution module: OAI.Topology.CoarseAssembly
Allowed axioms: propext, Quot.sound, Classical.choiceThe axioms this configuration allows a proof to use. A replay shows which of them a proof uses.
Imports: Mathlib
Imports from outside Mathlib: None
Local vocabulary: 216 local vocabulary declarations
Lines of Lean, without comments or blank lines: 4,469
Second proof-verification program (nanoda): Off in OpenAI's configuration.

A shareable summary of this page: the proposed paper match, what the Lean statement expresses, and which reviews are recorded.

Plectis Atlas