topology.metric_space.completion ⟷ Mathlib.Topology.MetricSpace.Completion

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -134,9 +134,9 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
         by_cases h : ε ≤ dist x y
         · exact Or.inl h
         · have Z := hε (not_le.1 h)
-          simp only [Set.mem_setOf_eq] at Z 
+          simp only [Set.mem_setOf_eq] at Z
           exact Or.inr Z
-    simp only [not_le.mpr hxy, false_or_iff, not_le] at this 
+    simp only [not_le.mpr hxy, false_or_iff, not_le] at this
     exact ts this
   · /- Start from a set `s` containing an ε-neighborhood of the diagonal in `completion α`. To show
         that it is an entourage, we use the fact that `dist` is uniformly continuous on
@@ -150,7 +150,7 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
     have : r ∈ uniformity ℝ := Metric.dist_mem_uniformity εpos
     have T := uniformContinuous_def.1 (@completion.uniform_continuous_dist α _) r this
     simp only [uniformity_prod_eq_prod, mem_prod_iff, exists_prop, Filter.mem_map,
-      Set.mem_setOf_eq] at T 
+      Set.mem_setOf_eq] at T
     rcases T with ⟨t1, ht1, t2, ht2, ht⟩
     refine' mem_of_superset ht1 _
     have A : ∀ a b : completion α, (a, b) ∈ t1 → dist a b < ε :=
@@ -158,7 +158,7 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
       intro a b hab
       have : ((a, b), (a, a)) ∈ t1 ×ˢ t2 := ⟨hab, refl_mem_uniformity ht2⟩
       have I := ht this
-      simp [completion.dist_self, Real.dist_eq, completion.dist_comm] at I 
+      simp [completion.dist_self, Real.dist_eq, completion.dist_comm] at I
       exact lt_of_le_of_lt (le_abs_self _) I
     show t1 ⊆ s
     · rintro ⟨a, b⟩ hp
@@ -173,10 +173,10 @@ protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) :
   by
   /- This follows from the separation of `completion α` and from the description of
     entourages in terms of the distance. -/
-  have : SeparatedSpace (completion α) := by infer_instance
-  refine' separated_def.1 this x y fun s hs => _
+  have : T0Space (completion α) := by infer_instance
+  refine' t0Space_iff_uniformity.1 this x y fun s hs => _
   rcases(completion.mem_uniformity_dist s).1 hs with ⟨ε, εpos, hε⟩
-  rw [← h] at εpos 
+  rw [← h] at εpos
   exact hε εpos
 #align uniform_space.completion.eq_of_dist_eq_zero UniformSpace.Completion.eq_of_dist_eq_zero
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,9 +3,9 @@ Copyright (c) 2019 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
 -/
-import Mathbin.Topology.UniformSpace.Completion
-import Mathbin.Topology.MetricSpace.Isometry
-import Mathbin.Topology.Instances.Real
+import Topology.UniformSpace.Completion
+import Topology.MetricSpace.Isometry
+import Topology.Instances.Real
 
 #align_import topology.metric_space.completion from "leanprover-community/mathlib"@"69c6a5a12d8a2b159f20933e60115a4f2de62b58"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

@@ -189,7 +189,7 @@ protected theorem uniformity_dist' :
   by
   ext s; rw [mem_infi_of_directed]
   · simp [completion.mem_uniformity_dist, subset_def]
-  · rintro ⟨r, hr⟩ ⟨p, hp⟩; use ⟨min r p, lt_min hr hp⟩
+  · rintro ⟨r, hr⟩ ⟨p, hp⟩; use⟨min r p, lt_min hr hp⟩
     simp (config := { contextual := true }) [lt_min_iff, (· ≥ ·)]
 #align uniform_space.completion.uniformity_dist' UniformSpace.Completion.uniformity_dist'
 -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,16 +2,13 @@
 Copyright (c) 2019 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
-
-! This file was ported from Lean 3 source module topology.metric_space.completion
-! leanprover-community/mathlib commit 69c6a5a12d8a2b159f20933e60115a4f2de62b58
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.UniformSpace.Completion
 import Mathbin.Topology.MetricSpace.Isometry
 import Mathbin.Topology.Instances.Real
 
+#align_import topology.metric_space.completion from "leanprover-community/mathlib"@"69c6a5a12d8a2b159f20933e60115a4f2de62b58"
+
 /-!
 # The completion of a metric space
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -42,11 +42,13 @@ by uniform continuity. -/
 instance : Dist (Completion α) :=
   ⟨Completion.extension₂ dist⟩
 
+#print UniformSpace.Completion.uniformContinuous_dist /-
 /-- The new distance is uniformly continuous. -/
 protected theorem uniformContinuous_dist :
     UniformContinuous fun p : Completion α × Completion α => dist p.1 p.2 :=
   uniformContinuous_extension₂ dist
 #align uniform_space.completion.uniform_continuous_dist UniformSpace.Completion.uniformContinuous_dist
+-/
 
 #print UniformSpace.Completion.continuous_dist /-
 /-- The new distance is continuous. -/
@@ -56,12 +58,15 @@ protected theorem continuous_dist [TopologicalSpace β] {f g : β → Completion
 #align uniform_space.completion.continuous_dist UniformSpace.Completion.continuous_dist
 -/
 
+#print UniformSpace.Completion.dist_eq /-
 /-- The new distance is an extension of the original distance. -/
 @[simp]
 protected theorem dist_eq (x y : α) : dist (x : Completion α) y = dist x y :=
   Completion.extension₂_coe_coe uniformContinuous_dist _ _
 #align uniform_space.completion.dist_eq UniformSpace.Completion.dist_eq
+-/
 
+#print UniformSpace.Completion.dist_self /-
 /- Let us check that the new distance satisfies the axioms of a distance, by starting from the
 properties on α and extending them to `completion α` by continuity. -/
 protected theorem dist_self (x : Completion α) : dist x x = 0 :=
@@ -72,6 +77,7 @@ protected theorem dist_self (x : Completion α) : dist x x = 0 :=
   · intro a
     rw [completion.dist_eq, dist_self]
 #align uniform_space.completion.dist_self UniformSpace.Completion.dist_self
+-/
 
 #print UniformSpace.Completion.dist_comm /-
 protected theorem dist_comm (x y : Completion α) : dist x y = dist y x :=
@@ -86,6 +92,7 @@ protected theorem dist_comm (x y : Completion α) : dist x y = dist y x :=
 #align uniform_space.completion.dist_comm UniformSpace.Completion.dist_comm
 -/
 
+#print UniformSpace.Completion.dist_triangle /-
 protected theorem dist_triangle (x y z : Completion α) : dist x z ≤ dist x y + dist y z :=
   by
   apply induction_on₃ x y z
@@ -96,8 +103,10 @@ protected theorem dist_triangle (x y z : Completion α) : dist x z ≤ dist x y
     rw [completion.dist_eq, completion.dist_eq, completion.dist_eq]
     exact dist_triangle a b c
 #align uniform_space.completion.dist_triangle UniformSpace.Completion.dist_triangle
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print UniformSpace.Completion.mem_uniformity_dist /-
 /-- Elements of the uniformity (defined generally for completions) can be characterized in terms
 of the distance. -/
 protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α)) :
@@ -159,7 +168,9 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
       have : dist a b < ε := A a b hp
       exact hε this
 #align uniform_space.completion.mem_uniformity_dist UniformSpace.Completion.mem_uniformity_dist
+-/
 
+#print UniformSpace.Completion.eq_of_dist_eq_zero /-
 /-- If two points are at distance 0, then they coincide. -/
 protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) : x = y :=
   by
@@ -171,7 +182,9 @@ protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) :
   rw [← h] at εpos 
   exact hε εpos
 #align uniform_space.completion.eq_of_dist_eq_zero UniformSpace.Completion.eq_of_dist_eq_zero
+-/
 
+#print UniformSpace.Completion.uniformity_dist' /-
 /-- Reformulate `completion.mem_uniformity_dist` in terms that are suitable for the definition
 of the metric space structure. -/
 protected theorem uniformity_dist' :
@@ -182,10 +195,13 @@ protected theorem uniformity_dist' :
   · rintro ⟨r, hr⟩ ⟨p, hp⟩; use ⟨min r p, lt_min hr hp⟩
     simp (config := { contextual := true }) [lt_min_iff, (· ≥ ·)]
 #align uniform_space.completion.uniformity_dist' UniformSpace.Completion.uniformity_dist'
+-/
 
+#print UniformSpace.Completion.uniformity_dist /-
 protected theorem uniformity_dist : 𝓤 (Completion α) = ⨅ ε > 0, 𝓟 {p | dist p.1 p.2 < ε} := by
   simpa [iInf_subtype] using @completion.uniformity_dist' α _
 #align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_dist
+-/
 
 /-- Metric space structure on the completion of a pseudo_metric space. -/
 instance : MetricSpace (Completion α)
@@ -198,15 +214,19 @@ instance : MetricSpace (Completion α)
   toUniformSpace := by infer_instance
   uniformity_dist := Completion.uniformity_dist
 
+#print UniformSpace.Completion.coe_isometry /-
 /-- The embedding of a metric space in its completion is an isometry. -/
 theorem coe_isometry : Isometry (coe : α → Completion α) :=
   Isometry.of_dist_eq Completion.dist_eq
 #align uniform_space.completion.coe_isometry UniformSpace.Completion.coe_isometry
+-/
 
+#print UniformSpace.Completion.edist_eq /-
 @[simp]
 protected theorem edist_eq (x y : α) : edist (x : Completion α) y = edist x y :=
   coe_isometry x y
 #align uniform_space.completion.edist_eq UniformSpace.Completion.edist_eq
+-/
 
 end UniformSpace.Completion
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -110,15 +110,15 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
         closed properties pass to the completion. -/
     intro hs
     rcases mem_uniformity_isClosed hs with ⟨t, ht, ⟨tclosed, ts⟩⟩
-    have A : { x : α × α | (coe x.1, coe x.2) ∈ t } ∈ uniformity α :=
+    have A : {x : α × α | (coe x.1, coe x.2) ∈ t} ∈ uniformity α :=
       uniformContinuous_def.1 (uniform_continuous_coe α) t ht
     rcases mem_uniformity_dist.1 A with ⟨ε, εpos, hε⟩
     refine' ⟨ε, εpos, fun x y hxy => _⟩
     have : ε ≤ dist x y ∨ (x, y) ∈ t := by
       apply induction_on₂ x y
       · have :
-          { x : completion α × completion α | ε ≤ dist x.fst x.snd ∨ (x.fst, x.snd) ∈ t } =
-            { p : completion α × completion α | ε ≤ dist p.1 p.2 } ∪ t :=
+          {x : completion α × completion α | ε ≤ dist x.fst x.snd ∨ (x.fst, x.snd) ∈ t} =
+            {p : completion α × completion α | ε ≤ dist p.1 p.2} ∪ t :=
           by ext <;> simp
         rw [this]
         apply IsClosed.union _ tclosed
@@ -140,7 +140,7 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
         the ε-neighborhood of the diagonal is an entourage in `completion α`, and therefore this is
         also the case of `s`. -/
     rintro ⟨ε, εpos, hε⟩
-    let r : Set (ℝ × ℝ) := { p | dist p.1 p.2 < ε }
+    let r : Set (ℝ × ℝ) := {p | dist p.1 p.2 < ε}
     have : r ∈ uniformity ℝ := Metric.dist_mem_uniformity εpos
     have T := uniformContinuous_def.1 (@completion.uniform_continuous_dist α _) r this
     simp only [uniformity_prod_eq_prod, mem_prod_iff, exists_prop, Filter.mem_map,
@@ -175,7 +175,7 @@ protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) :
 /-- Reformulate `completion.mem_uniformity_dist` in terms that are suitable for the definition
 of the metric space structure. -/
 protected theorem uniformity_dist' :
-    𝓤 (Completion α) = ⨅ ε : { ε : ℝ // 0 < ε }, 𝓟 { p | dist p.1 p.2 < ε.val } :=
+    𝓤 (Completion α) = ⨅ ε : { ε : ℝ // 0 < ε }, 𝓟 {p | dist p.1 p.2 < ε.val} :=
   by
   ext s; rw [mem_infi_of_directed]
   · simp [completion.mem_uniformity_dist, subset_def]
@@ -183,7 +183,7 @@ protected theorem uniformity_dist' :
     simp (config := { contextual := true }) [lt_min_iff, (· ≥ ·)]
 #align uniform_space.completion.uniformity_dist' UniformSpace.Completion.uniformity_dist'
 
-protected theorem uniformity_dist : 𝓤 (Completion α) = ⨅ ε > 0, 𝓟 { p | dist p.1 p.2 < ε } := by
+protected theorem uniformity_dist : 𝓤 (Completion α) = ⨅ ε > 0, 𝓟 {p | dist p.1 p.2 < ε} := by
   simpa [iInf_subtype] using @completion.uniformity_dist' α _
 #align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_dist
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -128,9 +128,9 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
         by_cases h : ε ≤ dist x y
         · exact Or.inl h
         · have Z := hε (not_le.1 h)
-          simp only [Set.mem_setOf_eq] at Z
+          simp only [Set.mem_setOf_eq] at Z 
           exact Or.inr Z
-    simp only [not_le.mpr hxy, false_or_iff, not_le] at this
+    simp only [not_le.mpr hxy, false_or_iff, not_le] at this 
     exact ts this
   · /- Start from a set `s` containing an ε-neighborhood of the diagonal in `completion α`. To show
         that it is an entourage, we use the fact that `dist` is uniformly continuous on
@@ -144,7 +144,7 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
     have : r ∈ uniformity ℝ := Metric.dist_mem_uniformity εpos
     have T := uniformContinuous_def.1 (@completion.uniform_continuous_dist α _) r this
     simp only [uniformity_prod_eq_prod, mem_prod_iff, exists_prop, Filter.mem_map,
-      Set.mem_setOf_eq] at T
+      Set.mem_setOf_eq] at T 
     rcases T with ⟨t1, ht1, t2, ht2, ht⟩
     refine' mem_of_superset ht1 _
     have A : ∀ a b : completion α, (a, b) ∈ t1 → dist a b < ε :=
@@ -152,7 +152,7 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
       intro a b hab
       have : ((a, b), (a, a)) ∈ t1 ×ˢ t2 := ⟨hab, refl_mem_uniformity ht2⟩
       have I := ht this
-      simp [completion.dist_self, Real.dist_eq, completion.dist_comm] at I
+      simp [completion.dist_self, Real.dist_eq, completion.dist_comm] at I 
       exact lt_of_le_of_lt (le_abs_self _) I
     show t1 ⊆ s
     · rintro ⟨a, b⟩ hp
@@ -168,7 +168,7 @@ protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) :
   have : SeparatedSpace (completion α) := by infer_instance
   refine' separated_def.1 this x y fun s hs => _
   rcases(completion.mem_uniformity_dist s).1 hs with ⟨ε, εpos, hε⟩
-  rw [← h] at εpos
+  rw [← h] at εpos 
   exact hε εpos
 #align uniform_space.completion.eq_of_dist_eq_zero UniformSpace.Completion.eq_of_dist_eq_zero
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -27,7 +27,7 @@ it defines the same uniformity as the already defined uniform structure on the c
 
 open Set Filter UniformSpace Metric
 
-open Filter Topology uniformity
+open scoped Filter Topology uniformity
 
 noncomputable section
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -42,12 +42,6 @@ by uniform continuity. -/
 instance : Dist (Completion α) :=
   ⟨Completion.extension₂ dist⟩
 
-/- warning: uniform_space.completion.uniform_continuous_dist -> UniformSpace.Completion.uniformContinuous_dist is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], UniformContinuous.{u1, 0} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) Real (Prod.uniformSpace.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], UniformContinuous.{u1, 0} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) Real (instUniformSpaceProd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_dist UniformSpace.Completion.uniformContinuous_distₓ'. -/
 /-- The new distance is uniformly continuous. -/
 protected theorem uniformContinuous_dist :
     UniformContinuous fun p : Completion α × Completion α => dist p.1 p.2 :=
@@ -62,24 +56,12 @@ protected theorem continuous_dist [TopologicalSpace β] {f g : β → Completion
 #align uniform_space.completion.continuous_dist UniformSpace.Completion.continuous_dist
 -/
 
-/- warning: uniform_space.completion.dist_eq -> UniformSpace.Completion.dist_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) y)) (Dist.dist.{u1} α (PseudoMetricSpace.toHasDist.{u1} α _inst_1) x y)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) x) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) y)) (Dist.dist.{u1} α (PseudoMetricSpace.toDist.{u1} α _inst_1) x y)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dist_eq UniformSpace.Completion.dist_eqₓ'. -/
 /-- The new distance is an extension of the original distance. -/
 @[simp]
 protected theorem dist_eq (x y : α) : dist (x : Completion α) y = dist x y :=
   Completion.extension₂_coe_coe uniformContinuous_dist _ _
 #align uniform_space.completion.dist_eq UniformSpace.Completion.dist_eq
 
-/- warning: uniform_space.completion.dist_self -> UniformSpace.Completion.dist_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) x x) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) x x) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dist_self UniformSpace.Completion.dist_selfₓ'. -/
 /- Let us check that the new distance satisfies the axioms of a distance, by starting from the
 properties on α and extending them to `completion α` by continuity. -/
 protected theorem dist_self (x : Completion α) : dist x x = 0 :=
@@ -104,12 +86,6 @@ protected theorem dist_comm (x y : Completion α) : dist x y = dist y x :=
 #align uniform_space.completion.dist_comm UniformSpace.Completion.dist_comm
 -/
 
-/- warning: uniform_space.completion.dist_triangle -> UniformSpace.Completion.dist_triangle is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (y : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (z : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) x z) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) x y) (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) y z))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (y : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (z : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) x z) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) x y) (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) y z))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dist_triangle UniformSpace.Completion.dist_triangleₓ'. -/
 protected theorem dist_triangle (x y z : Completion α) : dist x z ≤ dist x y + dist y z :=
   by
   apply induction_on₃ x y z
@@ -121,12 +97,6 @@ protected theorem dist_triangle (x y z : Completion α) : dist x z ≤ dist x y
     exact dist_triangle a b c
 #align uniform_space.completion.dist_triangle UniformSpace.Completion.dist_triangle
 
-/- warning: uniform_space.completion.mem_uniformity_dist -> UniformSpace.Completion.mem_uniformity_dist is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (s : Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))), Iff (Membership.Mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.hasMem.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) s (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Exists.{1} Real (fun (ε : Real) => Exists.{0} (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => forall {a : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)} {b : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)}, (LT.lt.{0} Real Real.hasLt (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) a b) ε) -> (Membership.Mem.{u1, u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Set.hasMem.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) a b) s))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (s : Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))), Iff (Membership.mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (instMembershipSetFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) s (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Exists.{1} Real (fun (ε : Real) => And (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (forall {a : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)} {b : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)}, (LT.lt.{0} Real Real.instLTReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) a b) ε) -> (Membership.mem.{u1, u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Set.instMembershipSet.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) a b) s))))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.mem_uniformity_dist UniformSpace.Completion.mem_uniformity_distₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /-- Elements of the uniformity (defined generally for completions) can be characterized in terms
 of the distance. -/
@@ -190,12 +160,6 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
       exact hε this
 #align uniform_space.completion.mem_uniformity_dist UniformSpace.Completion.mem_uniformity_dist
 
-/- warning: uniform_space.completion.eq_of_dist_eq_zero -> UniformSpace.Completion.eq_of_dist_eq_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (y : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), (Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) x y) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{succ u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) x y)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (y : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), (Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) x y) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{succ u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) x y)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.eq_of_dist_eq_zero UniformSpace.Completion.eq_of_dist_eq_zeroₓ'. -/
 /-- If two points are at distance 0, then they coincide. -/
 protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) : x = y :=
   by
@@ -208,12 +172,6 @@ protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) :
   exact hε εpos
 #align uniform_space.completion.eq_of_dist_eq_zero UniformSpace.Completion.eq_of_dist_eq_zero
 
-/- warning: uniform_space.completion.uniformity_dist' -> UniformSpace.Completion.uniformity_dist' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (iInf.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε)) (fun (ε : Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε)) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.hasLt (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) (Subtype.val.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) ε)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (iInf.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε)) (fun (ε : Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε)) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.instLTReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) (Subtype.val.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) ε)))))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniformity_dist' UniformSpace.Completion.uniformity_dist'ₓ'. -/
 /-- Reformulate `completion.mem_uniformity_dist` in terms that are suitable for the definition
 of the metric space structure. -/
 protected theorem uniformity_dist' :
@@ -225,12 +183,6 @@ protected theorem uniformity_dist' :
     simp (config := { contextual := true }) [lt_min_iff, (· ≥ ·)]
 #align uniform_space.completion.uniformity_dist' UniformSpace.Completion.uniformity_dist'
 
-/- warning: uniform_space.completion.uniformity_dist -> UniformSpace.Completion.uniformity_dist is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (iInf.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) Real (fun (ε : Real) => iInf.{u1, 0} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.hasLt (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) ε)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (iInf.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) Real (fun (ε : Real) => iInf.{u1, 0} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (fun (H : GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.instLTReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) ε)))))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_distₓ'. -/
 protected theorem uniformity_dist : 𝓤 (Completion α) = ⨅ ε > 0, 𝓟 { p | dist p.1 p.2 < ε } := by
   simpa [iInf_subtype] using @completion.uniformity_dist' α _
 #align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_dist
@@ -246,23 +198,11 @@ instance : MetricSpace (Completion α)
   toUniformSpace := by infer_instance
   uniformity_dist := Completion.uniformity_dist
 
-/- warning: uniform_space.completion.coe_isometry -> UniformSpace.Completion.coe_isometry is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Isometry.{u1, u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toPseudoMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpace.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Isometry.{u1, u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1) (EMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpace.{u1} α _inst_1))) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.coe_isometry UniformSpace.Completion.coe_isometryₓ'. -/
 /-- The embedding of a metric space in its completion is an isometry. -/
 theorem coe_isometry : Isometry (coe : α → Completion α) :=
   Isometry.of_dist_eq Completion.dist_eq
 #align uniform_space.completion.coe_isometry UniformSpace.Completion.coe_isometry
 
-/- warning: uniform_space.completion.edist_eq -> UniformSpace.Completion.edist_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} ENNReal (EDist.edist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toEDist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toPseudoMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpace.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) y)) (EDist.edist.{u1} α (PseudoMetricSpace.toEDist.{u1} α _inst_1) x y)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} ENNReal (EDist.edist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoEMetricSpace.toEDist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (EMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpace.{u1} α _inst_1)))) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) x) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) y)) (EDist.edist.{u1} α (PseudoEMetricSpace.toEDist.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1)) x y)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.edist_eq UniformSpace.Completion.edist_eqₓ'. -/
 @[simp]
 protected theorem edist_eq (x y : α) : edist (x : Completion α) y = edist x y :=
   coe_isometry x y

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -221,8 +221,7 @@ protected theorem uniformity_dist' :
   by
   ext s; rw [mem_infi_of_directed]
   · simp [completion.mem_uniformity_dist, subset_def]
-  · rintro ⟨r, hr⟩ ⟨p, hp⟩
-    use ⟨min r p, lt_min hr hp⟩
+  · rintro ⟨r, hr⟩ ⟨p, hp⟩; use ⟨min r p, lt_min hr hp⟩
     simp (config := { contextual := true }) [lt_min_iff, (· ≥ ·)]
 #align uniform_space.completion.uniformity_dist' UniformSpace.Completion.uniformity_dist'
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/c89fe2d59ae06402c3f55f978016d1ada444f57e

@@ -249,9 +249,9 @@ instance : MetricSpace (Completion α)
 
 /- warning: uniform_space.completion.coe_isometry -> UniformSpace.Completion.coe_isometry is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Isometry.{u1, u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toPseudoMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.metricSpace.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Isometry.{u1, u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toPseudoMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpace.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Isometry.{u1, u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1) (EMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpaceCompletionToUniformSpace.{u1} α _inst_1))) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Isometry.{u1, u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1) (EMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpace.{u1} α _inst_1))) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.coe_isometry UniformSpace.Completion.coe_isometryₓ'. -/
 /-- The embedding of a metric space in its completion is an isometry. -/
 theorem coe_isometry : Isometry (coe : α → Completion α) :=
@@ -260,9 +260,9 @@ theorem coe_isometry : Isometry (coe : α → Completion α) :=
 
 /- warning: uniform_space.completion.edist_eq -> UniformSpace.Completion.edist_eq is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} ENNReal (EDist.edist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toEDist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toPseudoMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.metricSpace.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) y)) (EDist.edist.{u1} α (PseudoMetricSpace.toEDist.{u1} α _inst_1) x y)
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} ENNReal (EDist.edist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toEDist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toPseudoMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpace.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) y)) (EDist.edist.{u1} α (PseudoMetricSpace.toEDist.{u1} α _inst_1) x y)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} ENNReal (EDist.edist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoEMetricSpace.toEDist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (EMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpaceCompletionToUniformSpace.{u1} α _inst_1)))) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) x) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) y)) (EDist.edist.{u1} α (PseudoEMetricSpace.toEDist.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1)) x y)
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} ENNReal (EDist.edist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoEMetricSpace.toEDist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (EMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpace.{u1} α _inst_1)))) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) x) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) y)) (EDist.edist.{u1} α (PseudoEMetricSpace.toEDist.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1)) x y)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.edist_eq UniformSpace.Completion.edist_eqₓ'. -/
 @[simp]
 protected theorem edist_eq (x y : α) : edist (x : Completion α) y = edist x y :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

@@ -210,9 +210,9 @@ protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) :
 
 /- warning: uniform_space.completion.uniformity_dist' -> UniformSpace.Completion.uniformity_dist' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (infᵢ.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε)) (fun (ε : Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε)) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.hasLt (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) (Subtype.val.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) ε)))))
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (iInf.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε)) (fun (ε : Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε)) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.hasLt (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) (Subtype.val.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) ε)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (infᵢ.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε)) (fun (ε : Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε)) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.instLTReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) (Subtype.val.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) ε)))))
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (iInf.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε)) (fun (ε : Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε)) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.instLTReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) (Subtype.val.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) ε)))))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniformity_dist' UniformSpace.Completion.uniformity_dist'ₓ'. -/
 /-- Reformulate `completion.mem_uniformity_dist` in terms that are suitable for the definition
 of the metric space structure. -/
@@ -228,12 +228,12 @@ protected theorem uniformity_dist' :
 
 /- warning: uniform_space.completion.uniformity_dist -> UniformSpace.Completion.uniformity_dist is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (infᵢ.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) Real (fun (ε : Real) => infᵢ.{u1, 0} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.hasLt (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) ε)))))
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (iInf.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) Real (fun (ε : Real) => iInf.{u1, 0} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.hasLt (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) ε)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (infᵢ.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) Real (fun (ε : Real) => infᵢ.{u1, 0} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (fun (H : GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.instLTReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) ε)))))
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (iInf.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) Real (fun (ε : Real) => iInf.{u1, 0} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (fun (H : GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.instLTReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) ε)))))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_distₓ'. -/
 protected theorem uniformity_dist : 𝓤 (Completion α) = ⨅ ε > 0, 𝓟 { p | dist p.1 p.2 < ε } := by
-  simpa [infᵢ_subtype] using @completion.uniformity_dist' α _
+  simpa [iInf_subtype] using @completion.uniformity_dist' α _
 #align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_dist
 
 /-- Metric space structure on the completion of a pseudo_metric space. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
 
 ! This file was ported from Lean 3 source module topology.metric_space.completion
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
+! leanprover-community/mathlib commit 69c6a5a12d8a2b159f20933e60115a4f2de62b58
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.Topology.Instances.Real
 /-!
 # The completion of a metric space
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Completion of uniform spaces are already defined in `topology.uniform_space.completion`. We show
 here that the uniform space completion of a metric space inherits a metric space structure,
 by extending the distance to the completion and checking that it is indeed a distance, and that

mathlib commit https://github.com/leanprover-community/mathlib/commit/21e3562c5e12d846c7def5eff8cdbc520d7d4936

@@ -39,24 +39,44 @@ by uniform continuity. -/
 instance : Dist (Completion α) :=
   ⟨Completion.extension₂ dist⟩
 
+/- warning: uniform_space.completion.uniform_continuous_dist -> UniformSpace.Completion.uniformContinuous_dist is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], UniformContinuous.{u1, 0} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) Real (Prod.uniformSpace.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], UniformContinuous.{u1, 0} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) Real (instUniformSpaceProd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (PseudoMetricSpace.toUniformSpace.{0} Real Real.pseudoMetricSpace) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p))
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_dist UniformSpace.Completion.uniformContinuous_distₓ'. -/
 /-- The new distance is uniformly continuous. -/
 protected theorem uniformContinuous_dist :
     UniformContinuous fun p : Completion α × Completion α => dist p.1 p.2 :=
   uniformContinuous_extension₂ dist
 #align uniform_space.completion.uniform_continuous_dist UniformSpace.Completion.uniformContinuous_dist
 
+#print UniformSpace.Completion.continuous_dist /-
 /-- The new distance is continuous. -/
 protected theorem continuous_dist [TopologicalSpace β] {f g : β → Completion α} (hf : Continuous f)
     (hg : Continuous g) : Continuous fun x => dist (f x) (g x) :=
   Completion.uniformContinuous_dist.Continuous.comp (hf.prod_mk hg : _)
 #align uniform_space.completion.continuous_dist UniformSpace.Completion.continuous_dist
+-/
 
+/- warning: uniform_space.completion.dist_eq -> UniformSpace.Completion.dist_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) y)) (Dist.dist.{u1} α (PseudoMetricSpace.toHasDist.{u1} α _inst_1) x y)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) x) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) y)) (Dist.dist.{u1} α (PseudoMetricSpace.toDist.{u1} α _inst_1) x y)
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dist_eq UniformSpace.Completion.dist_eqₓ'. -/
 /-- The new distance is an extension of the original distance. -/
 @[simp]
 protected theorem dist_eq (x y : α) : dist (x : Completion α) y = dist x y :=
   Completion.extension₂_coe_coe uniformContinuous_dist _ _
 #align uniform_space.completion.dist_eq UniformSpace.Completion.dist_eq
 
+/- warning: uniform_space.completion.dist_self -> UniformSpace.Completion.dist_self is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) x x) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) x x) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dist_self UniformSpace.Completion.dist_selfₓ'. -/
 /- Let us check that the new distance satisfies the axioms of a distance, by starting from the
 properties on α and extending them to `completion α` by continuity. -/
 protected theorem dist_self (x : Completion α) : dist x x = 0 :=
@@ -68,6 +88,7 @@ protected theorem dist_self (x : Completion α) : dist x x = 0 :=
     rw [completion.dist_eq, dist_self]
 #align uniform_space.completion.dist_self UniformSpace.Completion.dist_self
 
+#print UniformSpace.Completion.dist_comm /-
 protected theorem dist_comm (x y : Completion α) : dist x y = dist y x :=
   by
   apply induction_on₂ x y
@@ -78,7 +99,14 @@ protected theorem dist_comm (x y : Completion α) : dist x y = dist y x :=
   · intro a b
     rw [completion.dist_eq, completion.dist_eq, dist_comm]
 #align uniform_space.completion.dist_comm UniformSpace.Completion.dist_comm
+-/
 
+/- warning: uniform_space.completion.dist_triangle -> UniformSpace.Completion.dist_triangle is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (y : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (z : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), LE.le.{0} Real Real.hasLe (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) x z) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) x y) (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) y z))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (y : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (z : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), LE.le.{0} Real Real.instLEReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) x z) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) x y) (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) y z))
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dist_triangle UniformSpace.Completion.dist_triangleₓ'. -/
 protected theorem dist_triangle (x y z : Completion α) : dist x z ≤ dist x y + dist y z :=
   by
   apply induction_on₃ x y z
@@ -90,6 +118,12 @@ protected theorem dist_triangle (x y z : Completion α) : dist x z ≤ dist x y
     exact dist_triangle a b c
 #align uniform_space.completion.dist_triangle UniformSpace.Completion.dist_triangle
 
+/- warning: uniform_space.completion.mem_uniformity_dist -> UniformSpace.Completion.mem_uniformity_dist is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (s : Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))), Iff (Membership.Mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.hasMem.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) s (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Exists.{1} Real (fun (ε : Real) => Exists.{0} (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => forall {a : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)} {b : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)}, (LT.lt.{0} Real Real.hasLt (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) a b) ε) -> (Membership.Mem.{u1, u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Set.hasMem.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) a b) s))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (s : Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))), Iff (Membership.mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (instMembershipSetFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) s (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Exists.{1} Real (fun (ε : Real) => And (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (forall {a : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)} {b : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)}, (LT.lt.{0} Real Real.instLTReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) a b) ε) -> (Membership.mem.{u1, u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (Set.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Set.instMembershipSet.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) a b) s))))
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.mem_uniformity_dist UniformSpace.Completion.mem_uniformity_distₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /-- Elements of the uniformity (defined generally for completions) can be characterized in terms
 of the distance. -/
@@ -153,6 +187,12 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
       exact hε this
 #align uniform_space.completion.mem_uniformity_dist UniformSpace.Completion.mem_uniformity_dist
 
+/- warning: uniform_space.completion.eq_of_dist_eq_zero -> UniformSpace.Completion.eq_of_dist_eq_zero is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (y : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), (Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) x y) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) -> (Eq.{succ u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) x y)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (y : UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)), (Eq.{1} Real (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) x y) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) -> (Eq.{succ u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) x y)
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.eq_of_dist_eq_zero UniformSpace.Completion.eq_of_dist_eq_zeroₓ'. -/
 /-- If two points are at distance 0, then they coincide. -/
 protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) : x = y :=
   by
@@ -165,6 +205,12 @@ protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) :
   exact hε εpos
 #align uniform_space.completion.eq_of_dist_eq_zero UniformSpace.Completion.eq_of_dist_eq_zero
 
+/- warning: uniform_space.completion.uniformity_dist' -> UniformSpace.Completion.uniformity_dist' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (infᵢ.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε)) (fun (ε : Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε)) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.hasLt (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) (Subtype.val.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) ε) ε)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (infᵢ.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε)) (fun (ε : Subtype.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε)) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.instLTReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) (Subtype.val.{1} Real (fun (ε : Real) => LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) ε) ε)))))
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniformity_dist' UniformSpace.Completion.uniformity_dist'ₓ'. -/
 /-- Reformulate `completion.mem_uniformity_dist` in terms that are suitable for the definition
 of the metric space structure. -/
 protected theorem uniformity_dist' :
@@ -177,6 +223,12 @@ protected theorem uniformity_dist' :
     simp (config := { contextual := true }) [lt_min_iff, (· ≥ ·)]
 #align uniform_space.completion.uniformity_dist' UniformSpace.Completion.uniformity_dist'
 
+/- warning: uniform_space.completion.uniformity_dist -> UniformSpace.Completion.uniformity_dist is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (infᵢ.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) Real (fun (ε : Real) => infᵢ.{u1, 0} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toHasInf.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.completeLattice.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) (fun (H : GT.gt.{0} Real Real.hasLt ε (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.hasLt (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasDist.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) ε)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (uniformity.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.uniformSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (infᵢ.{u1, 1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) Real (fun (ε : Real) => infᵢ.{u1, 0} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (ConditionallyCompleteLattice.toInfSet.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Filter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) (Filter.instCompleteLatticeFilter.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))) (GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) (fun (H : GT.gt.{0} Real Real.instLTReal ε (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))) => Filter.principal.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (setOf.{u1} (Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) (fun (p : Prod.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))) => LT.lt.{0} Real Real.instLTReal (Dist.dist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instDistCompletionToUniformSpace.{u1} α _inst_1) (Prod.fst.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p) (Prod.snd.{u1, u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) p)) ε)))))
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_distₓ'. -/
 protected theorem uniformity_dist : 𝓤 (Completion α) = ⨅ ε > 0, 𝓟 { p | dist p.1 p.2 < ε } := by
   simpa [infᵢ_subtype] using @completion.uniformity_dist' α _
 #align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_dist
@@ -192,11 +244,23 @@ instance : MetricSpace (Completion α)
   toUniformSpace := by infer_instance
   uniformity_dist := Completion.uniformity_dist
 
+/- warning: uniform_space.completion.coe_isometry -> UniformSpace.Completion.coe_isometry is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Isometry.{u1, u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toPseudoMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.metricSpace.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α], Isometry.{u1, u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1) (EMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpaceCompletionToUniformSpace.{u1} α _inst_1))) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1))
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.coe_isometry UniformSpace.Completion.coe_isometryₓ'. -/
 /-- The embedding of a metric space in its completion is an isometry. -/
 theorem coe_isometry : Isometry (coe : α → Completion α) :=
   Isometry.of_dist_eq Completion.dist_eq
 #align uniform_space.completion.coe_isometry UniformSpace.Completion.coe_isometry
 
+/- warning: uniform_space.completion.edist_eq -> UniformSpace.Completion.edist_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} ENNReal (EDist.edist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoMetricSpace.toEDist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toPseudoMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.metricSpace.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.hasCoeT.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)))) y)) (EDist.edist.{u1} α (PseudoMetricSpace.toEDist.{u1} α _inst_1) x y)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PseudoMetricSpace.{u1} α] (x : α) (y : α), Eq.{1} ENNReal (EDist.edist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (PseudoEMetricSpace.toEDist.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (EMetricSpace.toPseudoEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (MetricSpace.toEMetricSpace.{u1} (UniformSpace.Completion.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.instMetricSpaceCompletionToUniformSpace.{u1} α _inst_1)))) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) x) (UniformSpace.Completion.coe'.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α _inst_1) y)) (EDist.edist.{u1} α (PseudoEMetricSpace.toEDist.{u1} α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α _inst_1)) x y)
+Case conversion may be inaccurate. Consider using '#align uniform_space.completion.edist_eq UniformSpace.Completion.edist_eqₓ'. -/
 @[simp]
 protected theorem edist_eq (x y : α) : edist (x : Completion α) y = edist x y :=
   coe_isometry x y

mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c

@@ -36,7 +36,7 @@ namespace UniformSpace.Completion
 
 /-- The distance on the completion is obtained by extending the distance on the original space,
 by uniform continuity. -/
-instance : HasDist (Completion α) :=
+instance : Dist (Completion α) :=
   ⟨Completion.extension₂ dist⟩
 
 /-- The new distance is uniformly continuous. -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

We had duplicated API between topological spaces and uniform spaces. In this PR I mostly deduplicate it with some exceptions:

• SeparationQuotient.lift' and SeparationQuotient.map are leftovers from the old version that are designed to work with uniform spaces;
• probably, some theorems/instances still assume UniformSpace when TopologicalSpace would work.

Outside of UniformSpace/Separation, I mostly changed SeparatedSpace to T0Space and separationRel to Inseparable. I also rewrote a few proofs that were broken by the API change.

Fixes #2031

@@ -142,17 +142,6 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
       exact hε this
 #align uniform_space.completion.mem_uniformity_dist UniformSpace.Completion.mem_uniformity_dist
 
-/-- If two points are at distance 0, then they coincide. -/
-protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) : x = y := by
-  /- This follows from the separation of `Completion α` and from the description of
-    entourages in terms of the distance. -/
-  have : SeparatedSpace (Completion α) := by infer_instance
-  refine' separated_def.1 this x y fun s hs ↦ _
-  rcases (Completion.mem_uniformity_dist s).1 hs with ⟨ε, εpos, hε⟩
-  rw [← h] at εpos
-  exact hε εpos
-#align uniform_space.completion.eq_of_dist_eq_zero UniformSpace.Completion.eq_of_dist_eq_zero
-
 /-- Reformulate `Completion.mem_uniformity_dist` in terms that are suitable for the definition
 of the metric space structure. -/
 protected theorem uniformity_dist' :
@@ -169,17 +158,22 @@ protected theorem uniformity_dist : 𝓤 (Completion α) = ⨅ ε > 0, 𝓟 { p
 #align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_dist
 
 /-- Metric space structure on the completion of a pseudo_metric space. -/
-instance instMetricSpace : MetricSpace (Completion α) where
-  dist_self := Completion.dist_self
-  eq_of_dist_eq_zero := Completion.eq_of_dist_eq_zero _ _
-  dist_comm := Completion.dist_comm
-  dist_triangle := Completion.dist_triangle
-  dist := dist
-  toUniformSpace := by infer_instance
-  uniformity_dist := Completion.uniformity_dist
-  edist_dist := fun x y ↦ rfl
+instance instMetricSpace : MetricSpace (Completion α) :=
+  @MetricSpace.ofT0PseudoMetricSpace _
+    { dist_self := Completion.dist_self
+      dist_comm := Completion.dist_comm
+      dist_triangle := Completion.dist_triangle
+      dist := dist
+      toUniformSpace := inferInstance
+      uniformity_dist := Completion.uniformity_dist
+      edist_dist := fun x y ↦ rfl } _
 #align uniform_space.completion.metric_space UniformSpace.Completion.instMetricSpace
 
+@[deprecated eq_of_dist_eq_zero]
+protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) : x = y :=
+  eq_of_dist_eq_zero h
+#align uniform_space.completion.eq_of_dist_eq_zero UniformSpace.Completion.eq_of_dist_eq_zero
+
 /-- The embedding of a metric space in its completion is an isometry. -/
 theorem coe_isometry : Isometry ((↑) : α → Completion α) :=
   Isometry.of_dist_eq Completion.dist_eq

This is a very large PR, but it has been reviewed piecemeal already in PRs to the bump/v4.7.0 branch as we update to intermediate nightlies.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: damiano <adomani@gmail.com>

@@ -132,9 +132,9 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
       intro a b hab
       have : ((a, b), (a, a)) ∈ t1 ×ˢ t2 := ⟨hab, refl_mem_uniformity ht2⟩
       have I := ht this
-      simp? [Completion.dist_self, Real.dist_eq, Completion.dist_comm] at I says
-        simp only [Real.dist_eq, preimage_setOf_eq, mem_setOf_eq, Completion.dist_self,
-          Completion.dist_comm, zero_sub, abs_neg] at I
+      simp? [r, Completion.dist_self, Real.dist_eq, Completion.dist_comm] at I says
+        simp only [Real.dist_eq, mem_setOf_eq, preimage_setOf_eq, Completion.dist_self,
+          Completion.dist_comm, zero_sub, abs_neg, r] at I
       exact lt_of_le_of_lt (le_abs_self _) I
     show t1 ⊆ s
     · rintro ⟨a, b⟩ hp

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -5,6 +5,7 @@ Authors: Sébastien Gouëzel
 -/
 import Mathlib.Topology.UniformSpace.Completion
 import Mathlib.Topology.MetricSpace.Isometry
+import Mathlib.Topology.MetricSpace.Lipschitz
 import Mathlib.Topology.Instances.Real
 
 #align_import topology.metric_space.completion from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"

Removes nonterminal uses of simp at. Replaces most of these with instances of simp? ... says.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

@@ -131,7 +131,9 @@ protected theorem mem_uniformity_dist (s : Set (Completion α × Completion α))
       intro a b hab
       have : ((a, b), (a, a)) ∈ t1 ×ˢ t2 := ⟨hab, refl_mem_uniformity ht2⟩
       have I := ht this
-      simp [Completion.dist_self, Real.dist_eq, Completion.dist_comm] at I
+      simp? [Completion.dist_self, Real.dist_eq, Completion.dist_comm] at I says
+        simp only [Real.dist_eq, preimage_setOf_eq, mem_setOf_eq, Completion.dist_self,
+          Completion.dist_comm, zero_sub, abs_neg] at I
       exact lt_of_le_of_lt (le_abs_self _) I
     show t1 ⊆ s
     · rintro ⟨a, b⟩ hp

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,16 +2,13 @@
 Copyright (c) 2019 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel
-
-! This file was ported from Lean 3 source module topology.metric_space.completion
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.UniformSpace.Completion
 import Mathlib.Topology.MetricSpace.Isometry
 import Mathlib.Topology.Instances.Real
 
+#align_import topology.metric_space.completion from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
+
 /-!
 # The completion of a metric space
 

@@ -169,7 +169,7 @@ protected theorem uniformity_dist : 𝓤 (Completion α) = ⨅ ε > 0, 𝓟 { p
 #align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_dist
 
 /-- Metric space structure on the completion of a pseudo_metric space. -/
-instance : MetricSpace (Completion α) where
+instance instMetricSpace : MetricSpace (Completion α) where
   dist_self := Completion.dist_self
   eq_of_dist_eq_zero := Completion.eq_of_dist_eq_zero _ _
   dist_comm := Completion.dist_comm
@@ -178,6 +178,7 @@ instance : MetricSpace (Completion α) where
   toUniformSpace := by infer_instance
   uniformity_dist := Completion.uniformity_dist
   edist_dist := fun x y ↦ rfl
+#align uniform_space.completion.metric_space UniformSpace.Completion.instMetricSpace
 
 /-- The embedding of a metric space in its completion is an isometry. -/
 theorem coe_isometry : Isometry ((↑) : α → Completion α) :=

As discussed on Zulip

Renames

• supₛ → sSup
• infₛ → sInf
• supᵢ → iSup
• infᵢ → iInf
• bsupₛ → bsSup
• binfₛ → bsInf
• bsupᵢ → biSup
• binfᵢ → biInf
• csupₛ → csSup
• cinfₛ → csInf
• csupᵢ → ciSup
• cinfᵢ → ciInf
• unionₛ → sUnion
• interₛ → sInter
• unionᵢ → iUnion
• interᵢ → iInter
• bunionₛ → bsUnion
• binterₛ → bsInter
• bunionᵢ → biUnion
• binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -157,7 +157,7 @@ protected theorem eq_of_dist_eq_zero (x y : Completion α) (h : dist x y = 0) :
 of the metric space structure. -/
 protected theorem uniformity_dist' :
     𝓤 (Completion α) = ⨅ ε : { ε : ℝ // 0 < ε }, 𝓟 { p | dist p.1 p.2 < ε.val } := by
-  ext s; rw [mem_infᵢ_of_directed]
+  ext s; rw [mem_iInf_of_directed]
   · simp [Completion.mem_uniformity_dist, subset_def]
   · rintro ⟨r, hr⟩ ⟨p, hp⟩
     use ⟨min r p, lt_min hr hp⟩
@@ -165,7 +165,7 @@ protected theorem uniformity_dist' :
 #align uniform_space.completion.uniformity_dist' UniformSpace.Completion.uniformity_dist'
 
 protected theorem uniformity_dist : 𝓤 (Completion α) = ⨅ ε > 0, 𝓟 { p | dist p.1 p.2 < ε } := by
-  simpa [infᵢ_subtype] using @Completion.uniformity_dist' α _
+  simpa [iInf_subtype] using @Completion.uniformity_dist' α _
 #align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_dist
 
 /-- Metric space structure on the completion of a pseudo_metric space. -/

@@ -169,8 +169,7 @@ protected theorem uniformity_dist : 𝓤 (Completion α) = ⨅ ε > 0, 𝓟 { p
 #align uniform_space.completion.uniformity_dist UniformSpace.Completion.uniformity_dist
 
 /-- Metric space structure on the completion of a pseudo_metric space. -/
-instance : MetricSpace (Completion α)
-    where
+instance : MetricSpace (Completion α) where
   dist_self := Completion.dist_self
   eq_of_dist_eq_zero := Completion.eq_of_dist_eq_zero _ _
   dist_comm := Completion.dist_comm
@@ -191,3 +190,25 @@ protected theorem edist_eq (x y : α) : edist (x : Completion α) y = edist x y
 #align uniform_space.completion.edist_eq UniformSpace.Completion.edist_eq
 
 end UniformSpace.Completion
+
+open UniformSpace Completion NNReal
+
+theorem LipschitzWith.completion_extension [MetricSpace β] [CompleteSpace β] {f : α → β}
+    {K : ℝ≥0} (h : LipschitzWith K f) : LipschitzWith K (Completion.extension f) :=
+  LipschitzWith.of_dist_le_mul fun x y => induction_on₂ x y
+    (isClosed_le (by continuity) (by continuity)) <| by
+      simpa only [extension_coe h.uniformContinuous, Completion.dist_eq] using h.dist_le_mul
+
+theorem LipschitzWith.completion_map [PseudoMetricSpace β] {f : α → β} {K : ℝ≥0}
+    (h : LipschitzWith K f) : LipschitzWith K (Completion.map f) :=
+  one_mul K ▸ (coe_isometry.lipschitz.comp h).completion_extension
+
+theorem Isometry.completion_extension [MetricSpace β] [CompleteSpace β] {f : α → β}
+    (h : Isometry f) : Isometry (Completion.extension f) :=
+  Isometry.of_dist_eq fun x y => induction_on₂ x y
+    (isClosed_eq (by continuity) (by continuity)) fun _ _ ↦ by
+      simp only [extension_coe h.uniformContinuous, Completion.dist_eq, h.dist_eq]
+
+theorem Isometry.completion_map [PseudoMetricSpace β] {f : α → β}
+    (h : Isometry f) : Isometry (Completion.map f) :=
+  (coe_isometry.comp h).completion_extension