topology.uniform_space.completion ⟷ Mathlib.Topology.UniformSpace.Completion

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

@@ -154,7 +154,7 @@ theorem mem_uniformity {s : Set (CauchyFilter α × CauchyFilter α)} :
 #print CauchyFilter.mem_uniformity' /-
 theorem mem_uniformity' {s : Set (CauchyFilter α × CauchyFilter α)} :
     s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ f g : CauchyFilter α, t ∈ f.1 ×ᶠ g.1 → (f, g) ∈ s :=
-  mem_uniformity.trans <| bex_congr fun t h => Prod.forall
+  mem_uniformity.trans <| exists₂_congr fun t h => Prod.forall
 #align Cauchy.mem_uniformity' CauchyFilter.mem_uniformity'
 -/
 

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

@@ -237,7 +237,7 @@ theorem nonempty_cauchyFilter_iff : Nonempty (CauchyFilter α) ↔ Nonempty α :
 
 section
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:339:40: warning: unsupported option eqn_compiler.zeta -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:340:40: warning: unsupported option eqn_compiler.zeta -/
 set_option eqn_compiler.zeta true
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/

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

@@ -272,9 +272,9 @@ def extend (f : α → β) : CauchyFilter α → β :=
 #align Cauchy.extend CauchyFilter.extend
 -/
 
-section SeparatedSpace
+section T0Space
 
-variable [SeparatedSpace β]
+variable [T0Space β]
 
 #print CauchyFilter.extend_pureCauchy /-
 theorem extend_pureCauchy {f : α → β} (hf : UniformContinuous f) (a : α) :
@@ -284,7 +284,7 @@ theorem extend_pureCauchy {f : α → β} (hf : UniformContinuous f) (a : α) :
 #align Cauchy.extend_pure_cauchy CauchyFilter.extend_pureCauchy
 -/
 
-end SeparatedSpace
+end T0Space
 
 variable [CompleteSpace β]
 
@@ -304,9 +304,8 @@ end Extend
 end
 
 #print CauchyFilter.cauchyFilter_eq /-
-theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpace α]
-    [SeparatedSpace α] {f g : CauchyFilter α} :
-    lim f.1 = lim g.1 ↔ (f, g) ∈ separationRel (CauchyFilter α) :=
+theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpace α] [T0Space α]
+    {f g : CauchyFilter α} : lim f.1 = lim g.1 ↔ (f, g) ∈ Inseparable (CauchyFilter α) :=
   by
   constructor
   · intro e s hs
@@ -318,10 +317,10 @@ theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [Complete
         ⟨_, f.2.le_nhds_lim (mem_nhds_right (lim f.1) du), _,
           g.2.le_nhds_lim (mem_nhds_left (lim g.1) du), fun x h => _⟩
     cases' x with a b; cases' h with h₁ h₂
-    rw [← e] at h₂ 
+    rw [← e] at h₂
     exact dt ⟨_, h₁, h₂⟩
   · intro H
-    refine' separated_def.1 (by infer_instance) _ _ fun t tu => _
+    refine' t0Space_iff_uniformity.1 (by infer_instance) _ _ fun t tu => _
     rcases mem_uniformity_isClosed tu with ⟨d, du, dc, dt⟩
     refine'
       H {p | (lim p.1.1, lim p.2.1) ∈ t} (CauchyFilter.mem_uniformity'.2 ⟨d, du, fun f g h => _⟩)
@@ -332,22 +331,22 @@ theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [Complete
       rw [closure_eq_cluster_pts]
       exact f.2.1.mono (le_inf f.2.le_nhds_lim (le_principal_iff.2 xf))
     have := dc.closure_subset_iff.2 h
-    rw [closure_prod_eq] at this 
+    rw [closure_prod_eq] at this
     refine' dt (this ⟨_, _⟩) <;> dsimp <;> apply limc <;> assumption
 #align Cauchy.Cauchy_eq CauchyFilter.cauchyFilter_eq
 -/
 
 section
 
-attribute [local instance] UniformSpace.separationSetoid
+attribute [local instance] inseparableSetoid
 
 #print CauchyFilter.separated_pureCauchy_injective /-
-theorem separated_pureCauchy_injective {α : Type _} [UniformSpace α] [s : SeparatedSpace α] :
+theorem separated_pureCauchy_injective {α : Type _} [UniformSpace α] [s : T0Space α] :
     Function.Injective fun a : α => ⟦pureCauchy a⟧
   | a, b, h =>
-    separated_def.1 s _ _ fun s hs =>
+    t0Space_iff_uniformity.1 s _ _ fun s hs =>
       let ⟨t, ht, hts⟩ := by
-        rw [← (@uniform_embedding_pure_cauchy α _).comap_uniformity, Filter.mem_comap] at hs  <;>
+        rw [← (@uniform_embedding_pure_cauchy α _).comap_uniformity, Filter.mem_comap] at hs <;>
           exact hs
       have : (pureCauchy a, pureCauchy b) ∈ t := Quotient.exact h t ht
       @hts (a, b) this
@@ -358,7 +357,7 @@ end
 
 end CauchyFilter
 
-attribute [local instance] UniformSpace.separationSetoid
+attribute [local instance] inseparableSetoid
 
 open CauchyFilter Set
 
@@ -370,9 +369,8 @@ variable {β : Type _} [UniformSpace β]
 
 variable {γ : Type _} [UniformSpace γ]
 
-#print UniformSpace.completeSpace_separation /-
-instance completeSpace_separation [h : CompleteSpace α] :
-    CompleteSpace (Quotient (separationSetoid α)) :=
+#print SeparationQuotient.instCompleteSpace /-
+instance instCompleteSpace [h : CompleteSpace α] : CompleteSpace (Quotient (inseparableSetoid α)) :=
   ⟨fun f => fun hf : Cauchy f =>
     have : Cauchy (f.comap fun x => ⟦x⟧) :=
       hf.comap' comap_quotient_le_uniformity <| hf.left.comap_of_surj (surjective_quotient_mk' _)
@@ -380,32 +378,32 @@ instance completeSpace_separation [h : CompleteSpace α] :
     ⟨⟦x⟧,
       (comap_le_comap_iff <| by simp).1
         (hx.trans <| map_le_iff_le_comap.1 continuous_quotient_mk'.ContinuousAt)⟩⟩
-#align uniform_space.complete_space_separation UniformSpace.completeSpace_separation
+#align uniform_space.complete_space_separation SeparationQuotient.instCompleteSpace
 -/
 
 #print UniformSpace.Completion /-
 /-- Hausdorff completion of `α` -/
 def Completion :=
-  Quotient (separationSetoid <| CauchyFilter α)
+  Quotient (inseparableSetoid <| CauchyFilter α)
 #align uniform_space.completion UniformSpace.Completion
 -/
 
 namespace Completion
 
 instance [Inhabited α] : Inhabited (Completion α) :=
-  Quotient.inhabited (separationSetoid (CauchyFilter α))
+  Quotient.inhabited (inseparableSetoid (CauchyFilter α))
 
 instance (priority := 50) : UniformSpace (Completion α) :=
-  separationSetoid.uniformSpace
+  inseparableSetoid.uniformSpace
 
 instance : CompleteSpace (Completion α) :=
-  UniformSpace.completeSpace_separation (CauchyFilter α)
+  SeparationQuotient.instCompleteSpace (CauchyFilter α)
 
-instance : SeparatedSpace (Completion α) :=
-  UniformSpace.separated_separation
+instance : T0Space (Completion α) :=
+  SeparationQuotient.instT0Space
 
 instance : T3Space (Completion α) :=
-  separated_t3
+  RegularSpace.t3Space_iff_t0Space
 
 /-- Automatic coercion from `α` to its completion. Not always injective. -/
 instance : CoeTC α (Completion α) :=
@@ -492,14 +490,14 @@ theorem continuous_coe : Continuous (coe : α → Completion α) :=
 -/
 
 #print UniformSpace.Completion.uniformEmbedding_coe /-
-theorem uniformEmbedding_coe [SeparatedSpace α] : UniformEmbedding (coe : α → Completion α) :=
+theorem uniformEmbedding_coe [T0Space α] : UniformEmbedding (coe : α → Completion α) :=
   { comap_uniformity := comap_coe_eq_uniformity α
     inj := separated_pureCauchy_injective }
 #align uniform_space.completion.uniform_embedding_coe UniformSpace.Completion.uniformEmbedding_coe
 -/
 
 #print UniformSpace.Completion.coe_injective /-
-theorem coe_injective [SeparatedSpace α] : Function.Injective (coe : α → Completion α) :=
+theorem coe_injective [T0Space α] : Function.Injective (coe : α → Completion α) :=
   UniformEmbedding.inj (uniformEmbedding_coe _)
 #align uniform_space.completion.coe_injective UniformSpace.Completion.coe_injective
 -/
@@ -514,7 +512,7 @@ theorem denseInducing_coe : DenseInducing (coe : α → Completion α) :=
 
 #print UniformSpace.Completion.UniformCompletion.completeEquivSelf /-
 /-- The uniform bijection between a complete space and its uniform completion. -/
-def UniformCompletion.completeEquivSelf [CompleteSpace α] [SeparatedSpace α] : Completion α ≃ᵤ α :=
+def UniformCompletion.completeEquivSelf [CompleteSpace α] [T0Space α] : Completion α ≃ᵤ α :=
   AbstractCompletion.compareEquiv Completion.cPkg AbstractCompletion.ofComplete
 #align uniform_space.completion.uniform_completion.complete_equiv_self UniformSpace.Completion.UniformCompletion.completeEquivSelf
 -/
@@ -528,7 +526,7 @@ instance separableSpace_completion [SeparableSpace α] : SeparableSpace (Complet
 -/
 
 #print UniformSpace.Completion.denseEmbedding_coe /-
-theorem denseEmbedding_coe [SeparatedSpace α] : DenseEmbedding (coe : α → Completion α) :=
+theorem denseEmbedding_coe [T0Space α] : DenseEmbedding (coe : α → Completion α) :=
   { denseInducing_coe with inj := separated_pureCauchy_injective }
 #align uniform_space.completion.dense_embedding_coe UniformSpace.Completion.denseEmbedding_coe
 -/
@@ -626,13 +624,13 @@ end CompleteSpace
 
 #print UniformSpace.Completion.extension_coe /-
 @[simp]
-theorem extension_coe [SeparatedSpace β] (hf : UniformContinuous f) (a : α) :
+theorem extension_coe [T0Space β] (hf : UniformContinuous f) (a : α) :
     (Completion.extension f) a = f a :=
   cPkg.extend_coe hf a
 #align uniform_space.completion.extension_coe UniformSpace.Completion.extension_coe
 -/
 
-variable [SeparatedSpace β] [CompleteSpace β]
+variable [T0Space β] [CompleteSpace β]
 
 #print UniformSpace.Completion.extension_unique /-
 theorem extension_unique (hf : UniformContinuous f) {g : Completion α → β}
@@ -697,7 +695,7 @@ theorem map_id : Completion.map (@id α) = id :=
 -/
 
 #print UniformSpace.Completion.extension_map /-
-theorem extension_map [CompleteSpace γ] [SeparatedSpace γ] {f : β → γ} {g : α → β}
+theorem extension_map [CompleteSpace γ] [T0Space γ] {f : β → γ} {g : α → β}
     (hf : UniformContinuous f) (hg : UniformContinuous g) :
     Completion.extension f ∘ Completion.map g = Completion.extension (f ∘ g) :=
   Completion.ext (continuous_extension.comp continuous_map) continuous_extension <| by
@@ -777,9 +775,9 @@ protected def extension₂ (f : α → β → γ) : Completion α → Completion
 #align uniform_space.completion.extension₂ UniformSpace.Completion.extension₂
 -/
 
-section SeparatedSpace
+section T0Space
 
-variable [SeparatedSpace γ] {f}
+variable [T0Space γ] {f}
 
 #print UniformSpace.Completion.extension₂_coe_coe /-
 @[simp]
@@ -789,7 +787,7 @@ theorem extension₂_coe_coe (hf : UniformContinuous₂ f) (a : α) (b : β) :
 #align uniform_space.completion.extension₂_coe_coe UniformSpace.Completion.extension₂_coe_coe
 -/
 
-end SeparatedSpace
+end T0Space
 
 variable [CompleteSpace γ] (f)
 

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

@@ -3,7 +3,7 @@ Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl
 -/
-import Mathbin.Topology.UniformSpace.AbstractCompletion
+import Topology.UniformSpace.AbstractCompletion
 
 #align_import topology.uniform_space.completion from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
 
@@ -237,7 +237,7 @@ theorem nonempty_cauchyFilter_iff : Nonempty (CauchyFilter α) ↔ Nonempty α :
 
 section
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:334:40: warning: unsupported option eqn_compiler.zeta -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:339:40: warning: unsupported option eqn_compiler.zeta -/
 set_option eqn_compiler.zeta true
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/

mathlib commit https://github.com/leanprover-community/mathlib/commit/001ffdc42920050657fd45bd2b8bfbec8eaaeb29

@@ -375,7 +375,7 @@ instance completeSpace_separation [h : CompleteSpace α] :
     CompleteSpace (Quotient (separationSetoid α)) :=
   ⟨fun f => fun hf : Cauchy f =>
     have : Cauchy (f.comap fun x => ⟦x⟧) :=
-      hf.comap' comap_quotient_le_uniformity <| hf.left.comap_of_surj (surjective_quotient_mk _)
+      hf.comap' comap_quotient_le_uniformity <| hf.left.comap_of_surj (surjective_quotient_mk' _)
     let ⟨x, (hx : (f fun x => ⟦x⟧) ≤ 𝓝 x)⟩ := CompleteSpace.complete this
     ⟨⟦x⟧,
       (comap_le_comap_iff <| by simp).1

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

@@ -2,14 +2,11 @@
 Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl
-
-! This file was ported from Lean 3 source module topology.uniform_space.completion
-! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.UniformSpace.AbstractCompletion
 
+#align_import topology.uniform_space.completion from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
+
 /-!
 # Hausdorff completions of uniform spaces
 

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

@@ -86,9 +86,11 @@ def gen (s : Set (α × α)) : Set (CauchyFilter α × CauchyFilter α) :=
 #align Cauchy.gen CauchyFilter.gen
 -/
 
+#print CauchyFilter.monotone_gen /-
 theorem monotone_gen : Monotone gen :=
   monotone_setOf fun p => @Filter.monotone_mem _ (p.1.val ×ᶠ p.2.val)
 #align Cauchy.monotone_gen CauchyFilter.monotone_gen
+-/
 
 private theorem symm_gen : map Prod.swap ((𝓤 α).lift' gen) ≤ (𝓤 α).lift' gen :=
   calc
@@ -145,15 +147,19 @@ instance : UniformSpace (CauchyFilter α) :=
       symm := symm_gen
       comp := comp_gen }
 
+#print CauchyFilter.mem_uniformity /-
 theorem mem_uniformity {s : Set (CauchyFilter α × CauchyFilter α)} :
     s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, gen t ⊆ s :=
   mem_lift'_sets monotone_gen
 #align Cauchy.mem_uniformity CauchyFilter.mem_uniformity
+-/
 
+#print CauchyFilter.mem_uniformity' /-
 theorem mem_uniformity' {s : Set (CauchyFilter α × CauchyFilter α)} :
     s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ f g : CauchyFilter α, t ∈ f.1 ×ᶠ g.1 → (f, g) ∈ s :=
   mem_uniformity.trans <| bex_congr fun t h => Prod.forall
 #align Cauchy.mem_uniformity' CauchyFilter.mem_uniformity'
+-/
 
 #print CauchyFilter.pureCauchy /-
 /-- Embedding of `α` into its completion `Cauchy α` -/
@@ -162,6 +168,7 @@ def pureCauchy (a : α) : CauchyFilter α :=
 #align Cauchy.pure_cauchy CauchyFilter.pureCauchy
 -/
 
+#print CauchyFilter.uniformInducing_pureCauchy /-
 theorem uniformInducing_pureCauchy : UniformInducing (pure_cauchy : α → CauchyFilter α) :=
   ⟨have : (preimage fun x : α × α => (pure_cauchy x.fst, pure_cauchy x.snd)) ∘ gen = id :=
       funext fun s =>
@@ -172,13 +179,17 @@ theorem uniformInducing_pureCauchy : UniformInducing (pure_cauchy : α → Cauch
         comap_lift'_eq
       _ = 𝓤 α := by simp [this]⟩
 #align Cauchy.uniform_inducing_pure_cauchy CauchyFilter.uniformInducing_pureCauchy
+-/
 
+#print CauchyFilter.uniformEmbedding_pureCauchy /-
 theorem uniformEmbedding_pureCauchy : UniformEmbedding (pure_cauchy : α → CauchyFilter α) :=
   { uniform_inducing_pure_cauchy with
     inj := fun a₁ a₂ h => pure_injective <| Subtype.ext_iff_val.1 h }
 #align Cauchy.uniform_embedding_pure_cauchy CauchyFilter.uniformEmbedding_pureCauchy
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print CauchyFilter.denseRange_pureCauchy /-
 theorem denseRange_pureCauchy : DenseRange pure_cauchy := fun f =>
   by
   have h_ex : ∀ s ∈ 𝓤 (CauchyFilter α), ∃ y : α, (f, pure_cauchy y) ∈ s := fun s hs =>
@@ -202,14 +213,19 @@ theorem denseRange_pureCauchy : DenseRange pure_cauchy := fun f =>
         ⟨mem_range_self y, hy⟩
       ⟨_, this⟩
 #align Cauchy.dense_range_pure_cauchy CauchyFilter.denseRange_pureCauchy
+-/
 
+#print CauchyFilter.denseInducing_pureCauchy /-
 theorem denseInducing_pureCauchy : DenseInducing pure_cauchy :=
   uniform_inducing_pure_cauchy.DenseInducing dense_range_pure_cauchy
 #align Cauchy.dense_inducing_pure_cauchy CauchyFilter.denseInducing_pureCauchy
+-/
 
+#print CauchyFilter.denseEmbedding_pureCauchy /-
 theorem denseEmbedding_pureCauchy : DenseEmbedding pure_cauchy :=
   uniform_embedding_pure_cauchy.DenseEmbedding dense_range_pure_cauchy
 #align Cauchy.dense_embedding_pure_cauchy CauchyFilter.denseEmbedding_pureCauchy
+-/
 
 #print CauchyFilter.nonempty_cauchyFilter_iff /-
 theorem nonempty_cauchyFilter_iff : Nonempty (CauchyFilter α) ↔ Nonempty α :=
@@ -275,6 +291,7 @@ end SeparatedSpace
 
 variable [CompleteSpace β]
 
+#print CauchyFilter.uniformContinuous_extend /-
 theorem uniformContinuous_extend {f : α → β} : UniformContinuous (extend f) :=
   by
   by_cases hf : UniformContinuous f
@@ -283,11 +300,13 @@ theorem uniformContinuous_extend {f : α → β} : UniformContinuous (extend f)
   · rw [extend, if_neg hf]
     exact uniformContinuous_of_const fun a b => by congr
 #align Cauchy.uniform_continuous_extend CauchyFilter.uniformContinuous_extend
+-/
 
 end Extend
 
 end
 
+#print CauchyFilter.cauchyFilter_eq /-
 theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpace α]
     [SeparatedSpace α] {f g : CauchyFilter α} :
     lim f.1 = lim g.1 ↔ (f, g) ∈ separationRel (CauchyFilter α) :=
@@ -319,11 +338,13 @@ theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [Complete
     rw [closure_prod_eq] at this 
     refine' dt (this ⟨_, _⟩) <;> dsimp <;> apply limc <;> assumption
 #align Cauchy.Cauchy_eq CauchyFilter.cauchyFilter_eq
+-/
 
 section
 
 attribute [local instance] UniformSpace.separationSetoid
 
+#print CauchyFilter.separated_pureCauchy_injective /-
 theorem separated_pureCauchy_injective {α : Type _} [UniformSpace α] [s : SeparatedSpace α] :
     Function.Injective fun a : α => ⟦pureCauchy a⟧
   | a, b, h =>
@@ -334,6 +355,7 @@ theorem separated_pureCauchy_injective {α : Type _} [UniformSpace α] [s : Sepa
       have : (pureCauchy a, pureCauchy b) ∈ t := Quotient.exact h t ht
       @hts (a, b) this
 #align Cauchy.separated_pure_cauchy_injective CauchyFilter.separated_pureCauchy_injective
+-/
 
 end
 
@@ -392,11 +414,14 @@ instance : T3Space (Completion α) :=
 instance : CoeTC α (Completion α) :=
   ⟨Quotient.mk' ∘ pureCauchy⟩
 
+#print UniformSpace.Completion.coe_eq /-
 -- note [use has_coe_t]
 protected theorem coe_eq : (coe : α → Completion α) = Quotient.mk' ∘ pureCauchy :=
   rfl
 #align uniform_space.completion.coe_eq UniformSpace.Completion.coe_eq
+-/
 
+#print UniformSpace.Completion.comap_coe_eq_uniformity /-
 theorem comap_coe_eq_uniformity :
     ((𝓤 _).comap fun p : α × α => ((p.1 : Completion α), (p.2 : Completion α))) = 𝓤 α :=
   by
@@ -410,16 +435,21 @@ theorem comap_coe_eq_uniformity :
     Filter.comap _ (Filter.comap _ (𝓤 <| Quotient <| separation_setoid <| CauchyFilter α)) = 𝓤 α
   rw [comap_quotient_eq_uniformity, uniform_embedding_pure_cauchy.comap_uniformity]
 #align uniform_space.completion.comap_coe_eq_uniformity UniformSpace.Completion.comap_coe_eq_uniformity
+-/
 
+#print UniformSpace.Completion.uniformInducing_coe /-
 theorem uniformInducing_coe : UniformInducing (coe : α → Completion α) :=
   ⟨comap_coe_eq_uniformity α⟩
 #align uniform_space.completion.uniform_inducing_coe UniformSpace.Completion.uniformInducing_coe
+-/
 
 variable {α}
 
+#print UniformSpace.Completion.denseRange_coe /-
 theorem denseRange_coe : DenseRange (coe : α → Completion α) :=
   denseRange_pureCauchy.Quotient
 #align uniform_space.completion.dense_range_coe UniformSpace.Completion.denseRange_coe
+-/
 
 variable (α)
 
@@ -452,28 +482,38 @@ theorem nonempty_completion_iff : Nonempty (Completion α) ↔ Nonempty α :=
 #align uniform_space.completion.nonempty_completion_iff UniformSpace.Completion.nonempty_completion_iff
 -/
 
+#print UniformSpace.Completion.uniformContinuous_coe /-
 theorem uniformContinuous_coe : UniformContinuous (coe : α → Completion α) :=
   cPkg.uniformContinuous_coe
 #align uniform_space.completion.uniform_continuous_coe UniformSpace.Completion.uniformContinuous_coe
+-/
 
+#print UniformSpace.Completion.continuous_coe /-
 theorem continuous_coe : Continuous (coe : α → Completion α) :=
   cPkg.continuous_coe
 #align uniform_space.completion.continuous_coe UniformSpace.Completion.continuous_coe
+-/
 
+#print UniformSpace.Completion.uniformEmbedding_coe /-
 theorem uniformEmbedding_coe [SeparatedSpace α] : UniformEmbedding (coe : α → Completion α) :=
   { comap_uniformity := comap_coe_eq_uniformity α
     inj := separated_pureCauchy_injective }
 #align uniform_space.completion.uniform_embedding_coe UniformSpace.Completion.uniformEmbedding_coe
+-/
 
+#print UniformSpace.Completion.coe_injective /-
 theorem coe_injective [SeparatedSpace α] : Function.Injective (coe : α → Completion α) :=
   UniformEmbedding.inj (uniformEmbedding_coe _)
 #align uniform_space.completion.coe_injective UniformSpace.Completion.coe_injective
+-/
 
 variable {α}
 
+#print UniformSpace.Completion.denseInducing_coe /-
 theorem denseInducing_coe : DenseInducing (coe : α → Completion α) :=
   { (uniformInducing_coe α).Inducing with dense := denseRange_coe }
 #align uniform_space.completion.dense_inducing_coe UniformSpace.Completion.denseInducing_coe
+-/
 
 #print UniformSpace.Completion.UniformCompletion.completeEquivSelf /-
 /-- The uniform bijection between a complete space and its uniform completion. -/
@@ -490,27 +530,36 @@ instance separableSpace_completion [SeparableSpace α] : SeparableSpace (Complet
 #align uniform_space.completion.separable_space_completion UniformSpace.Completion.separableSpace_completion
 -/
 
+#print UniformSpace.Completion.denseEmbedding_coe /-
 theorem denseEmbedding_coe [SeparatedSpace α] : DenseEmbedding (coe : α → Completion α) :=
   { denseInducing_coe with inj := separated_pureCauchy_injective }
 #align uniform_space.completion.dense_embedding_coe UniformSpace.Completion.denseEmbedding_coe
+-/
 
+#print UniformSpace.Completion.denseRange_coe₂ /-
 theorem denseRange_coe₂ :
     DenseRange fun x : α × β => ((x.1 : Completion α), (x.2 : Completion β)) :=
   denseRange_coe.Prod_map denseRange_coe
 #align uniform_space.completion.dense_range_coe₂ UniformSpace.Completion.denseRange_coe₂
+-/
 
+#print UniformSpace.Completion.denseRange_coe₃ /-
 theorem denseRange_coe₃ :
     DenseRange fun x : α × β × γ =>
       ((x.1 : Completion α), ((x.2.1 : Completion β), (x.2.2 : Completion γ))) :=
   denseRange_coe.Prod_map denseRange_coe₂
 #align uniform_space.completion.dense_range_coe₃ UniformSpace.Completion.denseRange_coe₃
+-/
 
+#print UniformSpace.Completion.induction_on /-
 @[elab_as_elim]
 theorem induction_on {p : Completion α → Prop} (a : Completion α) (hp : IsClosed {a | p a})
     (ih : ∀ a : α, p a) : p a :=
   isClosed_property denseRange_coe hp ih a
 #align uniform_space.completion.induction_on UniformSpace.Completion.induction_on
+-/
 
+#print UniformSpace.Completion.induction_on₂ /-
 @[elab_as_elim]
 theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Completion α) (b : Completion β)
     (hp : IsClosed {x : Completion α × Completion β | p x.1 x.2}) (ih : ∀ (a : α) (b : β), p a b) :
@@ -519,7 +568,9 @@ theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Comp
     isClosed_property denseRange_coe₂ hp fun ⟨a, b⟩ => ih a b
   this (a, b)
 #align uniform_space.completion.induction_on₂ UniformSpace.Completion.induction_on₂
+-/
 
+#print UniformSpace.Completion.induction_on₃ /-
 @[elab_as_elim]
 theorem induction_on₃ {p : Completion α → Completion β → Completion γ → Prop} (a : Completion α)
     (b : Completion β) (c : Completion γ)
@@ -529,17 +580,22 @@ theorem induction_on₃ {p : Completion α → Completion β → Completion γ 
     isClosed_property denseRange_coe₃ hp fun ⟨a, b, c⟩ => ih a b c
   this (a, b, c)
 #align uniform_space.completion.induction_on₃ UniformSpace.Completion.induction_on₃
+-/
 
+#print UniformSpace.Completion.ext /-
 theorem ext {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
     (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) : f = g :=
   cPkg.funext hf hg h
 #align uniform_space.completion.ext UniformSpace.Completion.ext
+-/
 
+#print UniformSpace.Completion.ext' /-
 theorem ext' {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
     (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) (a : Completion α) :
     f a = g a :=
   congr_fun (ext hf hg h) a
 #align uniform_space.completion.ext' UniformSpace.Completion.ext'
+-/
 
 section Extension
 
@@ -557,35 +613,45 @@ section CompleteSpace
 
 variable [CompleteSpace β]
 
+#print UniformSpace.Completion.uniformContinuous_extension /-
 theorem uniformContinuous_extension : UniformContinuous (Completion.extension f) :=
   cPkg.uniformContinuous_extend
 #align uniform_space.completion.uniform_continuous_extension UniformSpace.Completion.uniformContinuous_extension
+-/
 
+#print UniformSpace.Completion.continuous_extension /-
 theorem continuous_extension : Continuous (Completion.extension f) :=
   cPkg.continuous_extend
 #align uniform_space.completion.continuous_extension UniformSpace.Completion.continuous_extension
+-/
 
 end CompleteSpace
 
+#print UniformSpace.Completion.extension_coe /-
 @[simp]
 theorem extension_coe [SeparatedSpace β] (hf : UniformContinuous f) (a : α) :
     (Completion.extension f) a = f a :=
   cPkg.extend_coe hf a
 #align uniform_space.completion.extension_coe UniformSpace.Completion.extension_coe
+-/
 
 variable [SeparatedSpace β] [CompleteSpace β]
 
+#print UniformSpace.Completion.extension_unique /-
 theorem extension_unique (hf : UniformContinuous f) {g : Completion α → β}
     (hg : UniformContinuous g) (h : ∀ a : α, f a = g (a : Completion α)) :
     Completion.extension f = g :=
   cPkg.extend_unique hf hg h
 #align uniform_space.completion.extension_unique UniformSpace.Completion.extension_unique
+-/
 
+#print UniformSpace.Completion.extension_comp_coe /-
 @[simp]
 theorem extension_comp_coe {f : Completion α → β} (hf : UniformContinuous f) :
     Completion.extension (f ∘ coe) = f :=
   cPkg.extend_comp_coe hf
 #align uniform_space.completion.extension_comp_coe UniformSpace.Completion.extension_comp_coe
+-/
 
 end Extension
 
@@ -600,23 +666,31 @@ protected def map (f : α → β) : Completion α → Completion β :=
 #align uniform_space.completion.map UniformSpace.Completion.map
 -/
 
+#print UniformSpace.Completion.uniformContinuous_map /-
 theorem uniformContinuous_map : UniformContinuous (Completion.map f) :=
   cPkg.uniformContinuous_map cPkg f
 #align uniform_space.completion.uniform_continuous_map UniformSpace.Completion.uniformContinuous_map
+-/
 
+#print UniformSpace.Completion.continuous_map /-
 theorem continuous_map : Continuous (Completion.map f) :=
   cPkg.continuous_map cPkg f
 #align uniform_space.completion.continuous_map UniformSpace.Completion.continuous_map
+-/
 
+#print UniformSpace.Completion.map_coe /-
 @[simp]
 theorem map_coe (hf : UniformContinuous f) (a : α) : (Completion.map f) a = f a :=
   cPkg.map_coe cPkg hf a
 #align uniform_space.completion.map_coe UniformSpace.Completion.map_coe
+-/
 
+#print UniformSpace.Completion.map_unique /-
 theorem map_unique {f : α → β} {g : Completion α → Completion β} (hg : UniformContinuous g)
     (h : ∀ a : α, ↑(f a) = g a) : Completion.map f = g :=
   cPkg.map_unique cPkg hg h
 #align uniform_space.completion.map_unique UniformSpace.Completion.map_unique
+-/
 
 #print UniformSpace.Completion.map_id /-
 @[simp]
@@ -634,10 +708,12 @@ theorem extension_map [CompleteSpace γ] [SeparatedSpace γ] {f : β → γ} {g
 #align uniform_space.completion.extension_map UniformSpace.Completion.extension_map
 -/
 
+#print UniformSpace.Completion.map_comp /-
 theorem map_comp {g : β → γ} {f : α → β} (hg : UniformContinuous g) (hf : UniformContinuous f) :
     Completion.map g ∘ Completion.map f = Completion.map (g ∘ f) :=
   extension_map ((uniformContinuous_coe _).comp hg) hf
 #align uniform_space.completion.map_comp UniformSpace.Completion.map_comp
+-/
 
 end Map
 
@@ -708,19 +784,23 @@ section SeparatedSpace
 
 variable [SeparatedSpace γ] {f}
 
+#print UniformSpace.Completion.extension₂_coe_coe /-
 @[simp]
 theorem extension₂_coe_coe (hf : UniformContinuous₂ f) (a : α) (b : β) :
     Completion.extension₂ f a b = f a b :=
   cPkg.extension₂_coe_coe cPkg hf a b
 #align uniform_space.completion.extension₂_coe_coe UniformSpace.Completion.extension₂_coe_coe
+-/
 
 end SeparatedSpace
 
 variable [CompleteSpace γ] (f)
 
+#print UniformSpace.Completion.uniformContinuous_extension₂ /-
 theorem uniformContinuous_extension₂ : UniformContinuous₂ (Completion.extension₂ f) :=
   cPkg.uniformContinuous_extension₂ cPkg f
 #align uniform_space.completion.uniform_continuous_extension₂ UniformSpace.Completion.uniformContinuous_extension₂
+-/
 
 end Extension₂
 
@@ -735,20 +815,26 @@ protected def map₂ (f : α → β → γ) : Completion α → Completion β 
 #align uniform_space.completion.map₂ UniformSpace.Completion.map₂
 -/
 
+#print UniformSpace.Completion.uniformContinuous_map₂ /-
 theorem uniformContinuous_map₂ (f : α → β → γ) : UniformContinuous₂ (Completion.map₂ f) :=
   cPkg.uniformContinuous_map₂ cPkg cPkg f
 #align uniform_space.completion.uniform_continuous_map₂ UniformSpace.Completion.uniformContinuous_map₂
+-/
 
+#print UniformSpace.Completion.continuous_map₂ /-
 theorem continuous_map₂ {δ} [TopologicalSpace δ] {f : α → β → γ} {a : δ → Completion α}
     {b : δ → Completion β} (ha : Continuous a) (hb : Continuous b) :
     Continuous fun d : δ => Completion.map₂ f (a d) (b d) :=
   cPkg.continuous_map₂ cPkg cPkg ha hb
 #align uniform_space.completion.continuous_map₂ UniformSpace.Completion.continuous_map₂
+-/
 
+#print UniformSpace.Completion.map₂_coe_coe /-
 theorem map₂_coe_coe (a : α) (b : β) (f : α → β → γ) (hf : UniformContinuous₂ f) :
     Completion.map₂ f (a : Completion α) (b : Completion β) = f a b :=
   cPkg.map₂_coe_coe cPkg cPkg a b f hf
 #align uniform_space.completion.map₂_coe_coe UniformSpace.Completion.map₂_coe_coe
+-/
 
 end Map₂
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

@@ -106,7 +106,6 @@ private theorem symm_gen : map Prod.swap ((𝓤 α).lift' gen) ≤ (𝓤 α).lif
           have h := fun p : CauchyFilter α × CauchyFilter α => @Filter.prod_comm _ _ p.2.val p.1.val
           simp [Function.comp, h, -Subtype.val_eq_coe, mem_map']
           exact le_rfl)
-    
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -138,7 +137,6 @@ private theorem comp_gen : (((𝓤 α).lift' gen).lift' fun s => compRel s s) 
       exact monotone_id.comp_rel monotone_id
       exact monotone_gen
     _ ≤ (𝓤 α).lift' gen := lift'_mono comp_le_uniformity le_rfl
-    
 
 instance : UniformSpace (CauchyFilter α) :=
   UniformSpace.ofCore
@@ -172,8 +170,7 @@ theorem uniformInducing_pureCauchy : UniformInducing (pure_cauchy : α → Cauch
       comap (fun x : α × α => (pure_cauchy x.fst, pure_cauchy x.snd)) ((𝓤 α).lift' gen) =
           (𝓤 α).lift' ((preimage fun x : α × α => (pure_cauchy x.fst, pure_cauchy x.snd)) ∘ gen) :=
         comap_lift'_eq
-      _ = 𝓤 α := by simp [this]
-      ⟩
+      _ = 𝓤 α := by simp [this]⟩
 #align Cauchy.uniform_inducing_pure_cauchy CauchyFilter.uniformInducing_pureCauchy
 
 theorem uniformEmbedding_pureCauchy : UniformEmbedding (pure_cauchy : α → CauchyFilter α) :=

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

@@ -73,7 +73,7 @@ namespace CauchyFilter
 
 section
 
-parameter {α : Type u}[UniformSpace α]
+parameter {α : Type u} [UniformSpace α]
 
 variable {β : Type v} {γ : Type w}
 
@@ -82,7 +82,7 @@ variable [UniformSpace β] [UniformSpace γ]
 #print CauchyFilter.gen /-
 /-- The pairs of Cauchy filters generated by a set. -/
 def gen (s : Set (α × α)) : Set (CauchyFilter α × CauchyFilter α) :=
-  { p | s ∈ p.1.val ×ᶠ p.2.val }
+  {p | s ∈ p.1.val ×ᶠ p.2.val}
 #align Cauchy.gen CauchyFilter.gen
 -/
 
@@ -93,7 +93,7 @@ theorem monotone_gen : Monotone gen :=
 private theorem symm_gen : map Prod.swap ((𝓤 α).lift' gen) ≤ (𝓤 α).lift' gen :=
   calc
     map Prod.swap ((𝓤 α).lift' gen) =
-        (𝓤 α).lift' fun s : Set (α × α) => { p | s ∈ p.2.val ×ᶠ p.1.val } :=
+        (𝓤 α).lift' fun s : Set (α × α) => {p | s ∈ p.2.val ×ᶠ p.1.val} :=
       by
       delta gen
       simp [map_lift'_eq, monotone_set_of, Filter.monotone_mem, Function.comp,
@@ -192,7 +192,7 @@ theorem denseRange_pureCauchy : DenseRange pure_cauchy := fun f =>
     let ⟨x, (hx : x ∈ t)⟩ := f.property.left.nonempty_of_mem ht
     have : t'' ∈ f.val ×ᶠ pure x :=
       mem_prod_iff.mpr
-        ⟨t, ht, { y : α | (x, y) ∈ t' }, h <| mk_mem_prod hx hx,
+        ⟨t, ht, {y : α | (x, y) ∈ t'}, h <| mk_mem_prod hx hx,
           fun ⟨a, b⟩ ⟨(h₁ : a ∈ t), (h₂ : (x, b) ∈ t')⟩ =>
           ht'₂ <| prod_mk_mem_compRel (@h (a, x) ⟨h₁, hx⟩) h₂⟩
     ⟨x, ht''₂ <| by dsimp [gen] <;> exact this⟩
@@ -201,7 +201,7 @@ theorem denseRange_pureCauchy : DenseRange pure_cauchy := fun f =>
   exact
     (lift'_ne_bot_iff <| monotone_const.inter monotone_preimage).mpr fun s hs =>
       let ⟨y, hy⟩ := h_ex s hs
-      have : pure_cauchy y ∈ range pure_cauchy ∩ { y : CauchyFilter α | (f, y) ∈ s } :=
+      have : pure_cauchy y ∈ range pure_cauchy ∩ {y : CauchyFilter α | (f, y) ∈ s} :=
         ⟨mem_range_self y, hy⟩
       ⟨_, this⟩
 #align Cauchy.dense_range_pure_cauchy CauchyFilter.denseRange_pureCauchy
@@ -238,7 +238,7 @@ instance : CompleteSpace (CauchyFilter α) :=
       le_lift'.2 fun s hs =>
         let ⟨t, ht₁, (ht₂ : gen t ⊆ s)⟩ := (mem_lift'_sets monotone_gen).mp hs
         let ⟨t', ht', (h : t' ×ˢ t' ⊆ t)⟩ := mem_prod_same_iff.mp (hf.right ht₁)
-        have : t' ⊆ { y : α | (f', pure_cauchy y) ∈ gen t } := fun x hx =>
+        have : t' ⊆ {y : α | (f', pure_cauchy y) ∈ gen t} := fun x hx =>
           (f ×ᶠ pure x).sets_of_superset (prod_mem_prod ht' hx) h
         f.sets_of_superset ht' <| Subset.trans this (preimage_mono ht₂)
     ⟨f', by simp [nhds_eq_uniformity] <;> assumption⟩
@@ -311,7 +311,7 @@ theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [Complete
     refine' separated_def.1 (by infer_instance) _ _ fun t tu => _
     rcases mem_uniformity_isClosed tu with ⟨d, du, dc, dt⟩
     refine'
-      H { p | (lim p.1.1, lim p.2.1) ∈ t } (CauchyFilter.mem_uniformity'.2 ⟨d, du, fun f g h => _⟩)
+      H {p | (lim p.1.1, lim p.2.1) ∈ t} (CauchyFilter.mem_uniformity'.2 ⟨d, du, fun f g h => _⟩)
     rcases mem_prod_iff.1 h with ⟨x, xf, y, yg, h⟩
     have limc : ∀ (f : CauchyFilter α), ∀ x ∈ f.1, lim f.1 ∈ closure x :=
       by
@@ -509,15 +509,15 @@ theorem denseRange_coe₃ :
 #align uniform_space.completion.dense_range_coe₃ UniformSpace.Completion.denseRange_coe₃
 
 @[elab_as_elim]
-theorem induction_on {p : Completion α → Prop} (a : Completion α) (hp : IsClosed { a | p a })
+theorem induction_on {p : Completion α → Prop} (a : Completion α) (hp : IsClosed {a | p a})
     (ih : ∀ a : α, p a) : p a :=
   isClosed_property denseRange_coe hp ih a
 #align uniform_space.completion.induction_on UniformSpace.Completion.induction_on
 
 @[elab_as_elim]
 theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Completion α) (b : Completion β)
-    (hp : IsClosed { x : Completion α × Completion β | p x.1 x.2 })
-    (ih : ∀ (a : α) (b : β), p a b) : p a b :=
+    (hp : IsClosed {x : Completion α × Completion β | p x.1 x.2}) (ih : ∀ (a : α) (b : β), p a b) :
+    p a b :=
   have : ∀ x : Completion α × Completion β, p x.1 x.2 :=
     isClosed_property denseRange_coe₂ hp fun ⟨a, b⟩ => ih a b
   this (a, b)
@@ -526,7 +526,7 @@ theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Comp
 @[elab_as_elim]
 theorem induction_on₃ {p : Completion α → Completion β → Completion γ → Prop} (a : Completion α)
     (b : Completion β) (c : Completion γ)
-    (hp : IsClosed { x : Completion α × Completion β × Completion γ | p x.1 x.2.1 x.2.2 })
+    (hp : IsClosed {x : Completion α × Completion β × Completion γ | p x.1 x.2.1 x.2.2})
     (ih : ∀ (a : α) (b : β) (c : γ), p a b c) : p a b c :=
   have : ∀ x : Completion α × Completion β × Completion γ, p x.1 x.2.1 x.2.2 :=
     isClosed_property denseRange_coe₃ hp fun ⟨a, b, c⟩ => ih a b c

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

@@ -305,7 +305,7 @@ theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [Complete
         ⟨_, f.2.le_nhds_lim (mem_nhds_right (lim f.1) du), _,
           g.2.le_nhds_lim (mem_nhds_left (lim g.1) du), fun x h => _⟩
     cases' x with a b; cases' h with h₁ h₂
-    rw [← e] at h₂
+    rw [← e] at h₂ 
     exact dt ⟨_, h₁, h₂⟩
   · intro H
     refine' separated_def.1 (by infer_instance) _ _ fun t tu => _
@@ -319,7 +319,7 @@ theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [Complete
       rw [closure_eq_cluster_pts]
       exact f.2.1.mono (le_inf f.2.le_nhds_lim (le_principal_iff.2 xf))
     have := dc.closure_subset_iff.2 h
-    rw [closure_prod_eq] at this
+    rw [closure_prod_eq] at this 
     refine' dt (this ⟨_, _⟩) <;> dsimp <;> apply limc <;> assumption
 #align Cauchy.Cauchy_eq CauchyFilter.cauchyFilter_eq
 
@@ -332,7 +332,7 @@ theorem separated_pureCauchy_injective {α : Type _} [UniformSpace α] [s : Sepa
   | a, b, h =>
     separated_def.1 s _ _ fun s hs =>
       let ⟨t, ht, hts⟩ := by
-        rw [← (@uniform_embedding_pure_cauchy α _).comap_uniformity, Filter.mem_comap] at hs <;>
+        rw [← (@uniform_embedding_pure_cauchy α _).comap_uniformity, Filter.mem_comap] at hs  <;>
           exact hs
       have : (pureCauchy a, pureCauchy b) ∈ t := Quotient.exact h t ht
       @hts (a, b) this
@@ -446,8 +446,8 @@ instance AbstractCompletion.inhabited : Inhabited (AbstractCompletion α) :=
 #align uniform_space.completion.abstract_completion.inhabited UniformSpace.Completion.AbstractCompletion.inhabited
 -/
 
-attribute [local instance]
-  AbstractCompletion.uniformStruct AbstractCompletion.complete AbstractCompletion.separation
+attribute [local instance] AbstractCompletion.uniformStruct AbstractCompletion.complete
+  AbstractCompletion.separation
 
 #print UniformSpace.Completion.nonempty_completion_iff /-
 theorem nonempty_completion_iff : Nonempty (Completion α) ↔ Nonempty α :=

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

@@ -55,7 +55,7 @@ open Filter Set
 
 universe u v w x
 
-open uniformity Classical Topology Filter
+open scoped uniformity Classical Topology Filter
 
 #print CauchyFilter /-
 /-- Space of Cauchy filters

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

@@ -86,12 +86,6 @@ def gen (s : Set (α × α)) : Set (CauchyFilter α × CauchyFilter α) :=
 #align Cauchy.gen CauchyFilter.gen
 -/
 
-/- warning: Cauchy.monotone_gen -> CauchyFilter.monotone_gen is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], Monotone.{u1, u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (PartialOrder.toPreorder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.completeBooleanAlgebra.{u1} (Prod.{u1, u1} α α)))))))) (PartialOrder.toPreorder.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Set.completeBooleanAlgebra.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))))))))) (CauchyFilter.gen.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], Monotone.{u1, u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (PartialOrder.toPreorder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instCompleteBooleanAlgebraSet.{u1} (Prod.{u1, u1} α α)))))))) (PartialOrder.toPreorder.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Set.instCompleteBooleanAlgebraSet.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))))))))) (CauchyFilter.gen.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align Cauchy.monotone_gen CauchyFilter.monotone_genₓ'. -/
 theorem monotone_gen : Monotone gen :=
   monotone_setOf fun p => @Filter.monotone_mem _ (p.1.val ×ᶠ p.2.val)
 #align Cauchy.monotone_gen CauchyFilter.monotone_gen
@@ -153,23 +147,11 @@ instance : UniformSpace (CauchyFilter α) :=
       symm := symm_gen
       comp := comp_gen }
 
-/- warning: Cauchy.mem_uniformity -> CauchyFilter.mem_uniformity is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {s : Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))}, Iff (Membership.Mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Filter.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Filter.hasMem.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) s (uniformity.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.uniformSpace.{u1} α _inst_1))) (Exists.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (fun (t : Set.{u1} (Prod.{u1, u1} α α)) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} α α)) (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.hasMem.{u1} (Prod.{u1, u1} α α)) t (uniformity.{u1} α _inst_1)) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} α α)) (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.hasMem.{u1} (Prod.{u1, u1} α α)) t (uniformity.{u1} α _inst_1)) => HasSubset.Subset.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Set.hasSubset.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (CauchyFilter.gen.{u1} α _inst_1 t) s)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {s : Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))}, Iff (Membership.mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Filter.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (instMembershipSetFilter.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) s (uniformity.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (Exists.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (fun (t : Set.{u1} (Prod.{u1, u1} α α)) => And (Membership.mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} α α)) (Filter.{u1} (Prod.{u1, u1} α α)) (instMembershipSetFilter.{u1} (Prod.{u1, u1} α α)) t (uniformity.{u1} α _inst_1)) (HasSubset.Subset.{u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Set.instHasSubsetSet.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (CauchyFilter.gen.{u1} α _inst_1 t) s)))
-Case conversion may be inaccurate. Consider using '#align Cauchy.mem_uniformity CauchyFilter.mem_uniformityₓ'. -/
 theorem mem_uniformity {s : Set (CauchyFilter α × CauchyFilter α)} :
     s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, gen t ⊆ s :=
   mem_lift'_sets monotone_gen
 #align Cauchy.mem_uniformity CauchyFilter.mem_uniformity
 
-/- warning: Cauchy.mem_uniformity' -> CauchyFilter.mem_uniformity' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {s : Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))}, Iff (Membership.Mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Filter.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Filter.hasMem.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) s (uniformity.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.uniformSpace.{u1} α _inst_1))) (Exists.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (fun (t : Set.{u1} (Prod.{u1, u1} α α)) => Exists.{0} (Membership.Mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} α α)) (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.hasMem.{u1} (Prod.{u1, u1} α α)) t (uniformity.{u1} α _inst_1)) (fun (H : Membership.Mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} α α)) (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.hasMem.{u1} (Prod.{u1, u1} α α)) t (uniformity.{u1} α _inst_1)) => forall (f : CauchyFilter.{u1} α _inst_1) (g : CauchyFilter.{u1} α _inst_1), (Membership.Mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} α α)) (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.hasMem.{u1} (Prod.{u1, u1} α α)) t (Filter.prod.{u1, u1} α α (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_1 f) f) (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_1 f) g))) -> (Membership.Mem.{u1, u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1)) (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Set.hasMem.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Prod.mk.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1) f g) s))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {s : Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))}, Iff (Membership.mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Filter.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (instMembershipSetFilter.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) s (uniformity.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (Exists.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (fun (t : Set.{u1} (Prod.{u1, u1} α α)) => And (Membership.mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} α α)) (Filter.{u1} (Prod.{u1, u1} α α)) (instMembershipSetFilter.{u1} (Prod.{u1, u1} α α)) t (uniformity.{u1} α _inst_1)) (forall (f : CauchyFilter.{u1} α _inst_1) (g : CauchyFilter.{u1} α _inst_1), (Membership.mem.{u1, u1} (Set.{u1} (Prod.{u1, u1} α α)) (Filter.{u1} (Prod.{u1, u1} α α)) (instMembershipSetFilter.{u1} (Prod.{u1, u1} α α)) t (Filter.prod.{u1, u1} α α (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_1 f) f) (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_1 f) g))) -> (Membership.mem.{u1, u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1)) (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Set.instMembershipSet.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1))) (Prod.mk.{u1, u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.{u1} α _inst_1) f g) s))))
-Case conversion may be inaccurate. Consider using '#align Cauchy.mem_uniformity' CauchyFilter.mem_uniformity'ₓ'. -/
 theorem mem_uniformity' {s : Set (CauchyFilter α × CauchyFilter α)} :
     s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ f g : CauchyFilter α, t ∈ f.1 ×ᶠ g.1 → (f, g) ∈ s :=
   mem_uniformity.trans <| bex_congr fun t h => Prod.forall
@@ -182,12 +164,6 @@ def pureCauchy (a : α) : CauchyFilter α :=
 #align Cauchy.pure_cauchy CauchyFilter.pureCauchy
 -/
 
-/- warning: Cauchy.uniform_inducing_pure_cauchy -> CauchyFilter.uniformInducing_pureCauchy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], UniformInducing.{u1, u1} α (CauchyFilter.{u1} α _inst_1) _inst_1 (CauchyFilter.uniformSpace.{u1} α _inst_1) (CauchyFilter.pureCauchy.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], UniformInducing.{u1, u1} α (CauchyFilter.{u1} α _inst_1) _inst_1 (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1) (CauchyFilter.pureCauchy.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align Cauchy.uniform_inducing_pure_cauchy CauchyFilter.uniformInducing_pureCauchyₓ'. -/
 theorem uniformInducing_pureCauchy : UniformInducing (pure_cauchy : α → CauchyFilter α) :=
   ⟨have : (preimage fun x : α × α => (pure_cauchy x.fst, pure_cauchy x.snd)) ∘ gen = id :=
       funext fun s =>
@@ -200,23 +176,11 @@ theorem uniformInducing_pureCauchy : UniformInducing (pure_cauchy : α → Cauch
       ⟩
 #align Cauchy.uniform_inducing_pure_cauchy CauchyFilter.uniformInducing_pureCauchy
 
-/- warning: Cauchy.uniform_embedding_pure_cauchy -> CauchyFilter.uniformEmbedding_pureCauchy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], UniformEmbedding.{u1, u1} α (CauchyFilter.{u1} α _inst_1) _inst_1 (CauchyFilter.uniformSpace.{u1} α _inst_1) (CauchyFilter.pureCauchy.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], UniformEmbedding.{u1, u1} α (CauchyFilter.{u1} α _inst_1) _inst_1 (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1) (CauchyFilter.pureCauchy.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align Cauchy.uniform_embedding_pure_cauchy CauchyFilter.uniformEmbedding_pureCauchyₓ'. -/
 theorem uniformEmbedding_pureCauchy : UniformEmbedding (pure_cauchy : α → CauchyFilter α) :=
   { uniform_inducing_pure_cauchy with
     inj := fun a₁ a₂ h => pure_injective <| Subtype.ext_iff_val.1 h }
 #align Cauchy.uniform_embedding_pure_cauchy CauchyFilter.uniformEmbedding_pureCauchy
 
-/- warning: Cauchy.dense_range_pure_cauchy -> CauchyFilter.denseRange_pureCauchy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseRange.{u1, u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.uniformSpace.{u1} α _inst_1)) α (CauchyFilter.pureCauchy.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseRange.{u1, u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1)) α (CauchyFilter.pureCauchy.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align Cauchy.dense_range_pure_cauchy CauchyFilter.denseRange_pureCauchyₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem denseRange_pureCauchy : DenseRange pure_cauchy := fun f =>
   by
@@ -242,22 +206,10 @@ theorem denseRange_pureCauchy : DenseRange pure_cauchy := fun f =>
       ⟨_, this⟩
 #align Cauchy.dense_range_pure_cauchy CauchyFilter.denseRange_pureCauchy
 
-/- warning: Cauchy.dense_inducing_pure_cauchy -> CauchyFilter.denseInducing_pureCauchy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseInducing.{u1, u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.uniformSpace.{u1} α _inst_1)) (CauchyFilter.pureCauchy.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseInducing.{u1, u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1)) (CauchyFilter.pureCauchy.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align Cauchy.dense_inducing_pure_cauchy CauchyFilter.denseInducing_pureCauchyₓ'. -/
 theorem denseInducing_pureCauchy : DenseInducing pure_cauchy :=
   uniform_inducing_pure_cauchy.DenseInducing dense_range_pure_cauchy
 #align Cauchy.dense_inducing_pure_cauchy CauchyFilter.denseInducing_pureCauchy
 
-/- warning: Cauchy.dense_embedding_pure_cauchy -> CauchyFilter.denseEmbedding_pureCauchy is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseEmbedding.{u1, u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.uniformSpace.{u1} α _inst_1)) (CauchyFilter.pureCauchy.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseEmbedding.{u1, u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1)) (CauchyFilter.pureCauchy.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align Cauchy.dense_embedding_pure_cauchy CauchyFilter.denseEmbedding_pureCauchyₓ'. -/
 theorem denseEmbedding_pureCauchy : DenseEmbedding pure_cauchy :=
   uniform_embedding_pure_cauchy.DenseEmbedding dense_range_pure_cauchy
 #align Cauchy.dense_embedding_pure_cauchy CauchyFilter.denseEmbedding_pureCauchy
@@ -326,12 +278,6 @@ end SeparatedSpace
 
 variable [CompleteSpace β]
 
-/- warning: Cauchy.uniform_continuous_extend -> CauchyFilter.uniformContinuous_extend is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] [_inst_4 : CompleteSpace.{u2} β _inst_2] {f : α -> β}, UniformContinuous.{u1, u2} (CauchyFilter.{u1} α _inst_1) β (CauchyFilter.uniformSpace.{u1} α _inst_1) _inst_2 (CauchyFilter.extend.{u1, u2} α _inst_1 β _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] [_inst_4 : CompleteSpace.{u2} β _inst_2] {f : α -> β}, UniformContinuous.{u1, u2} (CauchyFilter.{u1} α _inst_1) β (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1) _inst_2 (CauchyFilter.extend.{u1, u2} α _inst_1 β _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align Cauchy.uniform_continuous_extend CauchyFilter.uniformContinuous_extendₓ'. -/
 theorem uniformContinuous_extend {f : α → β} : UniformContinuous (extend f) :=
   by
   by_cases hf : UniformContinuous f
@@ -345,12 +291,6 @@ end Extend
 
 end
 
-/- warning: Cauchy.Cauchy_eq -> CauchyFilter.cauchyFilter_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Inhabited.{succ u1} α] [_inst_2 : UniformSpace.{u1} α] [_inst_3 : CompleteSpace.{u1} α _inst_2] [_inst_4 : SeparatedSpace.{u1} α _inst_2] {f : CauchyFilter.{u1} α _inst_2} {g : CauchyFilter.{u1} α _inst_2}, Iff (Eq.{succ u1} α (lim.{u1} α (UniformSpace.toTopologicalSpace.{u1} α _inst_2) (instNonempty.{succ u1} α _inst_1) (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_2 f) f)) (lim.{u1} α (UniformSpace.toTopologicalSpace.{u1} α _inst_2) (instNonempty.{succ u1} α _inst_1) (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_2 f) g))) (Membership.Mem.{u1, u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2)) (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2))) (Set.hasMem.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2))) (Prod.mk.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2) f g) (separationRel.{u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.uniformSpace.{u1} α _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Inhabited.{succ u1} α] [_inst_2 : UniformSpace.{u1} α] [_inst_3 : CompleteSpace.{u1} α _inst_2] [_inst_4 : SeparatedSpace.{u1} α _inst_2] {f : CauchyFilter.{u1} α _inst_2} {g : CauchyFilter.{u1} α _inst_2}, Iff (Eq.{succ u1} α (lim.{u1} α (UniformSpace.toTopologicalSpace.{u1} α _inst_2) (instNonempty.{succ u1} α _inst_1) (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_2 f) f)) (lim.{u1} α (UniformSpace.toTopologicalSpace.{u1} α _inst_2) (instNonempty.{succ u1} α _inst_1) (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_2 f) g))) (Membership.mem.{u1, u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2)) (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2))) (Set.instMembershipSet.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2))) (Prod.mk.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2) f g) (separationRel.{u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_2)))
-Case conversion may be inaccurate. Consider using '#align Cauchy.Cauchy_eq CauchyFilter.cauchyFilter_eqₓ'. -/
 theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpace α]
     [SeparatedSpace α] {f g : CauchyFilter α} :
     lim f.1 = lim g.1 ↔ (f, g) ∈ separationRel (CauchyFilter α) :=
@@ -387,12 +327,6 @@ section
 
 attribute [local instance] UniformSpace.separationSetoid
 
-/- warning: Cauchy.separated_pure_cauchy_injective -> CauchyFilter.separated_pureCauchy_injective is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [s : SeparatedSpace.{u1} α _inst_1], Function.Injective.{succ u1, succ u1} α (Quotient.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.uniformSpace.{u1} α _inst_1))) (fun (a : α) => Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.uniformSpace.{u1} α _inst_1)) (CauchyFilter.pureCauchy.{u1} α _inst_1 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [s : SeparatedSpace.{u1} α _inst_1], Function.Injective.{succ u1, succ u1} α (Quotient.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (fun (a : α) => Quotient.mk.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1)) (CauchyFilter.pureCauchy.{u1} α _inst_1 a))
-Case conversion may be inaccurate. Consider using '#align Cauchy.separated_pure_cauchy_injective CauchyFilter.separated_pureCauchy_injectiveₓ'. -/
 theorem separated_pureCauchy_injective {α : Type _} [UniformSpace α] [s : SeparatedSpace α] :
     Function.Injective fun a : α => ⟦pureCauchy a⟧
   | a, b, h =>
@@ -461,23 +395,11 @@ instance : T3Space (Completion α) :=
 instance : CoeTC α (Completion α) :=
   ⟨Quotient.mk' ∘ pureCauchy⟩
 
-/- warning: uniform_space.completion.coe_eq -> UniformSpace.Completion.coe_eq is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (α -> (UniformSpace.Completion.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1)))) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.uniformSpace.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (α -> (UniformSpace.Completion.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (Quotient.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.coe_eq UniformSpace.Completion.coe_eqₓ'. -/
 -- note [use has_coe_t]
 protected theorem coe_eq : (coe : α → Completion α) = Quotient.mk' ∘ pureCauchy :=
   rfl
 #align uniform_space.completion.coe_eq UniformSpace.Completion.coe_eq
 
-/- warning: uniform_space.completion.comap_coe_eq_uniformity -> UniformSpace.Completion.comap_coe_eq_uniformity is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.comap.{u1, u1} (Prod.{u1, u1} α α) (Prod.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1)) (fun (p : Prod.{u1, u1} α α) => Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.fst.{u1, u1} α α p)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.snd.{u1, u1} α α p))) (uniformity.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1))) (uniformity.{u1} α _inst_1)
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.comap.{u1, u1} (Prod.{u1, u1} α α) (Prod.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1)) (fun (p : Prod.{u1, u1} α α) => Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, u1} α α p)) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.snd.{u1, u1} α α p))) (uniformity.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1))) (uniformity.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.comap_coe_eq_uniformity UniformSpace.Completion.comap_coe_eq_uniformityₓ'. -/
 theorem comap_coe_eq_uniformity :
     ((𝓤 _).comap fun p : α × α => ((p.1 : Completion α), (p.2 : Completion α))) = 𝓤 α :=
   by
@@ -492,24 +414,12 @@ theorem comap_coe_eq_uniformity :
   rw [comap_quotient_eq_uniformity, uniform_embedding_pure_cauchy.comap_uniformity]
 #align uniform_space.completion.comap_coe_eq_uniformity UniformSpace.Completion.comap_coe_eq_uniformity
 
-/- warning: uniform_space.completion.uniform_inducing_coe -> UniformSpace.Completion.uniformInducing_coe is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_inducing_coe UniformSpace.Completion.uniformInducing_coeₓ'. -/
 theorem uniformInducing_coe : UniformInducing (coe : α → Completion α) :=
   ⟨comap_coe_eq_uniformity α⟩
 #align uniform_space.completion.uniform_inducing_coe UniformSpace.Completion.uniformInducing_coe
 
 variable {α}
 
-/- warning: uniform_space.completion.dense_range_coe -> UniformSpace.Completion.denseRange_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseRange.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseRange.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) α (UniformSpace.Completion.coe'.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_range_coe UniformSpace.Completion.denseRange_coeₓ'. -/
 theorem denseRange_coe : DenseRange (coe : α → Completion α) :=
   denseRange_pureCauchy.Quotient
 #align uniform_space.completion.dense_range_coe UniformSpace.Completion.denseRange_coe
@@ -545,55 +455,25 @@ theorem nonempty_completion_iff : Nonempty (Completion α) ↔ Nonempty α :=
 #align uniform_space.completion.nonempty_completion_iff UniformSpace.Completion.nonempty_completion_iff
 -/
 
-/- warning: uniform_space.completion.uniform_continuous_coe -> UniformSpace.Completion.uniformContinuous_coe is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformContinuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformContinuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_coe UniformSpace.Completion.uniformContinuous_coeₓ'. -/
 theorem uniformContinuous_coe : UniformContinuous (coe : α → Completion α) :=
   cPkg.uniformContinuous_coe
 #align uniform_space.completion.uniform_continuous_coe UniformSpace.Completion.uniformContinuous_coe
 
-/- warning: uniform_space.completion.continuous_coe -> UniformSpace.Completion.continuous_coe is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Continuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Continuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.continuous_coe UniformSpace.Completion.continuous_coeₓ'. -/
 theorem continuous_coe : Continuous (coe : α → Completion α) :=
   cPkg.continuous_coe
 #align uniform_space.completion.continuous_coe UniformSpace.Completion.continuous_coe
 
-/- warning: uniform_space.completion.uniform_embedding_coe -> UniformSpace.Completion.uniformEmbedding_coe is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], UniformEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], UniformEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_embedding_coe UniformSpace.Completion.uniformEmbedding_coeₓ'. -/
 theorem uniformEmbedding_coe [SeparatedSpace α] : UniformEmbedding (coe : α → Completion α) :=
   { comap_uniformity := comap_coe_eq_uniformity α
     inj := separated_pureCauchy_injective }
 #align uniform_space.completion.uniform_embedding_coe UniformSpace.Completion.uniformEmbedding_coe
 
-/- warning: uniform_space.completion.coe_injective -> UniformSpace.Completion.coe_injective is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], Function.Injective.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], Function.Injective.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.coe_injective UniformSpace.Completion.coe_injectiveₓ'. -/
 theorem coe_injective [SeparatedSpace α] : Function.Injective (coe : α → Completion α) :=
   UniformEmbedding.inj (uniformEmbedding_coe _)
 #align uniform_space.completion.coe_injective UniformSpace.Completion.coe_injective
 
 variable {α}
 
-/- warning: uniform_space.completion.dense_inducing_coe -> UniformSpace.Completion.denseInducing_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_inducing_coe UniformSpace.Completion.denseInducing_coeₓ'. -/
 theorem denseInducing_coe : DenseInducing (coe : α → Completion α) :=
   { (uniformInducing_coe α).Inducing with dense := denseRange_coe }
 #align uniform_space.completion.dense_inducing_coe UniformSpace.Completion.denseInducing_coe
@@ -613,57 +493,27 @@ instance separableSpace_completion [SeparableSpace α] : SeparableSpace (Complet
 #align uniform_space.completion.separable_space_completion UniformSpace.Completion.separableSpace_completion
 -/
 
-/- warning: uniform_space.completion.dense_embedding_coe -> UniformSpace.Completion.denseEmbedding_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], DenseEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], DenseEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_embedding_coe UniformSpace.Completion.denseEmbedding_coeₓ'. -/
 theorem denseEmbedding_coe [SeparatedSpace α] : DenseEmbedding (coe : α → Completion α) :=
   { denseInducing_coe with inj := separated_pureCauchy_injective }
 #align uniform_space.completion.dense_embedding_coe UniformSpace.Completion.denseEmbedding_coe
 
-/- warning: uniform_space.completion.dense_range_coe₂ -> UniformSpace.Completion.denseRange_coe₂ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β], DenseRange.{max u1 u2, max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (Prod.topologicalSpace.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2))) (Prod.{u1, u2} α β) (fun (x : Prod.{u1, u2} α β) => Prod.mk.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.fst.{u1, u2} α β x)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (Prod.snd.{u1, u2} α β x)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β], DenseRange.{max u2 u1, max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (instTopologicalSpaceProd.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2))) (Prod.{u1, u2} α β) (fun (x : Prod.{u1, u2} α β) => Prod.mk.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, u2} α β x)) (UniformSpace.Completion.coe'.{u2} β _inst_2 (Prod.snd.{u1, u2} α β x)))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_range_coe₂ UniformSpace.Completion.denseRange_coe₂ₓ'. -/
 theorem denseRange_coe₂ :
     DenseRange fun x : α × β => ((x.1 : Completion α), (x.2 : Completion β)) :=
   denseRange_coe.Prod_map denseRange_coe
 #align uniform_space.completion.dense_range_coe₂ UniformSpace.Completion.denseRange_coe₂
 
-/- warning: uniform_space.completion.dense_range_coe₃ -> UniformSpace.Completion.denseRange_coe₃ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ], DenseRange.{max u1 u2 u3, max u1 u2 u3} (Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (Prod.topologicalSpace.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (Prod.topologicalSpace.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3)))) (Prod.{u1, max u2 u3} α (Prod.{u2, u3} β γ)) (fun (x : Prod.{u1, max u2 u3} α (Prod.{u2, u3} β γ)) => Prod.mk.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.fst.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)) (Prod.mk.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (Prod.fst.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x))) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) γ (UniformSpace.Completion.{u3} γ _inst_3) (HasLiftT.mk.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (CoeTCₓ.coe.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.hasCoeT.{u3} γ _inst_3))) (Prod.snd.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ], DenseRange.{max (max u3 u2) u1, max (max u1 u2) u3} (Prod.{u1, max u3 u2} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (instTopologicalSpaceProd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (instTopologicalSpaceProd.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3)))) (Prod.{u1, max u3 u2} α (Prod.{u2, u3} β γ)) (fun (x : Prod.{u1, max u3 u2} α (Prod.{u2, u3} β γ)) => Prod.mk.{u1, max u3 u2} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)) (Prod.mk.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.coe'.{u2} β _inst_2 (Prod.fst.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x))) (UniformSpace.Completion.coe'.{u3} γ _inst_3 (Prod.snd.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)))))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_range_coe₃ UniformSpace.Completion.denseRange_coe₃ₓ'. -/
 theorem denseRange_coe₃ :
     DenseRange fun x : α × β × γ =>
       ((x.1 : Completion α), ((x.2.1 : Completion β), (x.2.2 : Completion γ))) :=
   denseRange_coe.Prod_map denseRange_coe₂
 #align uniform_space.completion.dense_range_coe₃ UniformSpace.Completion.denseRange_coe₃
 
-/- warning: uniform_space.completion.induction_on -> UniformSpace.Completion.induction_on is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {p : (UniformSpace.Completion.{u1} α _inst_1) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1), (IsClosed.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (setOf.{u1} (UniformSpace.Completion.{u1} α _inst_1) (fun (a : UniformSpace.Completion.{u1} α _inst_1) => p a))) -> (forall (a : α), p ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) -> (p a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {p : (UniformSpace.Completion.{u1} α _inst_1) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1), (IsClosed.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (setOf.{u1} (UniformSpace.Completion.{u1} α _inst_1) (fun (a : UniformSpace.Completion.{u1} α _inst_1) => p a))) -> (forall (a : α), p (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) -> (p a)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.induction_on UniformSpace.Completion.induction_onₓ'. -/
 @[elab_as_elim]
 theorem induction_on {p : Completion α → Prop} (a : Completion α) (hp : IsClosed { a | p a })
     (ih : ∀ a : α, p a) : p a :=
   isClosed_property denseRange_coe hp ih a
 #align uniform_space.completion.induction_on UniformSpace.Completion.induction_on
 
-/- warning: uniform_space.completion.induction_on₂ -> UniformSpace.Completion.induction_on₂ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {p : (UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2), (IsClosed.{max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (Prod.topologicalSpace.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2))) (setOf.{max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (fun (x : Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) => p (Prod.fst.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) x) (Prod.snd.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) x)))) -> (forall (a : α) (b : β), p ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) b)) -> (p a b)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {p : (UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2) -> Prop} (a : UniformSpace.Completion.{u2} α _inst_1) (b : UniformSpace.Completion.{u1} β _inst_2), (IsClosed.{max u2 u1} (Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) (instTopologicalSpaceProd.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} β _inst_2))) (setOf.{max u2 u1} (Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) (fun (x : Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) => p (Prod.fst.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) x) (Prod.snd.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) x)))) -> (forall (a : α) (b : β), p (UniformSpace.Completion.coe'.{u2} α _inst_1 a) (UniformSpace.Completion.coe'.{u1} β _inst_2 b)) -> (p a b)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.induction_on₂ UniformSpace.Completion.induction_on₂ₓ'. -/
 @[elab_as_elim]
 theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Completion α) (b : Completion β)
     (hp : IsClosed { x : Completion α × Completion β | p x.1 x.2 })
@@ -673,12 +523,6 @@ theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Comp
   this (a, b)
 #align uniform_space.completion.induction_on₂ UniformSpace.Completion.induction_on₂
 
-/- warning: uniform_space.completion.induction_on₃ -> UniformSpace.Completion.induction_on₃ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] {p : (UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> (UniformSpace.Completion.{u3} γ _inst_3) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2) (c : UniformSpace.Completion.{u3} γ _inst_3), (IsClosed.{max u1 u2 u3} (Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (Prod.topologicalSpace.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (Prod.topologicalSpace.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3)))) (setOf.{max u1 u2 u3} (Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (fun (x : Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) => p (Prod.fst.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) x) (Prod.fst.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (Prod.snd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) x)) (Prod.snd.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (Prod.snd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) x))))) -> (forall (a : α) (b : β) (c : γ), p ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) b) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) γ (UniformSpace.Completion.{u3} γ _inst_3) (HasLiftT.mk.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (CoeTCₓ.coe.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.hasCoeT.{u3} γ _inst_3))) c)) -> (p a b c)
-but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {p : (UniformSpace.Completion.{u3} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> (UniformSpace.Completion.{u1} γ _inst_3) -> Prop} (a : UniformSpace.Completion.{u3} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2) (c : UniformSpace.Completion.{u1} γ _inst_3), (IsClosed.{max (max u3 u2) u1} (Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) (instTopologicalSpaceProd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.uniformSpace.{u3} α _inst_1)) (instTopologicalSpaceProd.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u1} γ _inst_3)))) (setOf.{max (max u3 u2) u1} (Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) (fun (x : Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) => p (Prod.fst.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x) (Prod.fst.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (Prod.snd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x)) (Prod.snd.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (Prod.snd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x))))) -> (forall (a : α) (b : β) (c : γ), p (UniformSpace.Completion.coe'.{u3} α _inst_1 a) (UniformSpace.Completion.coe'.{u2} β _inst_2 b) (UniformSpace.Completion.coe'.{u1} γ _inst_3 c)) -> (p a b c)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.induction_on₃ UniformSpace.Completion.induction_on₃ₓ'. -/
 @[elab_as_elim]
 theorem induction_on₃ {p : Completion α → Completion β → Completion γ → Prop} (a : Completion α)
     (b : Completion β) (c : Completion γ)
@@ -689,23 +533,11 @@ theorem induction_on₃ {p : Completion α → Completion β → Completion γ 
   this (a, b, c)
 #align uniform_space.completion.induction_on₃ UniformSpace.Completion.induction_on₃
 
-/- warning: uniform_space.completion.ext -> UniformSpace.Completion.ext is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> Y) f g)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) (g (UniformSpace.Completion.coe'.{u1} α _inst_1 a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> Y) f g)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.ext UniformSpace.Completion.extₓ'. -/
 theorem ext {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
     (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) : f = g :=
   cPkg.funext hf hg h
 #align uniform_space.completion.ext UniformSpace.Completion.ext
 
-/- warning: uniform_space.completion.ext' -> UniformSpace.Completion.ext' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (forall (a : UniformSpace.Completion.{u1} α _inst_1), Eq.{succ u2} Y (f a) (g a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) (g (UniformSpace.Completion.coe'.{u1} α _inst_1 a))) -> (forall (a : UniformSpace.Completion.{u1} α _inst_1), Eq.{succ u2} Y (f a) (g a))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.ext' UniformSpace.Completion.ext'ₓ'. -/
 theorem ext' {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
     (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) (a : Completion α) :
     f a = g a :=
@@ -728,34 +560,16 @@ section CompleteSpace
 
 variable [CompleteSpace β]
 
-/- warning: uniform_space.completion.uniform_continuous_extension -> UniformSpace.Completion.uniformContinuous_extension is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : CompleteSpace.{u2} β _inst_2], UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) _inst_2 (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : CompleteSpace.{u1} β _inst_2], UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u2} α _inst_1) _inst_2 (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_extension UniformSpace.Completion.uniformContinuous_extensionₓ'. -/
 theorem uniformContinuous_extension : UniformContinuous (Completion.extension f) :=
   cPkg.uniformContinuous_extend
 #align uniform_space.completion.uniform_continuous_extension UniformSpace.Completion.uniformContinuous_extension
 
-/- warning: uniform_space.completion.continuous_extension -> UniformSpace.Completion.continuous_extension is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : CompleteSpace.{u2} β _inst_2], Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) β (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} β _inst_2) (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : CompleteSpace.{u1} β _inst_2], Continuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} β _inst_2) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.continuous_extension UniformSpace.Completion.continuous_extensionₓ'. -/
 theorem continuous_extension : Continuous (Completion.extension f) :=
   cPkg.continuous_extend
 #align uniform_space.completion.continuous_extension UniformSpace.Completion.continuous_extension
 
 end CompleteSpace
 
-/- warning: uniform_space.completion.extension_coe -> UniformSpace.Completion.extension_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u2} β _inst_2], (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u2} β (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) (f a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u2} β _inst_2], (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u2} β (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) (f a))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.extension_coe UniformSpace.Completion.extension_coeₓ'. -/
 @[simp]
 theorem extension_coe [SeparatedSpace β] (hf : UniformContinuous f) (a : α) :
     (Completion.extension f) a = f a :=
@@ -764,24 +578,12 @@ theorem extension_coe [SeparatedSpace β] (hf : UniformContinuous f) (a : α) :
 
 variable [SeparatedSpace β] [CompleteSpace β]
 
-/- warning: uniform_space.completion.extension_unique -> UniformSpace.Completion.extension_unique is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u2} β _inst_2] [_inst_5 : CompleteSpace.{u2} β _inst_2], (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall {g : (UniformSpace.Completion.{u1} α _inst_1) -> β}, (UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) _inst_2 g) -> (forall (a : α), Eq.{succ u2} β (f a) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> β) (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f) g))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u1} β _inst_2] [_inst_5 : CompleteSpace.{u1} β _inst_2], (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (forall {g : (UniformSpace.Completion.{u2} α _inst_1) -> β}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u2} α _inst_1) _inst_2 g) -> (forall (a : α), Eq.{succ u1} β (f a) (g (UniformSpace.Completion.coe'.{u2} α _inst_1 a))) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> β) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f) g))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.extension_unique UniformSpace.Completion.extension_uniqueₓ'. -/
 theorem extension_unique (hf : UniformContinuous f) {g : Completion α → β}
     (hg : UniformContinuous g) (h : ∀ a : α, f a = g (a : Completion α)) :
     Completion.extension f = g :=
   cPkg.extend_unique hf hg h
 #align uniform_space.completion.extension_unique UniformSpace.Completion.extension_unique
 
-/- warning: uniform_space.completion.extension_comp_coe -> UniformSpace.Completion.extension_comp_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] [_inst_4 : SeparatedSpace.{u2} β _inst_2] [_inst_5 : CompleteSpace.{u2} β _inst_2] {f : (UniformSpace.Completion.{u1} α _inst_1) -> β}, (UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) _inst_2 f) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> β) (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (UniformSpace.Completion.{u1} α _inst_1) β f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1)))))) f)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] [_inst_4 : SeparatedSpace.{u1} β _inst_2] [_inst_5 : CompleteSpace.{u1} β _inst_2] {f : (UniformSpace.Completion.{u2} α _inst_1) -> β}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u2} α _inst_1) _inst_2 f) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> β) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 (Function.comp.{succ u2, succ u2, succ u1} α (UniformSpace.Completion.{u2} α _inst_1) β f (UniformSpace.Completion.coe'.{u2} α _inst_1))) f)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.extension_comp_coe UniformSpace.Completion.extension_comp_coeₓ'. -/
 @[simp]
 theorem extension_comp_coe {f : Completion α → β} (hf : UniformContinuous f) :
     Completion.extension (f ∘ coe) = f :=
@@ -801,43 +603,19 @@ protected def map (f : α → β) : Completion α → Completion β :=
 #align uniform_space.completion.map UniformSpace.Completion.map
 -/
 
-/- warning: uniform_space.completion.uniform_continuous_map -> UniformSpace.Completion.uniformContinuous_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β}, UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) (UniformSpace.Completion.map.{u1, u2} α _inst_1 β _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β}, UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} β _inst_2) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_map UniformSpace.Completion.uniformContinuous_mapₓ'. -/
 theorem uniformContinuous_map : UniformContinuous (Completion.map f) :=
   cPkg.uniformContinuous_map cPkg f
 #align uniform_space.completion.uniform_continuous_map UniformSpace.Completion.uniformContinuous_map
 
-/- warning: uniform_space.completion.continuous_map -> UniformSpace.Completion.continuous_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β}, Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.Completion.map.{u1, u2} α _inst_1 β _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β}, Continuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} β _inst_2)) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.continuous_map UniformSpace.Completion.continuous_mapₓ'. -/
 theorem continuous_map : Continuous (Completion.map f) :=
   cPkg.continuous_map cPkg f
 #align uniform_space.completion.continuous_map UniformSpace.Completion.continuous_map
 
-/- warning: uniform_space.completion.map_coe -> UniformSpace.Completion.map_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β}, (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.map.{u1, u2} α _inst_1 β _inst_2 f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (f a)))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β}, (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f (UniformSpace.Completion.coe'.{u2} α _inst_1 a)) (UniformSpace.Completion.coe'.{u1} β _inst_2 (f a)))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.map_coe UniformSpace.Completion.map_coeₓ'. -/
 @[simp]
 theorem map_coe (hf : UniformContinuous f) (a : α) : (Completion.map f) a = f a :=
   cPkg.map_coe cPkg hf a
 #align uniform_space.completion.map_coe UniformSpace.Completion.map_coe
 
-/- warning: uniform_space.completion.map_unique -> UniformSpace.Completion.map_unique is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} {g : (UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2)}, (UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) g) -> (forall (a : α), Eq.{succ u2} (UniformSpace.Completion.{u2} β _inst_2) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (f a)) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2)) (UniformSpace.Completion.map.{u1, u2} α _inst_1 β _inst_2 f) g)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} {g : (UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2)}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} β _inst_2) g) -> (forall (a : α), Eq.{succ u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.coe'.{u1} β _inst_2 (f a)) (g (UniformSpace.Completion.coe'.{u2} α _inst_1 a))) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2)) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f) g)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.map_unique UniformSpace.Completion.map_uniqueₓ'. -/
 theorem map_unique {f : α → β} {g : Completion α → Completion β} (hg : UniformContinuous g)
     (h : ∀ a : α, ↑(f a) = g a) : Completion.map f = g :=
   cPkg.map_unique cPkg hg h
@@ -859,12 +637,6 @@ theorem extension_map [CompleteSpace γ] [SeparatedSpace γ] {f : β → γ} {g
 #align uniform_space.completion.extension_map UniformSpace.Completion.extension_map
 -/
 
-/- warning: uniform_space.completion.map_comp -> UniformSpace.Completion.map_comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] {g : β -> γ} {f : α -> β}, (UniformContinuous.{u2, u3} β γ _inst_2 _inst_3 g) -> (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (Eq.{max (succ u1) (succ u3)} ((UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u3} γ _inst_3)) (Function.comp.{succ u1, succ u2, succ u3} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.map.{u2, u3} β _inst_2 γ _inst_3 g) (UniformSpace.Completion.map.{u1, u2} α _inst_1 β _inst_2 f)) (UniformSpace.Completion.map.{u1, u3} α _inst_1 γ _inst_3 (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u3}} [_inst_2 : UniformSpace.{u3} β] {γ : Type.{u2}} [_inst_3 : UniformSpace.{u2} γ] {g : β -> γ} {f : α -> β}, (UniformContinuous.{u3, u2} β γ _inst_2 _inst_3 g) -> (UniformContinuous.{u1, u3} α β _inst_1 _inst_2 f) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} γ _inst_3)) (Function.comp.{succ u1, succ u3, succ u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u3} β _inst_2) (UniformSpace.Completion.{u2} γ _inst_3) (UniformSpace.Completion.map.{u3, u2} β _inst_2 γ _inst_3 g) (UniformSpace.Completion.map.{u1, u3} α _inst_1 β _inst_2 f)) (UniformSpace.Completion.map.{u1, u2} α _inst_1 γ _inst_3 (Function.comp.{succ u1, succ u3, succ u2} α β γ g f)))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.map_comp UniformSpace.Completion.map_compₓ'. -/
 theorem map_comp {g : β → γ} {f : α → β} (hg : UniformContinuous g) (hf : UniformContinuous f) :
     Completion.map g ∘ Completion.map f = Completion.map (g ∘ f) :=
   extension_map ((uniformContinuous_coe _).comp hg) hf
@@ -939,12 +711,6 @@ section SeparatedSpace
 
 variable [SeparatedSpace γ] {f}
 
-/- warning: uniform_space.completion.extension₂_coe_coe -> UniformSpace.Completion.extension₂_coe_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] {f : α -> β -> γ} [_inst_4 : SeparatedSpace.{u3} γ _inst_3], (UniformContinuous₂.{u1, u2, u3} α β γ _inst_1 _inst_2 _inst_3 f) -> (forall (a : α) (b : β), Eq.{succ u3} γ (UniformSpace.Completion.extension₂.{u1, u2, u3} α _inst_1 β _inst_2 γ _inst_3 f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) b)) (f a b))
-but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {f : α -> β -> γ} [_inst_4 : SeparatedSpace.{u1} γ _inst_3], (UniformContinuous₂.{u3, u2, u1} α β γ _inst_1 _inst_2 _inst_3 f) -> (forall (a : α) (b : β), Eq.{succ u1} γ (UniformSpace.Completion.extension₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f (UniformSpace.Completion.coe'.{u3} α _inst_1 a) (UniformSpace.Completion.coe'.{u2} β _inst_2 b)) (f a b))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.extension₂_coe_coe UniformSpace.Completion.extension₂_coe_coeₓ'. -/
 @[simp]
 theorem extension₂_coe_coe (hf : UniformContinuous₂ f) (a : α) (b : β) :
     Completion.extension₂ f a b = f a b :=
@@ -955,12 +721,6 @@ end SeparatedSpace
 
 variable [CompleteSpace γ] (f)
 
-/- warning: uniform_space.completion.uniform_continuous_extension₂ -> UniformSpace.Completion.uniformContinuous_extension₂ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (f : α -> β -> γ) [_inst_4 : CompleteSpace.{u3} γ _inst_3], UniformContinuous₂.{u1, u2, u3} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) γ (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) _inst_3 (UniformSpace.Completion.extension₂.{u1, u2, u3} α _inst_1 β _inst_2 γ _inst_3 f)
-but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (f : α -> β -> γ) [_inst_4 : CompleteSpace.{u1} γ _inst_3], UniformContinuous₂.{u3, u2, u1} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) γ (UniformSpace.Completion.uniformSpace.{u3} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) _inst_3 (UniformSpace.Completion.extension₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_extension₂ UniformSpace.Completion.uniformContinuous_extension₂ₓ'. -/
 theorem uniformContinuous_extension₂ : UniformContinuous₂ (Completion.extension₂ f) :=
   cPkg.uniformContinuous_extension₂ cPkg f
 #align uniform_space.completion.uniform_continuous_extension₂ UniformSpace.Completion.uniformContinuous_extension₂
@@ -978,34 +738,16 @@ protected def map₂ (f : α → β → γ) : Completion α → Completion β 
 #align uniform_space.completion.map₂ UniformSpace.Completion.map₂
 -/
 
-/- warning: uniform_space.completion.uniform_continuous_map₂ -> UniformSpace.Completion.uniformContinuous_map₂ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (f : α -> β -> γ), UniformContinuous₂.{u1, u2, u3} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3) (UniformSpace.Completion.map₂.{u1, u2, u3} α _inst_1 β _inst_2 γ _inst_3 f)
-but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (f : α -> β -> γ), UniformContinuous₂.{u3, u2, u1} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} γ _inst_3) (UniformSpace.Completion.map₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f)
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_map₂ UniformSpace.Completion.uniformContinuous_map₂ₓ'. -/
 theorem uniformContinuous_map₂ (f : α → β → γ) : UniformContinuous₂ (Completion.map₂ f) :=
   cPkg.uniformContinuous_map₂ cPkg cPkg f
 #align uniform_space.completion.uniform_continuous_map₂ UniformSpace.Completion.uniformContinuous_map₂
 
-/- warning: uniform_space.completion.continuous_map₂ -> UniformSpace.Completion.continuous_map₂ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] {δ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} δ] {f : α -> β -> γ} {a : δ -> (UniformSpace.Completion.{u1} α _inst_1)} {b : δ -> (UniformSpace.Completion.{u2} β _inst_2)}, (Continuous.{u4, u1} δ (UniformSpace.Completion.{u1} α _inst_1) _inst_4 (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) a) -> (Continuous.{u4, u2} δ (UniformSpace.Completion.{u2} β _inst_2) _inst_4 (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) b) -> (Continuous.{u4, u3} δ (UniformSpace.Completion.{u3} γ _inst_3) _inst_4 (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3)) (fun (d : δ) => UniformSpace.Completion.map₂.{u1, u2, u3} α _inst_1 β _inst_2 γ _inst_3 f (a d) (b d)))
-but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {δ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} δ] {f : α -> β -> γ} {a : δ -> (UniformSpace.Completion.{u3} α _inst_1)} {b : δ -> (UniformSpace.Completion.{u2} β _inst_2)}, (Continuous.{u4, u3} δ (UniformSpace.Completion.{u3} α _inst_1) _inst_4 (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.uniformSpace.{u3} α _inst_1)) a) -> (Continuous.{u4, u2} δ (UniformSpace.Completion.{u2} β _inst_2) _inst_4 (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) b) -> (Continuous.{u4, u1} δ (UniformSpace.Completion.{u1} γ _inst_3) _inst_4 (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u1} γ _inst_3)) (fun (d : δ) => UniformSpace.Completion.map₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f (a d) (b d)))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.continuous_map₂ UniformSpace.Completion.continuous_map₂ₓ'. -/
 theorem continuous_map₂ {δ} [TopologicalSpace δ] {f : α → β → γ} {a : δ → Completion α}
     {b : δ → Completion β} (ha : Continuous a) (hb : Continuous b) :
     Continuous fun d : δ => Completion.map₂ f (a d) (b d) :=
   cPkg.continuous_map₂ cPkg cPkg ha hb
 #align uniform_space.completion.continuous_map₂ UniformSpace.Completion.continuous_map₂
 
-/- warning: uniform_space.completion.map₂_coe_coe -> UniformSpace.Completion.map₂_coe_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (a : α) (b : β) (f : α -> β -> γ), (UniformContinuous₂.{u1, u2, u3} α β γ _inst_1 _inst_2 _inst_3 f) -> (Eq.{succ u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.map₂.{u1, u2, u3} α _inst_1 β _inst_2 γ _inst_3 f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) b)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) γ (UniformSpace.Completion.{u3} γ _inst_3) (HasLiftT.mk.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (CoeTCₓ.coe.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.hasCoeT.{u3} γ _inst_3))) (f a b)))
-but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (a : α) (b : β) (f : α -> β -> γ), (UniformContinuous₂.{u3, u2, u1} α β γ _inst_1 _inst_2 _inst_3 f) -> (Eq.{succ u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.map₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f (UniformSpace.Completion.coe'.{u3} α _inst_1 a) (UniformSpace.Completion.coe'.{u2} β _inst_2 b)) (UniformSpace.Completion.coe'.{u1} γ _inst_3 (f a b)))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.map₂_coe_coe UniformSpace.Completion.map₂_coe_coeₓ'. -/
 theorem map₂_coe_coe (a : α) (b : β) (f : α → β → γ) (hf : UniformContinuous₂ f) :
     Completion.map₂ f (a : Completion α) (b : Completion β) = f a b :=
   cPkg.map₂_coe_coe cPkg cPkg a b f hf

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

@@ -364,8 +364,7 @@ theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [Complete
       mem_prod_iff.2
         ⟨_, f.2.le_nhds_lim (mem_nhds_right (lim f.1) du), _,
           g.2.le_nhds_lim (mem_nhds_left (lim g.1) du), fun x h => _⟩
-    cases' x with a b
-    cases' h with h₁ h₂
+    cases' x with a b; cases' h with h₁ h₂
     rw [← e] at h₂
     exact dt ⟨_, h₁, h₂⟩
   · intro H

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

@@ -113,7 +113,6 @@ private theorem symm_gen : map Prod.swap ((𝓤 α).lift' gen) ≤ (𝓤 α).lif
           simp [Function.comp, h, -Subtype.val_eq_coe, mem_map']
           exact le_rfl)
     
-#align Cauchy.symm_gen Cauchy.symm_gen
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -129,7 +128,6 @@ private theorem comp_rel_gen_gen_subset_gen_comp_rel {s t : Set (α × α)} :
   (f.val ×ᶠ g.val).sets_of_superset (prod_mem_prod ht₁ ht₄)
     fun ⟨a, b⟩ ⟨(ha : a ∈ t₁), (hb : b ∈ t₄)⟩ =>
     ⟨x, h₁ (show (a, x) ∈ t₁ ×ˢ t₂ from ⟨ha, xt₂⟩), h₂ (show (x, b) ∈ t₃ ×ˢ t₄ from ⟨xt₃, hb⟩)⟩
-#align Cauchy.comp_rel_gen_gen_subset_gen_comp_rel Cauchy.comp_rel_gen_gen_subset_gen_comp_rel
 
 private theorem comp_gen : (((𝓤 α).lift' gen).lift' fun s => compRel s s) ≤ (𝓤 α).lift' gen :=
   calc
@@ -147,7 +145,6 @@ private theorem comp_gen : (((𝓤 α).lift' gen).lift' fun s => compRel s s) 
       exact monotone_gen
     _ ≤ (𝓤 α).lift' gen := lift'_mono comp_le_uniformity le_rfl
     
-#align Cauchy.comp_gen Cauchy.comp_gen
 
 instance : UniformSpace (CauchyFilter α) :=
   UniformSpace.ofCore

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

@@ -480,7 +480,7 @@ protected theorem coe_eq : (coe : α → Completion α) = Quotient.mk' ∘ pureC
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.comap.{u1, u1} (Prod.{u1, u1} α α) (Prod.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1)) (fun (p : Prod.{u1, u1} α α) => Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.fst.{u1, u1} α α p)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.snd.{u1, u1} α α p))) (uniformity.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1))) (uniformity.{u1} α _inst_1)
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.comap.{u1, u1} (Prod.{u1, u1} α α) (Prod.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1)) (fun (p : Prod.{u1, u1} α α) => Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, u1} α α p)) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.snd.{u1, u1} α α p))) (uniformity.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1))) (uniformity.{u1} α _inst_1)
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.comap.{u1, u1} (Prod.{u1, u1} α α) (Prod.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1)) (fun (p : Prod.{u1, u1} α α) => Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, u1} α α p)) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.snd.{u1, u1} α α p))) (uniformity.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1))) (uniformity.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.comap_coe_eq_uniformity UniformSpace.Completion.comap_coe_eq_uniformityₓ'. -/
 theorem comap_coe_eq_uniformity :
     ((𝓤 _).comap fun p : α × α => ((p.1 : Completion α), (p.2 : Completion α))) = 𝓤 α :=
@@ -500,7 +500,7 @@ theorem comap_coe_eq_uniformity :
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_inducing_coe UniformSpace.Completion.uniformInducing_coeₓ'. -/
 theorem uniformInducing_coe : UniformInducing (coe : α → Completion α) :=
   ⟨comap_coe_eq_uniformity α⟩
@@ -512,7 +512,7 @@ variable {α}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseRange.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseRange.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) α (UniformSpace.Completion.coe'.{u1} α _inst_1)
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseRange.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) α (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_range_coe UniformSpace.Completion.denseRange_coeₓ'. -/
 theorem denseRange_coe : DenseRange (coe : α → Completion α) :=
   denseRange_pureCauchy.Quotient
@@ -553,7 +553,7 @@ theorem nonempty_completion_iff : Nonempty (Completion α) ↔ Nonempty α :=
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformContinuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformContinuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformContinuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_coe UniformSpace.Completion.uniformContinuous_coeₓ'. -/
 theorem uniformContinuous_coe : UniformContinuous (coe : α → Completion α) :=
   cPkg.uniformContinuous_coe
@@ -563,7 +563,7 @@ theorem uniformContinuous_coe : UniformContinuous (coe : α → Completion α) :
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Continuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Continuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Continuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.continuous_coe UniformSpace.Completion.continuous_coeₓ'. -/
 theorem continuous_coe : Continuous (coe : α → Completion α) :=
   cPkg.continuous_coe
@@ -573,7 +573,7 @@ theorem continuous_coe : Continuous (coe : α → Completion α) :=
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], UniformEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], UniformEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], UniformEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_embedding_coe UniformSpace.Completion.uniformEmbedding_coeₓ'. -/
 theorem uniformEmbedding_coe [SeparatedSpace α] : UniformEmbedding (coe : α → Completion α) :=
   { comap_uniformity := comap_coe_eq_uniformity α
@@ -596,40 +596,32 @@ variable {α}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_inducing_coe UniformSpace.Completion.denseInducing_coeₓ'. -/
 theorem denseInducing_coe : DenseInducing (coe : α → Completion α) :=
   { (uniformInducing_coe α).Inducing with dense := denseRange_coe }
 #align uniform_space.completion.dense_inducing_coe UniformSpace.Completion.denseInducing_coe
 
-/- warning: uniform_space.completion.uniform_completion.complete_equiv_self -> UniformSpace.Completion.UniformCompletion.completeEquivSelf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : CompleteSpace.{u1} α _inst_1] [_inst_5 : SeparatedSpace.{u1} α _inst_1], UniformEquiv.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) α (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) _inst_1
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : CompleteSpace.{u1} α _inst_1] [_inst_5 : SeparatedSpace.{u1} α _inst_1], UniformEquiv.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) α (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1) _inst_1
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_completion.complete_equiv_self UniformSpace.Completion.UniformCompletion.completeEquivSelfₓ'. -/
+#print UniformSpace.Completion.UniformCompletion.completeEquivSelf /-
 /-- The uniform bijection between a complete space and its uniform completion. -/
 def UniformCompletion.completeEquivSelf [CompleteSpace α] [SeparatedSpace α] : Completion α ≃ᵤ α :=
   AbstractCompletion.compareEquiv Completion.cPkg AbstractCompletion.ofComplete
 #align uniform_space.completion.uniform_completion.complete_equiv_self UniformSpace.Completion.UniformCompletion.completeEquivSelf
+-/
 
 open TopologicalSpace
 
-/- warning: uniform_space.completion.separable_space_completion -> UniformSpace.Completion.separableSpace_completion is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : TopologicalSpace.SeparableSpace.{u1} α (UniformSpace.toTopologicalSpace.{u1} α _inst_1)], TopologicalSpace.SeparableSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : TopologicalSpace.SeparableSpace.{u1} α (UniformSpace.toTopologicalSpace.{u1} α _inst_1)], TopologicalSpace.SeparableSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1))
-Case conversion may be inaccurate. Consider using '#align uniform_space.completion.separable_space_completion UniformSpace.Completion.separableSpace_completionₓ'. -/
+#print UniformSpace.Completion.separableSpace_completion /-
 instance separableSpace_completion [SeparableSpace α] : SeparableSpace (Completion α) :=
   Completion.denseInducing_coe.SeparableSpace
 #align uniform_space.completion.separable_space_completion UniformSpace.Completion.separableSpace_completion
+-/
 
 /- warning: uniform_space.completion.dense_embedding_coe -> UniformSpace.Completion.denseEmbedding_coe is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], DenseEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], DenseEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], DenseEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_embedding_coe UniformSpace.Completion.denseEmbedding_coeₓ'. -/
 theorem denseEmbedding_coe [SeparatedSpace α] : DenseEmbedding (coe : α → Completion α) :=
   { denseInducing_coe with inj := separated_pureCauchy_injective }
@@ -639,7 +631,7 @@ theorem denseEmbedding_coe [SeparatedSpace α] : DenseEmbedding (coe : α → Co
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β], DenseRange.{max u1 u2, max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (Prod.topologicalSpace.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2))) (Prod.{u1, u2} α β) (fun (x : Prod.{u1, u2} α β) => Prod.mk.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.fst.{u1, u2} α β x)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (Prod.snd.{u1, u2} α β x)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β], DenseRange.{max u2 u1, max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (instTopologicalSpaceProd.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2))) (Prod.{u1, u2} α β) (fun (x : Prod.{u1, u2} α β) => Prod.mk.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, u2} α β x)) (UniformSpace.Completion.coe'.{u2} β _inst_2 (Prod.snd.{u1, u2} α β x)))
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β], DenseRange.{max u2 u1, max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (instTopologicalSpaceProd.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2))) (Prod.{u1, u2} α β) (fun (x : Prod.{u1, u2} α β) => Prod.mk.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, u2} α β x)) (UniformSpace.Completion.coe'.{u2} β _inst_2 (Prod.snd.{u1, u2} α β x)))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_range_coe₂ UniformSpace.Completion.denseRange_coe₂ₓ'. -/
 theorem denseRange_coe₂ :
     DenseRange fun x : α × β => ((x.1 : Completion α), (x.2 : Completion β)) :=
@@ -650,7 +642,7 @@ theorem denseRange_coe₂ :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ], DenseRange.{max u1 u2 u3, max u1 u2 u3} (Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (Prod.topologicalSpace.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (Prod.topologicalSpace.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3)))) (Prod.{u1, max u2 u3} α (Prod.{u2, u3} β γ)) (fun (x : Prod.{u1, max u2 u3} α (Prod.{u2, u3} β γ)) => Prod.mk.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.fst.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)) (Prod.mk.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (Prod.fst.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x))) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) γ (UniformSpace.Completion.{u3} γ _inst_3) (HasLiftT.mk.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (CoeTCₓ.coe.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.hasCoeT.{u3} γ _inst_3))) (Prod.snd.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ], DenseRange.{max (max u3 u2) u1, max (max u1 u2) u3} (Prod.{u1, max u3 u2} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (instTopologicalSpaceProd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (instTopologicalSpaceProd.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.instUniformSpaceCompletion.{u3} γ _inst_3)))) (Prod.{u1, max u3 u2} α (Prod.{u2, u3} β γ)) (fun (x : Prod.{u1, max u3 u2} α (Prod.{u2, u3} β γ)) => Prod.mk.{u1, max u3 u2} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)) (Prod.mk.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.coe'.{u2} β _inst_2 (Prod.fst.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x))) (UniformSpace.Completion.coe'.{u3} γ _inst_3 (Prod.snd.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)))))
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ], DenseRange.{max (max u3 u2) u1, max (max u1 u2) u3} (Prod.{u1, max u3 u2} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (instTopologicalSpaceProd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (instTopologicalSpaceProd.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3)))) (Prod.{u1, max u3 u2} α (Prod.{u2, u3} β γ)) (fun (x : Prod.{u1, max u3 u2} α (Prod.{u2, u3} β γ)) => Prod.mk.{u1, max u3 u2} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)) (Prod.mk.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.coe'.{u2} β _inst_2 (Prod.fst.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x))) (UniformSpace.Completion.coe'.{u3} γ _inst_3 (Prod.snd.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)))))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_range_coe₃ UniformSpace.Completion.denseRange_coe₃ₓ'. -/
 theorem denseRange_coe₃ :
     DenseRange fun x : α × β × γ =>
@@ -662,7 +654,7 @@ theorem denseRange_coe₃ :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {p : (UniformSpace.Completion.{u1} α _inst_1) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1), (IsClosed.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (setOf.{u1} (UniformSpace.Completion.{u1} α _inst_1) (fun (a : UniformSpace.Completion.{u1} α _inst_1) => p a))) -> (forall (a : α), p ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) -> (p a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {p : (UniformSpace.Completion.{u1} α _inst_1) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1), (IsClosed.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (setOf.{u1} (UniformSpace.Completion.{u1} α _inst_1) (fun (a : UniformSpace.Completion.{u1} α _inst_1) => p a))) -> (forall (a : α), p (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) -> (p a)
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {p : (UniformSpace.Completion.{u1} α _inst_1) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1), (IsClosed.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (setOf.{u1} (UniformSpace.Completion.{u1} α _inst_1) (fun (a : UniformSpace.Completion.{u1} α _inst_1) => p a))) -> (forall (a : α), p (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) -> (p a)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.induction_on UniformSpace.Completion.induction_onₓ'. -/
 @[elab_as_elim]
 theorem induction_on {p : Completion α → Prop} (a : Completion α) (hp : IsClosed { a | p a })
@@ -674,7 +666,7 @@ theorem induction_on {p : Completion α → Prop} (a : Completion α) (hp : IsCl
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {p : (UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2), (IsClosed.{max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (Prod.topologicalSpace.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2))) (setOf.{max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (fun (x : Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) => p (Prod.fst.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) x) (Prod.snd.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) x)))) -> (forall (a : α) (b : β), p ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) b)) -> (p a b)
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {p : (UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2) -> Prop} (a : UniformSpace.Completion.{u2} α _inst_1) (b : UniformSpace.Completion.{u1} β _inst_2), (IsClosed.{max u2 u1} (Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) (instTopologicalSpaceProd.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} β _inst_2))) (setOf.{max u2 u1} (Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) (fun (x : Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) => p (Prod.fst.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) x) (Prod.snd.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) x)))) -> (forall (a : α) (b : β), p (UniformSpace.Completion.coe'.{u2} α _inst_1 a) (UniformSpace.Completion.coe'.{u1} β _inst_2 b)) -> (p a b)
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {p : (UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2) -> Prop} (a : UniformSpace.Completion.{u2} α _inst_1) (b : UniformSpace.Completion.{u1} β _inst_2), (IsClosed.{max u2 u1} (Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) (instTopologicalSpaceProd.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} β _inst_2))) (setOf.{max u2 u1} (Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) (fun (x : Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) => p (Prod.fst.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) x) (Prod.snd.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) x)))) -> (forall (a : α) (b : β), p (UniformSpace.Completion.coe'.{u2} α _inst_1 a) (UniformSpace.Completion.coe'.{u1} β _inst_2 b)) -> (p a b)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.induction_on₂ UniformSpace.Completion.induction_on₂ₓ'. -/
 @[elab_as_elim]
 theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Completion α) (b : Completion β)
@@ -689,7 +681,7 @@ theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Comp
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] {p : (UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> (UniformSpace.Completion.{u3} γ _inst_3) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2) (c : UniformSpace.Completion.{u3} γ _inst_3), (IsClosed.{max u1 u2 u3} (Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (Prod.topologicalSpace.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (Prod.topologicalSpace.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3)))) (setOf.{max u1 u2 u3} (Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (fun (x : Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) => p (Prod.fst.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) x) (Prod.fst.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (Prod.snd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) x)) (Prod.snd.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (Prod.snd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) x))))) -> (forall (a : α) (b : β) (c : γ), p ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) b) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) γ (UniformSpace.Completion.{u3} γ _inst_3) (HasLiftT.mk.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (CoeTCₓ.coe.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.hasCoeT.{u3} γ _inst_3))) c)) -> (p a b c)
 but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {p : (UniformSpace.Completion.{u3} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> (UniformSpace.Completion.{u1} γ _inst_3) -> Prop} (a : UniformSpace.Completion.{u3} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2) (c : UniformSpace.Completion.{u1} γ _inst_3), (IsClosed.{max (max u3 u2) u1} (Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) (instTopologicalSpaceProd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u3} α _inst_1)) (instTopologicalSpaceProd.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} γ _inst_3)))) (setOf.{max (max u3 u2) u1} (Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) (fun (x : Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) => p (Prod.fst.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x) (Prod.fst.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (Prod.snd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x)) (Prod.snd.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (Prod.snd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x))))) -> (forall (a : α) (b : β) (c : γ), p (UniformSpace.Completion.coe'.{u3} α _inst_1 a) (UniformSpace.Completion.coe'.{u2} β _inst_2 b) (UniformSpace.Completion.coe'.{u1} γ _inst_3 c)) -> (p a b c)
+  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {p : (UniformSpace.Completion.{u3} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> (UniformSpace.Completion.{u1} γ _inst_3) -> Prop} (a : UniformSpace.Completion.{u3} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2) (c : UniformSpace.Completion.{u1} γ _inst_3), (IsClosed.{max (max u3 u2) u1} (Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) (instTopologicalSpaceProd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.uniformSpace.{u3} α _inst_1)) (instTopologicalSpaceProd.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u1} γ _inst_3)))) (setOf.{max (max u3 u2) u1} (Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) (fun (x : Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) => p (Prod.fst.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x) (Prod.fst.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (Prod.snd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x)) (Prod.snd.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (Prod.snd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x))))) -> (forall (a : α) (b : β) (c : γ), p (UniformSpace.Completion.coe'.{u3} α _inst_1 a) (UniformSpace.Completion.coe'.{u2} β _inst_2 b) (UniformSpace.Completion.coe'.{u1} γ _inst_3 c)) -> (p a b c)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.induction_on₃ UniformSpace.Completion.induction_on₃ₓ'. -/
 @[elab_as_elim]
 theorem induction_on₃ {p : Completion α → Completion β → Completion γ → Prop} (a : Completion α)
@@ -705,7 +697,7 @@ theorem induction_on₃ {p : Completion α → Completion β → Completion γ 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> Y) f g)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) (g (UniformSpace.Completion.coe'.{u1} α _inst_1 a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> Y) f g)
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) (g (UniformSpace.Completion.coe'.{u1} α _inst_1 a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> Y) f g)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.ext UniformSpace.Completion.extₓ'. -/
 theorem ext {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
     (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) : f = g :=
@@ -716,7 +708,7 @@ theorem ext {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (forall (a : UniformSpace.Completion.{u1} α _inst_1), Eq.{succ u2} Y (f a) (g a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) (g (UniformSpace.Completion.coe'.{u1} α _inst_1 a))) -> (forall (a : UniformSpace.Completion.{u1} α _inst_1), Eq.{succ u2} Y (f a) (g a))
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) (g (UniformSpace.Completion.coe'.{u1} α _inst_1 a))) -> (forall (a : UniformSpace.Completion.{u1} α _inst_1), Eq.{succ u2} Y (f a) (g a))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.ext' UniformSpace.Completion.ext'ₓ'. -/
 theorem ext' {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
     (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) (a : Completion α) :
@@ -744,7 +736,7 @@ variable [CompleteSpace β]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : CompleteSpace.{u2} β _inst_2], UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) _inst_2 (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f)
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : CompleteSpace.{u1} β _inst_2], UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) _inst_2 (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f)
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : CompleteSpace.{u1} β _inst_2], UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u2} α _inst_1) _inst_2 (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_extension UniformSpace.Completion.uniformContinuous_extensionₓ'. -/
 theorem uniformContinuous_extension : UniformContinuous (Completion.extension f) :=
   cPkg.uniformContinuous_extend
@@ -754,7 +746,7 @@ theorem uniformContinuous_extension : UniformContinuous (Completion.extension f)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : CompleteSpace.{u2} β _inst_2], Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) β (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} β _inst_2) (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f)
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : CompleteSpace.{u1} β _inst_2], Continuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} β _inst_2) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f)
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : CompleteSpace.{u1} β _inst_2], Continuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} β _inst_2) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.continuous_extension UniformSpace.Completion.continuous_extensionₓ'. -/
 theorem continuous_extension : Continuous (Completion.extension f) :=
   cPkg.continuous_extend
@@ -780,7 +772,7 @@ variable [SeparatedSpace β] [CompleteSpace β]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u2} β _inst_2] [_inst_5 : CompleteSpace.{u2} β _inst_2], (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall {g : (UniformSpace.Completion.{u1} α _inst_1) -> β}, (UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) _inst_2 g) -> (forall (a : α), Eq.{succ u2} β (f a) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> β) (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f) g))
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u1} β _inst_2] [_inst_5 : CompleteSpace.{u1} β _inst_2], (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (forall {g : (UniformSpace.Completion.{u2} α _inst_1) -> β}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) _inst_2 g) -> (forall (a : α), Eq.{succ u1} β (f a) (g (UniformSpace.Completion.coe'.{u2} α _inst_1 a))) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> β) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f) g))
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u1} β _inst_2] [_inst_5 : CompleteSpace.{u1} β _inst_2], (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (forall {g : (UniformSpace.Completion.{u2} α _inst_1) -> β}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u2} α _inst_1) _inst_2 g) -> (forall (a : α), Eq.{succ u1} β (f a) (g (UniformSpace.Completion.coe'.{u2} α _inst_1 a))) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> β) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f) g))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.extension_unique UniformSpace.Completion.extension_uniqueₓ'. -/
 theorem extension_unique (hf : UniformContinuous f) {g : Completion α → β}
     (hg : UniformContinuous g) (h : ∀ a : α, f a = g (a : Completion α)) :
@@ -792,7 +784,7 @@ theorem extension_unique (hf : UniformContinuous f) {g : Completion α → β}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] [_inst_4 : SeparatedSpace.{u2} β _inst_2] [_inst_5 : CompleteSpace.{u2} β _inst_2] {f : (UniformSpace.Completion.{u1} α _inst_1) -> β}, (UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) _inst_2 f) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> β) (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (UniformSpace.Completion.{u1} α _inst_1) β f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1)))))) f)
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] [_inst_4 : SeparatedSpace.{u1} β _inst_2] [_inst_5 : CompleteSpace.{u1} β _inst_2] {f : (UniformSpace.Completion.{u2} α _inst_1) -> β}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) _inst_2 f) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> β) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 (Function.comp.{succ u2, succ u2, succ u1} α (UniformSpace.Completion.{u2} α _inst_1) β f (UniformSpace.Completion.coe'.{u2} α _inst_1))) f)
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] [_inst_4 : SeparatedSpace.{u1} β _inst_2] [_inst_5 : CompleteSpace.{u1} β _inst_2] {f : (UniformSpace.Completion.{u2} α _inst_1) -> β}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u2} α _inst_1) _inst_2 f) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> β) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 (Function.comp.{succ u2, succ u2, succ u1} α (UniformSpace.Completion.{u2} α _inst_1) β f (UniformSpace.Completion.coe'.{u2} α _inst_1))) f)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.extension_comp_coe UniformSpace.Completion.extension_comp_coeₓ'. -/
 @[simp]
 theorem extension_comp_coe {f : Completion α → β} (hf : UniformContinuous f) :
@@ -817,7 +809,7 @@ protected def map (f : α → β) : Completion α → Completion β :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β}, UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) (UniformSpace.Completion.map.{u1, u2} α _inst_1 β _inst_2 f)
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β}, UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} β _inst_2) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f)
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β}, UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} β _inst_2) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_map UniformSpace.Completion.uniformContinuous_mapₓ'. -/
 theorem uniformContinuous_map : UniformContinuous (Completion.map f) :=
   cPkg.uniformContinuous_map cPkg f
@@ -827,7 +819,7 @@ theorem uniformContinuous_map : UniformContinuous (Completion.map f) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β}, Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.Completion.map.{u1, u2} α _inst_1 β _inst_2 f)
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β}, Continuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} β _inst_2)) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f)
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β}, Continuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} β _inst_2)) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.continuous_map UniformSpace.Completion.continuous_mapₓ'. -/
 theorem continuous_map : Continuous (Completion.map f) :=
   cPkg.continuous_map cPkg f
@@ -848,7 +840,7 @@ theorem map_coe (hf : UniformContinuous f) (a : α) : (Completion.map f) a = f a
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} {g : (UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2)}, (UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) g) -> (forall (a : α), Eq.{succ u2} (UniformSpace.Completion.{u2} β _inst_2) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (f a)) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2)) (UniformSpace.Completion.map.{u1, u2} α _inst_1 β _inst_2 f) g)
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} {g : (UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2)}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} β _inst_2) g) -> (forall (a : α), Eq.{succ u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.coe'.{u1} β _inst_2 (f a)) (g (UniformSpace.Completion.coe'.{u2} α _inst_1 a))) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2)) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f) g)
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} {g : (UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2)}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} β _inst_2) g) -> (forall (a : α), Eq.{succ u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.coe'.{u1} β _inst_2 (f a)) (g (UniformSpace.Completion.coe'.{u2} α _inst_1 a))) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2)) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f) g)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.map_unique UniformSpace.Completion.map_uniqueₓ'. -/
 theorem map_unique {f : α → β} {g : Completion α → Completion β} (hg : UniformContinuous g)
     (h : ∀ a : α, ↑(f a) = g a) : Completion.map f = g :=
@@ -971,7 +963,7 @@ variable [CompleteSpace γ] (f)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (f : α -> β -> γ) [_inst_4 : CompleteSpace.{u3} γ _inst_3], UniformContinuous₂.{u1, u2, u3} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) γ (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) _inst_3 (UniformSpace.Completion.extension₂.{u1, u2, u3} α _inst_1 β _inst_2 γ _inst_3 f)
 but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (f : α -> β -> γ) [_inst_4 : CompleteSpace.{u1} γ _inst_3], UniformContinuous₂.{u3, u2, u1} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) γ (UniformSpace.Completion.instUniformSpaceCompletion.{u3} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2) _inst_3 (UniformSpace.Completion.extension₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f)
+  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (f : α -> β -> γ) [_inst_4 : CompleteSpace.{u1} γ _inst_3], UniformContinuous₂.{u3, u2, u1} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) γ (UniformSpace.Completion.uniformSpace.{u3} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) _inst_3 (UniformSpace.Completion.extension₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_extension₂ UniformSpace.Completion.uniformContinuous_extension₂ₓ'. -/
 theorem uniformContinuous_extension₂ : UniformContinuous₂ (Completion.extension₂ f) :=
   cPkg.uniformContinuous_extension₂ cPkg f
@@ -994,7 +986,7 @@ protected def map₂ (f : α → β → γ) : Completion α → Completion β 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (f : α -> β -> γ), UniformContinuous₂.{u1, u2, u3} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3) (UniformSpace.Completion.map₂.{u1, u2, u3} α _inst_1 β _inst_2 γ _inst_3 f)
 but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (f : α -> β -> γ), UniformContinuous₂.{u3, u2, u1} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.instUniformSpaceCompletion.{u3} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} γ _inst_3) (UniformSpace.Completion.map₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f)
+  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (f : α -> β -> γ), UniformContinuous₂.{u3, u2, u1} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} γ _inst_3) (UniformSpace.Completion.map₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_map₂ UniformSpace.Completion.uniformContinuous_map₂ₓ'. -/
 theorem uniformContinuous_map₂ (f : α → β → γ) : UniformContinuous₂ (Completion.map₂ f) :=
   cPkg.uniformContinuous_map₂ cPkg cPkg f
@@ -1004,7 +996,7 @@ theorem uniformContinuous_map₂ (f : α → β → γ) : UniformContinuous₂ (
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] {δ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} δ] {f : α -> β -> γ} {a : δ -> (UniformSpace.Completion.{u1} α _inst_1)} {b : δ -> (UniformSpace.Completion.{u2} β _inst_2)}, (Continuous.{u4, u1} δ (UniformSpace.Completion.{u1} α _inst_1) _inst_4 (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) a) -> (Continuous.{u4, u2} δ (UniformSpace.Completion.{u2} β _inst_2) _inst_4 (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) b) -> (Continuous.{u4, u3} δ (UniformSpace.Completion.{u3} γ _inst_3) _inst_4 (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3)) (fun (d : δ) => UniformSpace.Completion.map₂.{u1, u2, u3} α _inst_1 β _inst_2 γ _inst_3 f (a d) (b d)))
 but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {δ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} δ] {f : α -> β -> γ} {a : δ -> (UniformSpace.Completion.{u3} α _inst_1)} {b : δ -> (UniformSpace.Completion.{u2} β _inst_2)}, (Continuous.{u4, u3} δ (UniformSpace.Completion.{u3} α _inst_1) _inst_4 (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u3} α _inst_1)) a) -> (Continuous.{u4, u2} δ (UniformSpace.Completion.{u2} β _inst_2) _inst_4 (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2)) b) -> (Continuous.{u4, u1} δ (UniformSpace.Completion.{u1} γ _inst_3) _inst_4 (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} γ _inst_3)) (fun (d : δ) => UniformSpace.Completion.map₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f (a d) (b d)))
+  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {δ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} δ] {f : α -> β -> γ} {a : δ -> (UniformSpace.Completion.{u3} α _inst_1)} {b : δ -> (UniformSpace.Completion.{u2} β _inst_2)}, (Continuous.{u4, u3} δ (UniformSpace.Completion.{u3} α _inst_1) _inst_4 (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.uniformSpace.{u3} α _inst_1)) a) -> (Continuous.{u4, u2} δ (UniformSpace.Completion.{u2} β _inst_2) _inst_4 (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) b) -> (Continuous.{u4, u1} δ (UniformSpace.Completion.{u1} γ _inst_3) _inst_4 (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u1} γ _inst_3)) (fun (d : δ) => UniformSpace.Completion.map₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f (a d) (b d)))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.continuous_map₂ UniformSpace.Completion.continuous_map₂ₓ'. -/
 theorem continuous_map₂ {δ} [TopologicalSpace δ] {f : α → β → γ} {a : δ → Completion α}
     {b : δ → Completion β} (ha : Continuous a) (hb : Continuous b) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/3b267e70a936eebb21ab546f49a8df34dd300b25

@@ -469,7 +469,7 @@ instance : CoeTC α (Completion α) :=
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (α -> (UniformSpace.Completion.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1)))) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.uniformSpace.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (α -> (UniformSpace.Completion.{u1} α _inst_1)) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1)) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (Quotient.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (α -> (UniformSpace.Completion.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (Quotient.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.coe_eq UniformSpace.Completion.coe_eqₓ'. -/
 -- note [use has_coe_t]
 protected theorem coe_eq : (coe : α → Completion α) = Quotient.mk' ∘ pureCauchy :=
@@ -480,7 +480,7 @@ protected theorem coe_eq : (coe : α → Completion α) = Quotient.mk' ∘ pureC
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.comap.{u1, u1} (Prod.{u1, u1} α α) (Prod.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1)) (fun (p : Prod.{u1, u1} α α) => Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.fst.{u1, u1} α α p)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.snd.{u1, u1} α α p))) (uniformity.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1))) (uniformity.{u1} α _inst_1)
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.comap.{u1, u1} (Prod.{u1, u1} α α) (Prod.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1)) (fun (p : Prod.{u1, u1} α α) => Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1) (Prod.fst.{u1, u1} α α p)) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1) (Prod.snd.{u1, u1} α α p))) (uniformity.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1))) (uniformity.{u1} α _inst_1)
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Eq.{succ u1} (Filter.{u1} (Prod.{u1, u1} α α)) (Filter.comap.{u1, u1} (Prod.{u1, u1} α α) (Prod.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1)) (fun (p : Prod.{u1, u1} α α) => Prod.mk.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, u1} α α p)) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.snd.{u1, u1} α α p))) (uniformity.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1))) (uniformity.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.comap_coe_eq_uniformity UniformSpace.Completion.comap_coe_eq_uniformityₓ'. -/
 theorem comap_coe_eq_uniformity :
     ((𝓤 _).comap fun p : α × α => ((p.1 : Completion α), (p.2 : Completion α))) = 𝓤 α :=
@@ -500,7 +500,7 @@ theorem comap_coe_eq_uniformity :
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_inducing_coe UniformSpace.Completion.uniformInducing_coeₓ'. -/
 theorem uniformInducing_coe : UniformInducing (coe : α → Completion α) :=
   ⟨comap_coe_eq_uniformity α⟩
@@ -512,7 +512,7 @@ variable {α}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseRange.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) α ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseRange.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) α (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseRange.{u1, u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) α (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_range_coe UniformSpace.Completion.denseRange_coeₓ'. -/
 theorem denseRange_coe : DenseRange (coe : α → Completion α) :=
   denseRange_pureCauchy.Quotient
@@ -553,7 +553,7 @@ theorem nonempty_completion_iff : Nonempty (Completion α) ↔ Nonempty α :=
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformContinuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformContinuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], UniformContinuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_continuous_coe UniformSpace.Completion.uniformContinuous_coeₓ'. -/
 theorem uniformContinuous_coe : UniformContinuous (coe : α → Completion α) :=
   cPkg.uniformContinuous_coe
@@ -563,7 +563,7 @@ theorem uniformContinuous_coe : UniformContinuous (coe : α → Completion α) :
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Continuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Continuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α], Continuous.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.continuous_coe UniformSpace.Completion.continuous_coeₓ'. -/
 theorem continuous_coe : Continuous (coe : α → Completion α) :=
   cPkg.continuous_coe
@@ -573,7 +573,7 @@ theorem continuous_coe : Continuous (coe : α → Completion α) :=
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], UniformEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], UniformEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], UniformEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) _inst_1 (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.uniform_embedding_coe UniformSpace.Completion.uniformEmbedding_coeₓ'. -/
 theorem uniformEmbedding_coe [SeparatedSpace α] : UniformEmbedding (coe : α → Completion α) :=
   { comap_uniformity := comap_coe_eq_uniformity α
@@ -584,7 +584,7 @@ theorem uniformEmbedding_coe [SeparatedSpace α] : UniformEmbedding (coe : α 
 lean 3 declaration is
   forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], Function.Injective.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], Function.Injective.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
+  forall (α : Type.{u1}) [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], Function.Injective.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.coe_injective UniformSpace.Completion.coe_injectiveₓ'. -/
 theorem coe_injective [SeparatedSpace α] : Function.Injective (coe : α → Completion α) :=
   UniformEmbedding.inj (uniformEmbedding_coe _)
@@ -596,7 +596,7 @@ variable {α}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], DenseInducing.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_inducing_coe UniformSpace.Completion.denseInducing_coeₓ'. -/
 theorem denseInducing_coe : DenseInducing (coe : α → Completion α) :=
   { (uniformInducing_coe α).Inducing with dense := denseRange_coe }
@@ -629,7 +629,7 @@ instance separableSpace_completion [SeparableSpace α] : SeparableSpace (Complet
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], DenseEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], DenseEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1))
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] [_inst_4 : SeparatedSpace.{u1} α _inst_1], DenseEmbedding.{u1, u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (UniformSpace.Completion.coe'.{u1} α _inst_1)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_embedding_coe UniformSpace.Completion.denseEmbedding_coeₓ'. -/
 theorem denseEmbedding_coe [SeparatedSpace α] : DenseEmbedding (coe : α → Completion α) :=
   { denseInducing_coe with inj := separated_pureCauchy_injective }
@@ -639,7 +639,7 @@ theorem denseEmbedding_coe [SeparatedSpace α] : DenseEmbedding (coe : α → Co
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β], DenseRange.{max u1 u2, max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (Prod.topologicalSpace.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2))) (Prod.{u1, u2} α β) (fun (x : Prod.{u1, u2} α β) => Prod.mk.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.fst.{u1, u2} α β x)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (Prod.snd.{u1, u2} α β x)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β], DenseRange.{max u2 u1, max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (instTopologicalSpaceProd.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2))) (Prod.{u1, u2} α β) (fun (x : Prod.{u1, u2} α β) => Prod.mk.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (Function.comp.{succ u2, succ u2, succ u2} β (CauchyFilter.{u2} β _inst_2) (UniformSpace.Completion.{u2} β _inst_2) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} β _inst_2) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} β _inst_2) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} β _inst_2))) (CauchyFilter.pureCauchy.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β], DenseRange.{max u2 u1, max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (instTopologicalSpaceProd.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2))) (Prod.{u1, u2} α β) (fun (x : Prod.{u1, u2} α β) => Prod.mk.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, u2} α β x)) (UniformSpace.Completion.coe'.{u2} β _inst_2 (Prod.snd.{u1, u2} α β x)))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_range_coe₂ UniformSpace.Completion.denseRange_coe₂ₓ'. -/
 theorem denseRange_coe₂ :
     DenseRange fun x : α × β => ((x.1 : Completion α), (x.2 : Completion β)) :=
@@ -650,7 +650,7 @@ theorem denseRange_coe₂ :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ], DenseRange.{max u1 u2 u3, max u1 u2 u3} (Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (Prod.topologicalSpace.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (Prod.topologicalSpace.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3)))) (Prod.{u1, max u2 u3} α (Prod.{u2, u3} β γ)) (fun (x : Prod.{u1, max u2 u3} α (Prod.{u2, u3} β γ)) => Prod.mk.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) (Prod.fst.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)) (Prod.mk.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (Prod.fst.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x))) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) γ (UniformSpace.Completion.{u3} γ _inst_3) (HasLiftT.mk.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (CoeTCₓ.coe.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.hasCoeT.{u3} γ _inst_3))) (Prod.snd.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ], DenseRange.{max (max u3 u2) u1, max (max u1 u2) u3} (Prod.{u1, max u3 u2} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (instTopologicalSpaceProd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (instTopologicalSpaceProd.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.instUniformSpaceCompletion.{u3} γ _inst_3)))) (Prod.{u1, max u3 u2} α (Prod.{u2, u3} β γ)) (fun (x : Prod.{u1, max u3 u2} α (Prod.{u2, u3} β γ)) => Prod.mk.{u1, max u3 u2} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1) (Prod.fst.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)) (Prod.mk.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (Function.comp.{succ u2, succ u2, succ u2} β (CauchyFilter.{u2} β _inst_2) (UniformSpace.Completion.{u2} β _inst_2) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} β _inst_2) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} β _inst_2) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} β _inst_2))) (CauchyFilter.pureCauchy.{u2} β _inst_2) (Prod.fst.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x))) (Function.comp.{succ u3, succ u3, succ u3} γ (CauchyFilter.{u3} γ _inst_3) (UniformSpace.Completion.{u3} γ _inst_3) (Quotient.mk'.{succ u3} (CauchyFilter.{u3} γ _inst_3) (UniformSpace.separationSetoid.{u3} (CauchyFilter.{u3} γ _inst_3) (CauchyFilter.instUniformSpaceCauchyFilter.{u3} γ _inst_3))) (CauchyFilter.pureCauchy.{u3} γ _inst_3) (Prod.snd.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)))))
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ], DenseRange.{max (max u3 u2) u1, max (max u1 u2) u3} (Prod.{u1, max u3 u2} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (instTopologicalSpaceProd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (instTopologicalSpaceProd.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.instUniformSpaceCompletion.{u3} γ _inst_3)))) (Prod.{u1, max u3 u2} α (Prod.{u2, u3} β γ)) (fun (x : Prod.{u1, max u3 u2} α (Prod.{u2, u3} β γ)) => Prod.mk.{u1, max u3 u2} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.Completion.coe'.{u1} α _inst_1 (Prod.fst.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)) (Prod.mk.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.coe'.{u2} β _inst_2 (Prod.fst.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x))) (UniformSpace.Completion.coe'.{u3} γ _inst_3 (Prod.snd.{u2, u3} β γ (Prod.snd.{u1, max u2 u3} α (Prod.{u2, u3} β γ) x)))))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.dense_range_coe₃ UniformSpace.Completion.denseRange_coe₃ₓ'. -/
 theorem denseRange_coe₃ :
     DenseRange fun x : α × β × γ =>
@@ -662,7 +662,7 @@ theorem denseRange_coe₃ :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {p : (UniformSpace.Completion.{u1} α _inst_1) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1), (IsClosed.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (setOf.{u1} (UniformSpace.Completion.{u1} α _inst_1) (fun (a : UniformSpace.Completion.{u1} α _inst_1) => p a))) -> (forall (a : α), p ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) -> (p a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {p : (UniformSpace.Completion.{u1} α _inst_1) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1), (IsClosed.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (setOf.{u1} (UniformSpace.Completion.{u1} α _inst_1) (fun (a : UniformSpace.Completion.{u1} α _inst_1) => p a))) -> (forall (a : α), p (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1) a)) -> (p a)
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {p : (UniformSpace.Completion.{u1} α _inst_1) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1), (IsClosed.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) (setOf.{u1} (UniformSpace.Completion.{u1} α _inst_1) (fun (a : UniformSpace.Completion.{u1} α _inst_1) => p a))) -> (forall (a : α), p (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) -> (p a)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.induction_on UniformSpace.Completion.induction_onₓ'. -/
 @[elab_as_elim]
 theorem induction_on {p : Completion α → Prop} (a : Completion α) (hp : IsClosed { a | p a })
@@ -674,7 +674,7 @@ theorem induction_on {p : Completion α → Prop} (a : Completion α) (hp : IsCl
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {p : (UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2), (IsClosed.{max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (Prod.topologicalSpace.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2))) (setOf.{max u1 u2} (Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) (fun (x : Prod.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2)) => p (Prod.fst.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) x) (Prod.snd.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) x)))) -> (forall (a : α) (b : β), p ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) b)) -> (p a b)
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {p : (UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2) -> Prop} (a : UniformSpace.Completion.{u2} α _inst_1) (b : UniformSpace.Completion.{u1} β _inst_2), (IsClosed.{max u2 u1} (Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) (instTopologicalSpaceProd.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} β _inst_2))) (setOf.{max u2 u1} (Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) (fun (x : Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) => p (Prod.fst.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) x) (Prod.snd.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) x)))) -> (forall (a : α) (b : β), p (Function.comp.{succ u2, succ u2, succ u2} α (CauchyFilter.{u2} α _inst_1) (UniformSpace.Completion.{u2} α _inst_1) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} α _inst_1) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} α _inst_1))) (CauchyFilter.pureCauchy.{u2} α _inst_1) a) (Function.comp.{succ u1, succ u1, succ u1} β (CauchyFilter.{u1} β _inst_2) (UniformSpace.Completion.{u1} β _inst_2) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} β _inst_2) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} β _inst_2) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} β _inst_2))) (CauchyFilter.pureCauchy.{u1} β _inst_2) b)) -> (p a b)
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {p : (UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2) -> Prop} (a : UniformSpace.Completion.{u2} α _inst_1) (b : UniformSpace.Completion.{u1} β _inst_2), (IsClosed.{max u2 u1} (Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) (instTopologicalSpaceProd.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} β _inst_2))) (setOf.{max u2 u1} (Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) (fun (x : Prod.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2)) => p (Prod.fst.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) x) (Prod.snd.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) x)))) -> (forall (a : α) (b : β), p (UniformSpace.Completion.coe'.{u2} α _inst_1 a) (UniformSpace.Completion.coe'.{u1} β _inst_2 b)) -> (p a b)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.induction_on₂ UniformSpace.Completion.induction_on₂ₓ'. -/
 @[elab_as_elim]
 theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Completion α) (b : Completion β)
@@ -689,7 +689,7 @@ theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Comp
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] {p : (UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> (UniformSpace.Completion.{u3} γ _inst_3) -> Prop} (a : UniformSpace.Completion.{u1} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2) (c : UniformSpace.Completion.{u3} γ _inst_3), (IsClosed.{max u1 u2 u3} (Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (Prod.topologicalSpace.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) (Prod.topologicalSpace.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.uniformSpace.{u3} γ _inst_3)))) (setOf.{max u1 u2 u3} (Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) (fun (x : Prod.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3))) => p (Prod.fst.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) x) (Prod.fst.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (Prod.snd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) x)) (Prod.snd.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3) (Prod.snd.{u1, max u2 u3} (UniformSpace.Completion.{u1} α _inst_1) (Prod.{u2, u3} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u3} γ _inst_3)) x))))) -> (forall (a : α) (b : β) (c : γ), p ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) b) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) γ (UniformSpace.Completion.{u3} γ _inst_3) (HasLiftT.mk.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (CoeTCₓ.coe.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.hasCoeT.{u3} γ _inst_3))) c)) -> (p a b c)
 but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {p : (UniformSpace.Completion.{u3} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> (UniformSpace.Completion.{u1} γ _inst_3) -> Prop} (a : UniformSpace.Completion.{u3} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2) (c : UniformSpace.Completion.{u1} γ _inst_3), (IsClosed.{max (max u3 u2) u1} (Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) (instTopologicalSpaceProd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u3} α _inst_1)) (instTopologicalSpaceProd.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} γ _inst_3)))) (setOf.{max (max u3 u2) u1} (Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) (fun (x : Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) => p (Prod.fst.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x) (Prod.fst.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (Prod.snd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x)) (Prod.snd.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (Prod.snd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x))))) -> (forall (a : α) (b : β) (c : γ), p (Function.comp.{succ u3, succ u3, succ u3} α (CauchyFilter.{u3} α _inst_1) (UniformSpace.Completion.{u3} α _inst_1) (Quotient.mk'.{succ u3} (CauchyFilter.{u3} α _inst_1) (UniformSpace.separationSetoid.{u3} (CauchyFilter.{u3} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u3} α _inst_1))) (CauchyFilter.pureCauchy.{u3} α _inst_1) a) (Function.comp.{succ u2, succ u2, succ u2} β (CauchyFilter.{u2} β _inst_2) (UniformSpace.Completion.{u2} β _inst_2) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} β _inst_2) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} β _inst_2) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} β _inst_2))) (CauchyFilter.pureCauchy.{u2} β _inst_2) b) (Function.comp.{succ u1, succ u1, succ u1} γ (CauchyFilter.{u1} γ _inst_3) (UniformSpace.Completion.{u1} γ _inst_3) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} γ _inst_3) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} γ _inst_3) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} γ _inst_3))) (CauchyFilter.pureCauchy.{u1} γ _inst_3) c)) -> (p a b c)
+  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {p : (UniformSpace.Completion.{u3} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2) -> (UniformSpace.Completion.{u1} γ _inst_3) -> Prop} (a : UniformSpace.Completion.{u3} α _inst_1) (b : UniformSpace.Completion.{u2} β _inst_2) (c : UniformSpace.Completion.{u1} γ _inst_3), (IsClosed.{max (max u3 u2) u1} (Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) (instTopologicalSpaceProd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) (UniformSpace.toTopologicalSpace.{u3} (UniformSpace.Completion.{u3} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u3} α _inst_1)) (instTopologicalSpaceProd.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.toTopologicalSpace.{u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} β _inst_2)) (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} γ _inst_3)))) (setOf.{max (max u3 u2) u1} (Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) (fun (x : Prod.{u3, max u1 u2} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3))) => p (Prod.fst.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x) (Prod.fst.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (Prod.snd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x)) (Prod.snd.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3) (Prod.snd.{u3, max u2 u1} (UniformSpace.Completion.{u3} α _inst_1) (Prod.{u2, u1} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.{u1} γ _inst_3)) x))))) -> (forall (a : α) (b : β) (c : γ), p (UniformSpace.Completion.coe'.{u3} α _inst_1 a) (UniformSpace.Completion.coe'.{u2} β _inst_2 b) (UniformSpace.Completion.coe'.{u1} γ _inst_3 c)) -> (p a b c)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.induction_on₃ UniformSpace.Completion.induction_on₃ₓ'. -/
 @[elab_as_elim]
 theorem induction_on₃ {p : Completion α → Completion β → Completion γ → Prop} (a : Completion α)
@@ -705,7 +705,7 @@ theorem induction_on₃ {p : Completion α → Completion β → Completion γ 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> Y) f g)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1) a)) (g (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1) a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> Y) f g)
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) (g (UniformSpace.Completion.coe'.{u1} α _inst_1 a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> Y) f g)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.ext UniformSpace.Completion.extₓ'. -/
 theorem ext {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
     (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) : f = g :=
@@ -716,7 +716,7 @@ theorem ext {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α 
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (forall (a : UniformSpace.Completion.{u1} α _inst_1), Eq.{succ u2} Y (f a) (g a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1) a)) (g (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1) a))) -> (forall (a : UniformSpace.Completion.{u1} α _inst_1), Eq.{succ u2} Y (f a) (g a))
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {Y : Type.{u2}} [_inst_4 : TopologicalSpace.{u2} Y] [_inst_5 : T2Space.{u2} Y _inst_4] {f : (UniformSpace.Completion.{u1} α _inst_1) -> Y} {g : (UniformSpace.Completion.{u1} α _inst_1) -> Y}, (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 f) -> (Continuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) Y (UniformSpace.toTopologicalSpace.{u1} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} α _inst_1)) _inst_4 g) -> (forall (a : α), Eq.{succ u2} Y (f (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) (g (UniformSpace.Completion.coe'.{u1} α _inst_1 a))) -> (forall (a : UniformSpace.Completion.{u1} α _inst_1), Eq.{succ u2} Y (f a) (g a))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.ext' UniformSpace.Completion.ext'ₓ'. -/
 theorem ext' {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
     (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) (a : Completion α) :
@@ -766,7 +766,7 @@ end CompleteSpace
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u2} β _inst_2], (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u2} β (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) (f a))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u2} β _inst_2], (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u2} β (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f (Function.comp.{succ u1, succ u1, succ u1} α (CauchyFilter.{u1} α _inst_1) (UniformSpace.Completion.{u1} α _inst_1) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} α _inst_1) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_1))) (CauchyFilter.pureCauchy.{u1} α _inst_1) a)) (f a))
+  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u2} β _inst_2], (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u2} β (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f (UniformSpace.Completion.coe'.{u1} α _inst_1 a)) (f a))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.extension_coe UniformSpace.Completion.extension_coeₓ'. -/
 @[simp]
 theorem extension_coe [SeparatedSpace β] (hf : UniformContinuous f) (a : α) :
@@ -780,7 +780,7 @@ variable [SeparatedSpace β] [CompleteSpace β]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u2} β _inst_2] [_inst_5 : CompleteSpace.{u2} β _inst_2], (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall {g : (UniformSpace.Completion.{u1} α _inst_1) -> β}, (UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) _inst_2 g) -> (forall (a : α), Eq.{succ u2} β (f a) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> β) (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 f) g))
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u1} β _inst_2] [_inst_5 : CompleteSpace.{u1} β _inst_2], (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (forall {g : (UniformSpace.Completion.{u2} α _inst_1) -> β}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) _inst_2 g) -> (forall (a : α), Eq.{succ u1} β (f a) (g (Function.comp.{succ u2, succ u2, succ u2} α (CauchyFilter.{u2} α _inst_1) (UniformSpace.Completion.{u2} α _inst_1) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} α _inst_1) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} α _inst_1))) (CauchyFilter.pureCauchy.{u2} α _inst_1) a))) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> β) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f) g))
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_4 : SeparatedSpace.{u1} β _inst_2] [_inst_5 : CompleteSpace.{u1} β _inst_2], (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (forall {g : (UniformSpace.Completion.{u2} α _inst_1) -> β}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) _inst_2 g) -> (forall (a : α), Eq.{succ u1} β (f a) (g (UniformSpace.Completion.coe'.{u2} α _inst_1 a))) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> β) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 f) g))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.extension_unique UniformSpace.Completion.extension_uniqueₓ'. -/
 theorem extension_unique (hf : UniformContinuous f) {g : Completion α → β}
     (hg : UniformContinuous g) (h : ∀ a : α, f a = g (a : Completion α)) :
@@ -792,7 +792,7 @@ theorem extension_unique (hf : UniformContinuous f) {g : Completion α → β}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] [_inst_4 : SeparatedSpace.{u2} β _inst_2] [_inst_5 : CompleteSpace.{u2} β _inst_2] {f : (UniformSpace.Completion.{u1} α _inst_1) -> β}, (UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) β (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) _inst_2 f) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> β) (UniformSpace.Completion.extension.{u1, u2} α _inst_1 β _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (UniformSpace.Completion.{u1} α _inst_1) β f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1)))))) f)
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] [_inst_4 : SeparatedSpace.{u1} β _inst_2] [_inst_5 : CompleteSpace.{u1} β _inst_2] {f : (UniformSpace.Completion.{u2} α _inst_1) -> β}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) _inst_2 f) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> β) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 (Function.comp.{succ u2, succ u2, succ u1} α (UniformSpace.Completion.{u2} α _inst_1) β f (Function.comp.{succ u2, succ u2, succ u2} α (CauchyFilter.{u2} α _inst_1) (UniformSpace.Completion.{u2} α _inst_1) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} α _inst_1) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} α _inst_1))) (CauchyFilter.pureCauchy.{u2} α _inst_1)))) f)
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] [_inst_4 : SeparatedSpace.{u1} β _inst_2] [_inst_5 : CompleteSpace.{u1} β _inst_2] {f : (UniformSpace.Completion.{u2} α _inst_1) -> β}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) β (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) _inst_2 f) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> β) (UniformSpace.Completion.extension.{u2, u1} α _inst_1 β _inst_2 (Function.comp.{succ u2, succ u2, succ u1} α (UniformSpace.Completion.{u2} α _inst_1) β f (UniformSpace.Completion.coe'.{u2} α _inst_1))) f)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.extension_comp_coe UniformSpace.Completion.extension_comp_coeₓ'. -/
 @[simp]
 theorem extension_comp_coe {f : Completion α → β} (hf : UniformContinuous f) :
@@ -837,7 +837,7 @@ theorem continuous_map : Continuous (Completion.map f) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β}, (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u2} (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.map.{u1, u2} α _inst_1 β _inst_2 f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a)) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (f a)))
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β}, (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f (Function.comp.{succ u2, succ u2, succ u2} α (CauchyFilter.{u2} α _inst_1) (UniformSpace.Completion.{u2} α _inst_1) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} α _inst_1) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} α _inst_1))) (CauchyFilter.pureCauchy.{u2} α _inst_1) a)) (Function.comp.{succ u1, succ u1, succ u1} β (CauchyFilter.{u1} β _inst_2) (UniformSpace.Completion.{u1} β _inst_2) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} β _inst_2) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} β _inst_2) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} β _inst_2))) (CauchyFilter.pureCauchy.{u1} β _inst_2) (f a)))
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β}, (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f (UniformSpace.Completion.coe'.{u2} α _inst_1 a)) (UniformSpace.Completion.coe'.{u1} β _inst_2 (f a)))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.map_coe UniformSpace.Completion.map_coeₓ'. -/
 @[simp]
 theorem map_coe (hf : UniformContinuous f) (a : α) : (Completion.map f) a = f a :=
@@ -848,7 +848,7 @@ theorem map_coe (hf : UniformContinuous f) (a : α) : (Completion.map f) a = f a
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} {g : (UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2)}, (UniformContinuous.{u1, u2} (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.uniformSpace.{u1} α _inst_1) (UniformSpace.Completion.uniformSpace.{u2} β _inst_2) g) -> (forall (a : α), Eq.{succ u2} (UniformSpace.Completion.{u2} β _inst_2) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) (f a)) (g ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a))) -> (Eq.{max (succ u1) (succ u2)} ((UniformSpace.Completion.{u1} α _inst_1) -> (UniformSpace.Completion.{u2} β _inst_2)) (UniformSpace.Completion.map.{u1, u2} α _inst_1 β _inst_2 f) g)
 but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} {g : (UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2)}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} β _inst_2) g) -> (forall (a : α), Eq.{succ u1} (UniformSpace.Completion.{u1} β _inst_2) (Function.comp.{succ u1, succ u1, succ u1} β (CauchyFilter.{u1} β _inst_2) (UniformSpace.Completion.{u1} β _inst_2) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} β _inst_2) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} β _inst_2) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} β _inst_2))) (CauchyFilter.pureCauchy.{u1} β _inst_2) (f a)) (g (Function.comp.{succ u2, succ u2, succ u2} α (CauchyFilter.{u2} α _inst_1) (UniformSpace.Completion.{u2} α _inst_1) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} α _inst_1) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} α _inst_1))) (CauchyFilter.pureCauchy.{u2} α _inst_1) a))) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2)) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f) g)
+  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} {g : (UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2)}, (UniformContinuous.{u2, u1} (UniformSpace.Completion.{u2} α _inst_1) (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.instUniformSpaceCompletion.{u2} α _inst_1) (UniformSpace.Completion.instUniformSpaceCompletion.{u1} β _inst_2) g) -> (forall (a : α), Eq.{succ u1} (UniformSpace.Completion.{u1} β _inst_2) (UniformSpace.Completion.coe'.{u1} β _inst_2 (f a)) (g (UniformSpace.Completion.coe'.{u2} α _inst_1 a))) -> (Eq.{max (succ u2) (succ u1)} ((UniformSpace.Completion.{u2} α _inst_1) -> (UniformSpace.Completion.{u1} β _inst_2)) (UniformSpace.Completion.map.{u2, u1} α _inst_1 β _inst_2 f) g)
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.map_unique UniformSpace.Completion.map_uniqueₓ'. -/
 theorem map_unique {f : α → β} {g : Completion α → Completion β} (hg : UniformContinuous g)
     (h : ∀ a : α, ↑(f a) = g a) : Completion.map f = g :=
@@ -955,7 +955,7 @@ variable [SeparatedSpace γ] {f}
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] {f : α -> β -> γ} [_inst_4 : SeparatedSpace.{u3} γ _inst_3], (UniformContinuous₂.{u1, u2, u3} α β γ _inst_1 _inst_2 _inst_3 f) -> (forall (a : α) (b : β), Eq.{succ u3} γ (UniformSpace.Completion.extension₂.{u1, u2, u3} α _inst_1 β _inst_2 γ _inst_3 f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) b)) (f a b))
 but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {f : α -> β -> γ} [_inst_4 : SeparatedSpace.{u1} γ _inst_3], (UniformContinuous₂.{u3, u2, u1} α β γ _inst_1 _inst_2 _inst_3 f) -> (forall (a : α) (b : β), Eq.{succ u1} γ (UniformSpace.Completion.extension₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f (Function.comp.{succ u3, succ u3, succ u3} α (CauchyFilter.{u3} α _inst_1) (UniformSpace.Completion.{u3} α _inst_1) (Quotient.mk'.{succ u3} (CauchyFilter.{u3} α _inst_1) (UniformSpace.separationSetoid.{u3} (CauchyFilter.{u3} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u3} α _inst_1))) (CauchyFilter.pureCauchy.{u3} α _inst_1) a) (Function.comp.{succ u2, succ u2, succ u2} β (CauchyFilter.{u2} β _inst_2) (UniformSpace.Completion.{u2} β _inst_2) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} β _inst_2) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} β _inst_2) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} β _inst_2))) (CauchyFilter.pureCauchy.{u2} β _inst_2) b)) (f a b))
+  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] {f : α -> β -> γ} [_inst_4 : SeparatedSpace.{u1} γ _inst_3], (UniformContinuous₂.{u3, u2, u1} α β γ _inst_1 _inst_2 _inst_3 f) -> (forall (a : α) (b : β), Eq.{succ u1} γ (UniformSpace.Completion.extension₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f (UniformSpace.Completion.coe'.{u3} α _inst_1 a) (UniformSpace.Completion.coe'.{u2} β _inst_2 b)) (f a b))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.extension₂_coe_coe UniformSpace.Completion.extension₂_coe_coeₓ'. -/
 @[simp]
 theorem extension₂_coe_coe (hf : UniformContinuous₂ f) (a : α) (b : β) :
@@ -1016,7 +1016,7 @@ theorem continuous_map₂ {δ} [TopologicalSpace δ] {f : α → β → γ} {a :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (a : α) (b : β) (f : α -> β -> γ), (UniformContinuous₂.{u1, u2, u3} α β γ _inst_1 _inst_2 _inst_3 f) -> (Eq.{succ u3} (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.map₂.{u1, u2, u3} α _inst_1 β _inst_2 γ _inst_3 f ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (UniformSpace.Completion.{u1} α _inst_1) (HasLiftT.mk.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (CoeTCₓ.coe.{succ u1, succ u1} α (UniformSpace.Completion.{u1} α _inst_1) (UniformSpace.Completion.hasCoeT.{u1} α _inst_1))) a) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) β (UniformSpace.Completion.{u2} β _inst_2) (HasLiftT.mk.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (CoeTCₓ.coe.{succ u2, succ u2} β (UniformSpace.Completion.{u2} β _inst_2) (UniformSpace.Completion.hasCoeT.{u2} β _inst_2))) b)) ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) γ (UniformSpace.Completion.{u3} γ _inst_3) (HasLiftT.mk.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (CoeTCₓ.coe.{succ u3, succ u3} γ (UniformSpace.Completion.{u3} γ _inst_3) (UniformSpace.Completion.hasCoeT.{u3} γ _inst_3))) (f a b)))
 but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (a : α) (b : β) (f : α -> β -> γ), (UniformContinuous₂.{u3, u2, u1} α β γ _inst_1 _inst_2 _inst_3 f) -> (Eq.{succ u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.map₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f (Function.comp.{succ u3, succ u3, succ u3} α (CauchyFilter.{u3} α _inst_1) (UniformSpace.Completion.{u3} α _inst_1) (Quotient.mk'.{succ u3} (CauchyFilter.{u3} α _inst_1) (UniformSpace.separationSetoid.{u3} (CauchyFilter.{u3} α _inst_1) (CauchyFilter.instUniformSpaceCauchyFilter.{u3} α _inst_1))) (CauchyFilter.pureCauchy.{u3} α _inst_1) a) (Function.comp.{succ u2, succ u2, succ u2} β (CauchyFilter.{u2} β _inst_2) (UniformSpace.Completion.{u2} β _inst_2) (Quotient.mk'.{succ u2} (CauchyFilter.{u2} β _inst_2) (UniformSpace.separationSetoid.{u2} (CauchyFilter.{u2} β _inst_2) (CauchyFilter.instUniformSpaceCauchyFilter.{u2} β _inst_2))) (CauchyFilter.pureCauchy.{u2} β _inst_2) b)) (Function.comp.{succ u1, succ u1, succ u1} γ (CauchyFilter.{u1} γ _inst_3) (UniformSpace.Completion.{u1} γ _inst_3) (Quotient.mk'.{succ u1} (CauchyFilter.{u1} γ _inst_3) (UniformSpace.separationSetoid.{u1} (CauchyFilter.{u1} γ _inst_3) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} γ _inst_3))) (CauchyFilter.pureCauchy.{u1} γ _inst_3) (f a b)))
+  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (a : α) (b : β) (f : α -> β -> γ), (UniformContinuous₂.{u3, u2, u1} α β γ _inst_1 _inst_2 _inst_3 f) -> (Eq.{succ u1} (UniformSpace.Completion.{u1} γ _inst_3) (UniformSpace.Completion.map₂.{u3, u2, u1} α _inst_1 β _inst_2 γ _inst_3 f (UniformSpace.Completion.coe'.{u3} α _inst_1 a) (UniformSpace.Completion.coe'.{u2} β _inst_2 b)) (UniformSpace.Completion.coe'.{u1} γ _inst_3 (f a b)))
 Case conversion may be inaccurate. Consider using '#align uniform_space.completion.map₂_coe_coe UniformSpace.Completion.map₂_coe_coeₓ'. -/
 theorem map₂_coe_coe (a : α) (b : β) (f : α → β → γ) (hf : UniformContinuous₂ f) :
     Completion.map₂ f (a : Completion α) (b : Completion β) = f a b :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

@@ -139,7 +139,7 @@ private theorem comp_gen : (((𝓤 α).lift' gen).lift' fun s => compRel s s) 
       exact monotone_gen
       exact monotone_id.comp_rel monotone_id
     _ ≤ (𝓤 α).lift' fun s => gen <| compRel s s :=
-      lift'_mono' fun s hs => comp_rel_gen_gen_subset_gen_comp_rel
+      (lift'_mono' fun s hs => comp_rel_gen_gen_subset_gen_comp_rel)
     _ = ((𝓤 α).lift' fun s : Set (α × α) => compRel s s).lift' gen :=
       by
       rw [lift'_lift'_assoc]

mathlib commit https://github.com/leanprover-community/mathlib/commit/3ade05ac9447ae31a22d2ea5423435e054131240

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl
 
 ! This file was ported from Lean 3 source module topology.uniform_space.completion
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
+! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.Topology.UniformSpace.AbstractCompletion
 /-!
 # Hausdorff completions of uniform spaces
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 The goal is to construct a left-adjoint to the inclusion of complete Hausdorff uniform spaces
 into all uniform spaces. Any uniform space `α` gets a completion `completion α` and a morphism
 (ie. uniformly continuous map) `coe : α → completion α` which solves the universal

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

@@ -262,15 +262,15 @@ theorem denseEmbedding_pureCauchy : DenseEmbedding pure_cauchy :=
   uniform_embedding_pure_cauchy.DenseEmbedding dense_range_pure_cauchy
 #align Cauchy.dense_embedding_pure_cauchy CauchyFilter.denseEmbedding_pureCauchy
 
-#print CauchyFilter.nonempty_cauchyCat_iff /-
-theorem nonempty_cauchyCat_iff : Nonempty (CauchyFilter α) ↔ Nonempty α :=
+#print CauchyFilter.nonempty_cauchyFilter_iff /-
+theorem nonempty_cauchyFilter_iff : Nonempty (CauchyFilter α) ↔ Nonempty α :=
   by
   constructor <;> rintro ⟨c⟩
   · have := eq_univ_iff_forall.1 dense_embedding_pure_cauchy.to_dense_inducing.closure_range c
     obtain ⟨_, ⟨_, a, _⟩⟩ := mem_closure_iff.1 this _ isOpen_univ trivial
     exact ⟨a⟩
   · exact ⟨pure_cauchy c⟩
-#align Cauchy.nonempty_Cauchy_iff CauchyFilter.nonempty_cauchyCat_iff
+#align Cauchy.nonempty_Cauchy_iff CauchyFilter.nonempty_cauchyFilter_iff
 -/
 
 section
@@ -345,13 +345,13 @@ end Extend
 
 end
 
-/- warning: Cauchy.Cauchy_eq -> CauchyFilter.cauchyCat_eq is a dubious translation:
+/- warning: Cauchy.Cauchy_eq -> CauchyFilter.cauchyFilter_eq is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Inhabited.{succ u1} α] [_inst_2 : UniformSpace.{u1} α] [_inst_3 : CompleteSpace.{u1} α _inst_2] [_inst_4 : SeparatedSpace.{u1} α _inst_2] {f : CauchyFilter.{u1} α _inst_2} {g : CauchyFilter.{u1} α _inst_2}, Iff (Eq.{succ u1} α (lim.{u1} α (UniformSpace.toTopologicalSpace.{u1} α _inst_2) (instNonempty.{succ u1} α _inst_1) (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_2 f) f)) (lim.{u1} α (UniformSpace.toTopologicalSpace.{u1} α _inst_2) (instNonempty.{succ u1} α _inst_1) (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_2 f) g))) (Membership.Mem.{u1, u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2)) (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2))) (Set.hasMem.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2))) (Prod.mk.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2) f g) (separationRel.{u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.uniformSpace.{u1} α _inst_2)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Inhabited.{succ u1} α] [_inst_2 : UniformSpace.{u1} α] [_inst_3 : CompleteSpace.{u1} α _inst_2] [_inst_4 : SeparatedSpace.{u1} α _inst_2] {f : CauchyFilter.{u1} α _inst_2} {g : CauchyFilter.{u1} α _inst_2}, Iff (Eq.{succ u1} α (lim.{u1} α (UniformSpace.toTopologicalSpace.{u1} α _inst_2) (instNonempty.{succ u1} α _inst_1) (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_2 f) f)) (lim.{u1} α (UniformSpace.toTopologicalSpace.{u1} α _inst_2) (instNonempty.{succ u1} α _inst_1) (Subtype.val.{succ u1} (Filter.{u1} α) (fun (f : Filter.{u1} α) => Cauchy.{u1} α _inst_2 f) g))) (Membership.mem.{u1, u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2)) (Set.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2))) (Set.instMembershipSet.{u1} (Prod.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2))) (Prod.mk.{u1, u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.{u1} α _inst_2) f g) (separationRel.{u1} (CauchyFilter.{u1} α _inst_2) (CauchyFilter.instUniformSpaceCauchyFilter.{u1} α _inst_2)))
-Case conversion may be inaccurate. Consider using '#align Cauchy.Cauchy_eq CauchyFilter.cauchyCat_eqₓ'. -/
-theorem cauchyCat_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpace α]
+Case conversion may be inaccurate. Consider using '#align Cauchy.Cauchy_eq CauchyFilter.cauchyFilter_eqₓ'. -/
+theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpace α]
     [SeparatedSpace α] {f g : CauchyFilter α} :
     lim f.1 = lim g.1 ↔ (f, g) ∈ separationRel (CauchyFilter α) :=
   by
@@ -382,7 +382,7 @@ theorem cauchyCat_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpa
     have := dc.closure_subset_iff.2 h
     rw [closure_prod_eq] at this
     refine' dt (this ⟨_, _⟩) <;> dsimp <;> apply limc <;> assumption
-#align Cauchy.Cauchy_eq CauchyFilter.cauchyCat_eq
+#align Cauchy.Cauchy_eq CauchyFilter.cauchyFilter_eq
 
 section
 

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

@@ -39,7 +39,7 @@ In this file we introduce the following concepts:
 This formalization is mostly based on
   N. Bourbaki: General Topology
   I. M. James: Topologies and Uniformities
-From a slightly different perspective in order to reuse material in topology.uniform_space.basic.
+From a slightly different perspective in order to reuse material in `Topology.UniformSpace.Basic`.
 -/
 
 

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

@@ -68,9 +68,7 @@ namespace CauchyFilter
 section
 
 variable {α : Type u} [UniformSpace α]
-
 variable {β : Type v} {γ : Type w}
-
 variable [UniformSpace β] [UniformSpace γ]
 
 instance (f : CauchyFilter α) : NeBot f.1 := f.2.1

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

@@ -73,6 +73,8 @@ variable {β : Type v} {γ : Type w}
 
 variable [UniformSpace β] [UniformSpace γ]
 
+instance (f : CauchyFilter α) : NeBot f.1 := f.2.1
+
 /-- The pairs of Cauchy filters generated by a set. -/
 def gen (s : Set (α × α)) : Set (CauchyFilter α × CauchyFilter α) :=
   { p | s ∈ p.1.val ×ˢ p.2.val }
@@ -142,6 +144,10 @@ theorem mem_uniformity {s : Set (CauchyFilter α × CauchyFilter α)} :
 set_option linter.uppercaseLean3 false in
 #align Cauchy.mem_uniformity CauchyFilter.mem_uniformity
 
+theorem basis_uniformity {ι : Sort*} {p : ι → Prop} {s : ι → Set (α × α)} (h : (𝓤 α).HasBasis p s) :
+    (𝓤 (CauchyFilter α)).HasBasis p (gen ∘ s) :=
+  h.lift' monotone_gen
+
 theorem mem_uniformity' {s : Set (CauchyFilter α × CauchyFilter α)} :
     s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ f g : CauchyFilter α, t ∈ f.1 ×ˢ g.1 → (f, g) ∈ s := by
   refine mem_uniformity.trans (exists_congr (fun t => and_congr_right_iff.mpr (fun _h => ?_)))
@@ -254,9 +260,9 @@ def extend (f : α → β) : CauchyFilter α → β :=
 set_option linter.uppercaseLean3 false in
 #align Cauchy.extend CauchyFilter.extend
 
-section SeparatedSpace
+section T0Space
 
-variable [SeparatedSpace β]
+variable [T0Space β]
 
 theorem extend_pureCauchy {f : α → β} (hf : UniformContinuous f) (a : α) :
     extend f (pureCauchy a) = f a := by
@@ -265,7 +271,7 @@ theorem extend_pureCauchy {f : α → β} (hf : UniformContinuous f) (a : α) :
 set_option linter.uppercaseLean3 false in
 #align Cauchy.extend_pure_cauchy CauchyFilter.extend_pureCauchy
 
-end SeparatedSpace
+end T0Space
 
 variable [CompleteSpace β]
 
@@ -280,54 +286,35 @@ set_option linter.uppercaseLean3 false in
 
 end Extend
 
+theorem inseparable_iff {f g : CauchyFilter α} : Inseparable f g ↔ f.1 ×ˢ g.1 ≤ 𝓤 α :=
+  (basis_uniformity (basis_sets _)).inseparable_iff_uniformity
+
+theorem inseparable_iff_of_le_nhds {f g : CauchyFilter α} {a b : α}
+    (ha : f.1 ≤ 𝓝 a) (hb : g.1 ≤ 𝓝 b) : Inseparable a b ↔ Inseparable f g := by
+  rw [← tendsto_id'] at ha hb
+  rw [inseparable_iff, (ha.comp tendsto_fst).inseparable_iff_uniformity (hb.comp tendsto_snd)]
+  rfl
+
+theorem inseparable_lim_iff [CompleteSpace α] {f g : CauchyFilter α} :
+    haveI := f.2.1.nonempty; Inseparable (lim f.1) (lim g.1) ↔ Inseparable f g :=
+  inseparable_iff_of_le_nhds f.2.le_nhds_lim g.2.le_nhds_lim
+
 end
 
-theorem cauchyFilter_eq {α : Type*} [UniformSpace α] [CompleteSpace α] [SeparatedSpace α]
+theorem cauchyFilter_eq {α : Type*} [UniformSpace α] [CompleteSpace α] [T0Space α]
     {f g : CauchyFilter α} :
-    haveI := f.2.1.nonempty; lim f.1 = lim g.1 ↔ (f, g) ∈ separationRel (CauchyFilter α) := by
-  haveI := f.2.1.nonempty
-  constructor
-  · intro e s hs
-    rcases CauchyFilter.mem_uniformity'.1 hs with ⟨t, tu, ts⟩
-    apply ts
-    rcases comp_mem_uniformity_sets tu with ⟨d, du, dt⟩
-    refine'
-      mem_prod_iff.2
-        ⟨_, f.2.le_nhds_lim (mem_nhds_right (lim f.1) du), _,
-          g.2.le_nhds_lim (mem_nhds_left (lim g.1) du), fun x h => _⟩
-    cases' x with a b
-    cases' h with h₁ h₂
-    rw [← e] at h₂
-    exact dt ⟨_, h₁, h₂⟩
-  · intro H
-    refine' separated_def.1 (by infer_instance) _ _ fun t tu => _
-    rcases mem_uniformity_isClosed tu with ⟨d, du, dc, dt⟩
-    refine'
-      H { p | (lim p.1.1, lim p.2.1) ∈ t } (CauchyFilter.mem_uniformity'.2 ⟨d, du, fun f g h => _⟩)
-    rcases mem_prod_iff.1 h with ⟨x, xf, y, yg, h⟩
-    have limc : ∀ (f : CauchyFilter α), ∀ x ∈ f.1, lim f.1 ∈ closure x := by
-      intro f x xf
-      rw [closure_eq_cluster_pts]
-      exact f.2.1.mono (le_inf f.2.le_nhds_lim (le_principal_iff.2 xf))
-    have := dc.closure_subset_iff.2 h
-    rw [closure_prod_eq] at this
-    refine' dt (this ⟨_, _⟩) <;> dsimp <;> apply limc <;> assumption
+    haveI := f.2.1.nonempty; lim f.1 = lim g.1 ↔ Inseparable f g := by
+  rw [← inseparable_iff_eq, inseparable_lim_iff]
+
 set_option linter.uppercaseLean3 false in
 #align Cauchy.Cauchy_eq CauchyFilter.cauchyFilter_eq
 
 section
 
-attribute [local instance] UniformSpace.separationSetoid
-
--- Porting note: added types in Function.Injective
-theorem separated_pureCauchy_injective {α : Type*} [UniformSpace α] [s : SeparatedSpace α] :
-    @Function.Injective α (Quotient (UniformSpace.separationSetoid (CauchyFilter α)))
-      fun a : α => ⟦pureCauchy a⟧
-  | a, b, h => by
-    refine separated_def.1 s _ _ (fun s hs => ?_)
-    rw [← (@uniformEmbedding_pureCauchy α _).comap_uniformity, Filter.mem_comap] at hs
-    obtain ⟨t, ht, hts⟩ := hs
-    exact @hts (a, b) (Quotient.exact h t ht)
+theorem separated_pureCauchy_injective {α : Type*} [UniformSpace α] [T0Space α] :
+    Function.Injective fun a : α => SeparationQuotient.mk (pureCauchy a) := fun a b h ↦
+  Inseparable.eq <| (inseparable_iff_of_le_nhds (pure_le_nhds a) (pure_le_nhds b)).2 <|
+    SeparationQuotient.mk_eq_mk.1 h
 set_option linter.uppercaseLean3 false in
 #align Cauchy.separated_pure_cauchy_injective CauchyFilter.separated_pureCauchy_injective
 
@@ -335,33 +322,16 @@ end
 
 end CauchyFilter
 
-attribute [local instance] UniformSpace.separationSetoid
-
 open CauchyFilter Set
 
 namespace UniformSpace
 
 variable (α : Type*) [UniformSpace α]
-
 variable {β : Type*} [UniformSpace β]
-
 variable {γ : Type*} [UniformSpace γ]
 
-instance completeSpace_separation [h : CompleteSpace α] :
-    CompleteSpace (Quotient (separationSetoid α)) := by
-  constructor
-  intro f hf
-  have : Cauchy (f.comap fun x => ⟦x⟧) :=
-    hf.comap' comap_quotient_le_uniformity <| hf.left.comap_of_surj (surjective_quotient_mk' _)
-  let ⟨x, (hx : (f.comap fun x => ⟦x⟧) ≤ 𝓝 x)⟩ := CompleteSpace.complete this
-  exact ⟨⟦x⟧,
-    (comap_le_comap_iff <| by simp).1
-      (hx.trans <| map_le_iff_le_comap.1 continuous_quotient_mk'.continuousAt)⟩
-#align uniform_space.complete_space_separation UniformSpace.completeSpace_separation
-
 /-- Hausdorff completion of `α` -/
-def Completion :=
-  Quotient (separationSetoid <| CauchyFilter α)
+def Completion := SeparationQuotient (CauchyFilter α)
 #align uniform_space.completion UniformSpace.Completion
 
 namespace Completion
@@ -369,52 +339,41 @@ namespace Completion
 instance inhabited [Inhabited α] : Inhabited (Completion α) :=
   inferInstanceAs <| Inhabited (Quotient _)
 
-instance (priority := 50) uniformSpace : UniformSpace (Completion α) :=
-  separationSetoid.uniformSpace
+instance uniformSpace : UniformSpace (Completion α) :=
+  SeparationQuotient.instUniformSpace
 
 instance completeSpace : CompleteSpace (Completion α) :=
-  UniformSpace.completeSpace_separation (CauchyFilter α)
-
-instance separatedSpace : SeparatedSpace (Completion α) :=
-  UniformSpace.separated_separation
+  SeparationQuotient.instCompleteSpace
 
-instance t3Space : T3Space (Completion α) :=
-  separated_t3
+instance t0Space : T0Space (Completion α) := SeparationQuotient.instT0Space
 
 /-- The map from a uniform space to its completion.
 
 porting note: this was added to create a target for the `@[coe]` attribute. -/
-@[coe] def coe' : α → Completion α := Quotient.mk' ∘ pureCauchy
+@[coe] def coe' : α → Completion α := SeparationQuotient.mk ∘ pureCauchy
 
 /-- Automatic coercion from `α` to its completion. Not always injective. -/
 instance : Coe α (Completion α) :=
   ⟨coe' α⟩
 
 -- note [use has_coe_t]
-protected theorem coe_eq : ((↑) : α → Completion α) = Quotient.mk' ∘ pureCauchy :=
-  rfl
+protected theorem coe_eq : ((↑) : α → Completion α) = SeparationQuotient.mk ∘ pureCauchy := rfl
 #align uniform_space.completion.coe_eq UniformSpace.Completion.coe_eq
 
-theorem comap_coe_eq_uniformity :
-    ((𝓤 _).comap fun p : α × α => ((p.1 : Completion α), (p.2 : Completion α))) = 𝓤 α := by
-  have :
-    (fun x : α × α => ((x.1 : Completion α), (x.2 : Completion α))) =
-      (fun x : CauchyFilter α × CauchyFilter α => (⟦x.1⟧, ⟦x.2⟧)) ∘ fun x : α × α =>
-        (pureCauchy x.1, pureCauchy x.2) :=
-    by ext ⟨a, b⟩ <;> simp <;> rfl
-  rw [this, ← Filter.comap_comap]
-  change Filter.comap _ (Filter.comap _ (𝓤 <| Quotient <| separationSetoid <| CauchyFilter α)) = 𝓤 α
-  rw [comap_quotient_eq_uniformity, uniformEmbedding_pureCauchy.comap_uniformity]
-#align uniform_space.completion.comap_coe_eq_uniformity UniformSpace.Completion.comap_coe_eq_uniformity
-
 theorem uniformInducing_coe : UniformInducing ((↑) : α → Completion α) :=
-  ⟨comap_coe_eq_uniformity α⟩
+  SeparationQuotient.uniformInducing_mk.comp uniformInducing_pureCauchy
 #align uniform_space.completion.uniform_inducing_coe UniformSpace.Completion.uniformInducing_coe
 
+theorem comap_coe_eq_uniformity :
+    ((𝓤 _).comap fun p : α × α => ((p.1 : Completion α), (p.2 : Completion α))) = 𝓤 α :=
+  (uniformInducing_coe _).1
+#align uniform_space.completion.comap_coe_eq_uniformity UniformSpace.Completion.comap_coe_eq_uniformity
+
 variable {α}
 
 theorem denseRange_coe : DenseRange ((↑) : α → Completion α) :=
-  denseRange_pureCauchy.quotient
+  SeparationQuotient.surjective_mk.denseRange.comp denseRange_pureCauchy
+    SeparationQuotient.continuous_mk
 #align uniform_space.completion.dense_range_coe UniformSpace.Completion.denseRange_coe
 
 variable (α)
@@ -449,12 +408,12 @@ theorem continuous_coe : Continuous ((↑) : α → Completion α) :=
   cPkg.continuous_coe
 #align uniform_space.completion.continuous_coe UniformSpace.Completion.continuous_coe
 
-theorem uniformEmbedding_coe [SeparatedSpace α] : UniformEmbedding ((↑) : α → Completion α) :=
+theorem uniformEmbedding_coe [T0Space α] : UniformEmbedding ((↑) : α → Completion α) :=
   { comap_uniformity := comap_coe_eq_uniformity α
     inj := separated_pureCauchy_injective }
 #align uniform_space.completion.uniform_embedding_coe UniformSpace.Completion.uniformEmbedding_coe
 
-theorem coe_injective [SeparatedSpace α] : Function.Injective ((↑) : α → Completion α) :=
+theorem coe_injective [T0Space α] : Function.Injective ((↑) : α → Completion α) :=
   UniformEmbedding.inj (uniformEmbedding_coe _)
 #align uniform_space.completion.coe_injective UniformSpace.Completion.coe_injective
 
@@ -465,7 +424,7 @@ theorem denseInducing_coe : DenseInducing ((↑) : α → Completion α) :=
 #align uniform_space.completion.dense_inducing_coe UniformSpace.Completion.denseInducing_coe
 
 /-- The uniform bijection between a complete space and its uniform completion. -/
-def UniformCompletion.completeEquivSelf [CompleteSpace α] [SeparatedSpace α] : Completion α ≃ᵤ α :=
+def UniformCompletion.completeEquivSelf [CompleteSpace α] [T0Space α] : Completion α ≃ᵤ α :=
   AbstractCompletion.compareEquiv Completion.cPkg AbstractCompletion.ofComplete
 #align uniform_space.completion.uniform_completion.complete_equiv_self UniformSpace.Completion.UniformCompletion.completeEquivSelf
 
@@ -475,7 +434,7 @@ instance separableSpace_completion [SeparableSpace α] : SeparableSpace (Complet
   Completion.denseInducing_coe.separableSpace
 #align uniform_space.completion.separable_space_completion UniformSpace.Completion.separableSpace_completion
 
-theorem denseEmbedding_coe [SeparatedSpace α] : DenseEmbedding ((↑) : α → Completion α) :=
+theorem denseEmbedding_coe [T0Space α] : DenseEmbedding ((↑) : α → Completion α) :=
   { denseInducing_coe with inj := separated_pureCauchy_injective }
 #align uniform_space.completion.dense_embedding_coe UniformSpace.Completion.denseEmbedding_coe
 
@@ -553,12 +512,12 @@ end CompleteSpace
 
 /- porting note: removed `@[simp]` because this lemma doesn't even trigger on itself in Lean 3 or
 Lean 4 unless the user manually supplies the `hf` argument, so it is useless as a `simp` lemma. -/
-theorem extension_coe [SeparatedSpace β] (hf : UniformContinuous f) (a : α) :
+theorem extension_coe [T0Space β] (hf : UniformContinuous f) (a : α) :
     (Completion.extension f) a = f a :=
   cPkg.extend_coe hf a
 #align uniform_space.completion.extension_coe UniformSpace.Completion.extension_coe
 
-variable [SeparatedSpace β] [CompleteSpace β]
+variable [T0Space β] [CompleteSpace β]
 
 theorem extension_unique (hf : UniformContinuous f) {g : Completion α → β}
     (hg : UniformContinuous g) (h : ∀ a : α, f a = g (a : Completion α)) :
@@ -608,7 +567,7 @@ theorem map_id : Completion.map (@id α) = id :=
   cPkg.map_id
 #align uniform_space.completion.map_id UniformSpace.Completion.map_id
 
-theorem extension_map [CompleteSpace γ] [SeparatedSpace γ] {f : β → γ} {g : α → β}
+theorem extension_map [CompleteSpace γ] [T0Space γ] {f : β → γ} {g : α → β}
     (hf : UniformContinuous f) (hg : UniformContinuous g) :
     Completion.extension f ∘ Completion.map g = Completion.extension (f ∘ g) :=
   Completion.ext (continuous_extension.comp continuous_map) continuous_extension <| by
@@ -630,29 +589,21 @@ end Map
 completion of its separation quotient -/
 section SeparationQuotientCompletion
 
+open SeparationQuotient in
 /-- The isomorphism between the completion of a uniform space and the completion of its separation
 quotient. -/
 def completionSeparationQuotientEquiv (α : Type u) [UniformSpace α] :
     Completion (SeparationQuotient α) ≃ Completion α := by
-  refine'
-    ⟨Completion.extension (SeparationQuotient.lift ((↑) : α → Completion α)),
-      Completion.map Quotient.mk', _, _⟩
-  · intro a
-    refine' induction_on a (isClosed_eq (continuous_map.comp continuous_extension) continuous_id) _
-    rintro ⟨a⟩
-    -- Porting note: had to insert rewrites to switch between Quot.mk, Quotient.mk, Quotient.mk'
-    rw [← Quotient.mk,extension_coe (SeparationQuotient.uniformContinuous_lift _),
-      SeparationQuotient.lift_mk (uniformContinuous_coe α), map_coe]
-    · rfl
-    · exact uniformContinuous_quotient_mk
-  · intro a
-    refine' Completion.induction_on a
-        (isClosed_eq (continuous_extension.comp continuous_map) continuous_id) fun a => _
-    rw [map_coe]
-    -- Porting note: add SeparationQuotient.lift_mk' for Quotient.mk' ?
-    · rw [extension_coe (SeparationQuotient.uniformContinuous_lift _), Quotient.mk',
-        SeparationQuotient.lift_mk (uniformContinuous_coe α) _]
-    · exact uniformContinuous_quotient_mk
+  refine ⟨Completion.extension (lift' ((↑) : α → Completion α)),
+    Completion.map SeparationQuotient.mk, fun a ↦ ?_, fun a ↦ ?_⟩
+  · refine induction_on a (isClosed_eq (continuous_map.comp continuous_extension) continuous_id) ?_
+    refine SeparationQuotient.surjective_mk.forall.2 fun a ↦ ?_
+    rw [extension_coe (uniformContinuous_lift' _), lift'_mk (uniformContinuous_coe α),
+      map_coe uniformContinuous_mk]
+  · refine induction_on a
+      (isClosed_eq (continuous_extension.comp continuous_map) continuous_id) fun a ↦ ?_
+    rw [map_coe uniformContinuous_mk, extension_coe (uniformContinuous_lift' _),
+      lift'_mk (uniformContinuous_coe _)]
 #align uniform_space.completion.completion_separation_quotient_equiv UniformSpace.Completion.completionSeparationQuotientEquiv
 
 theorem uniformContinuous_completionSeparationQuotientEquiv :
@@ -678,9 +629,9 @@ protected def extension₂ (f : α → β → γ) : Completion α → Completion
   cPkg.extend₂ cPkg f
 #align uniform_space.completion.extension₂ UniformSpace.Completion.extension₂
 
-section SeparatedSpace
+section T0Space
 
-variable [SeparatedSpace γ] {f}
+variable [T0Space γ] {f}
 
 /- porting note: removed `@[simp]` because this lemma doesn't even trigger on itself in Lean 3 or
 Lean 4 unless the user manually supplies the `hf` argument, so it is useless as a `simp` lemma. -/
@@ -689,7 +640,7 @@ theorem extension₂_coe_coe (hf : UniformContinuous₂ f) (a : α) (b : β) :
   cPkg.extension₂_coe_coe cPkg hf a b
 #align uniform_space.completion.extension₂_coe_coe UniformSpace.Completion.extension₂_coe_coe
 
-end SeparatedSpace
+end T0Space
 
 variable [CompleteSpace γ]
 

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

@@ -49,7 +49,8 @@ open Filter Set
 
 universe u v w x
 
-open Uniformity Classical Topology Filter
+open scoped Classical
+open Uniformity Topology Filter
 
 /-- Space of Cauchy filters
 

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

• converts "--porting note" into "-- Porting note";
• converts "porting note" into "Porting note".

@@ -83,7 +83,7 @@ theorem monotone_gen : Monotone (gen : Set (α × α) → _) :=
 set_option linter.uppercaseLean3 false in
 #align Cauchy.monotone_gen CauchyFilter.monotone_gen
 
--- porting note: this was a calc proof, but I could not make it work
+-- Porting note: this was a calc proof, but I could not make it work
 private theorem symm_gen : map Prod.swap ((𝓤 α).lift' gen) ≤ (𝓤 α).lift' gen := by
   let f := fun s : Set (α × α) =>
         { p : CauchyFilter α × CauchyFilter α | s ∈ (p.2.val ×ˢ p.1.val : Filter (α × α)) }
@@ -220,7 +220,7 @@ set_option linter.uppercaseLean3 false in
 
 section
 
--- porting note: I commented this
+-- Porting note: I commented this
 -- set_option eqn_compiler.zeta true
 
 instance : CompleteSpace (CauchyFilter α) :=
@@ -318,7 +318,7 @@ section
 
 attribute [local instance] UniformSpace.separationSetoid
 
--- porting note: added types in Function.Injective
+-- Porting note: added types in Function.Injective
 theorem separated_pureCauchy_injective {α : Type*} [UniformSpace α] [s : SeparatedSpace α] :
     @Function.Injective α (Quotient (UniformSpace.separationSetoid (CauchyFilter α)))
       fun a : α => ⟦pureCauchy a⟧
@@ -612,7 +612,7 @@ theorem extension_map [CompleteSpace γ] [SeparatedSpace γ] {f : β → γ} {g
     Completion.extension f ∘ Completion.map g = Completion.extension (f ∘ g) :=
   Completion.ext (continuous_extension.comp continuous_map) continuous_extension <| by
     intro a
-    -- porting note: this is not provable by simp [hf, hg, hf.comp hg, map_coe, extension_coe],
+    -- Porting note: this is not provable by simp [hf, hg, hf.comp hg, map_coe, extension_coe],
     -- but should be?
     rw [extension_coe (hf.comp hg), Function.comp_apply, map_coe hg, extension_coe hf,
       Function.comp_apply]
@@ -639,7 +639,7 @@ def completionSeparationQuotientEquiv (α : Type u) [UniformSpace α] :
   · intro a
     refine' induction_on a (isClosed_eq (continuous_map.comp continuous_extension) continuous_id) _
     rintro ⟨a⟩
-    -- porting note: had to insert rewrites to switch between Quot.mk, Quotient.mk, Quotient.mk'
+    -- Porting note: had to insert rewrites to switch between Quot.mk, Quotient.mk, Quotient.mk'
     rw [← Quotient.mk,extension_coe (SeparationQuotient.uniformContinuous_lift _),
       SeparationQuotient.lift_mk (uniformContinuous_coe α), map_coe]
     · rfl
@@ -648,7 +648,7 @@ def completionSeparationQuotientEquiv (α : Type u) [UniformSpace α] :
     refine' Completion.induction_on a
         (isClosed_eq (continuous_extension.comp continuous_map) continuous_id) fun a => _
     rw [map_coe]
-    -- porting note: add SeparationQuotient.lift_mk' for Quotient.mk' ?
+    -- Porting note: add SeparationQuotient.lift_mk' for Quotient.mk' ?
     · rw [extension_coe (SeparationQuotient.uniformContinuous_lift _), Quotient.mk',
         SeparationQuotient.lift_mk (uniformContinuous_coe α) _]
     · exact uniformContinuous_quotient_mk

Use haveI to drop unneeded Nonempty/Inhabited assumptions.

@@ -281,9 +281,10 @@ end Extend
 
 end
 
-theorem cauchyFilter_eq {α : Type*} [Inhabited α] [UniformSpace α] [CompleteSpace α]
-    [SeparatedSpace α] {f g : CauchyFilter α} :
-    lim f.1 = lim g.1 ↔ (f, g) ∈ separationRel (CauchyFilter α) := by
+theorem cauchyFilter_eq {α : Type*} [UniformSpace α] [CompleteSpace α] [SeparatedSpace α]
+    {f g : CauchyFilter α} :
+    haveI := f.2.1.nonempty; lim f.1 = lim g.1 ↔ (f, g) ∈ separationRel (CauchyFilter α) := by
+  haveI := f.2.1.nonempty
   constructor
   · intro e s hs
     rcases CauchyFilter.mem_uniformity'.1 hs with ⟨t, tu, ts⟩

Co-authored-by: Patrick Massot <patrickmassot@free.fr> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -97,7 +97,7 @@ private theorem symm_gen : map Prod.swap ((𝓤 α).lift' gen) ≤ (𝓤 α).lif
         (monotone_setOf fun p => @Filter.monotone_mem _ (p.2.val ×ˢ p.1.val)))
       (by
         have h := fun p : CauchyFilter α × CauchyFilter α => @Filter.prod_comm _ _ p.2.val p.1.val
-        simp [Function.comp, h, mem_map']
+        simp [f, Function.comp, h, mem_map']
         exact le_rfl)
   exact h₁.trans_le h₂
 

The mathlib3 lemma is about quotient.mk, which takes an instance argument and is translated into mathlib4 as Quotient.mk'.

@@ -350,7 +350,7 @@ instance completeSpace_separation [h : CompleteSpace α] :
   constructor
   intro f hf
   have : Cauchy (f.comap fun x => ⟦x⟧) :=
-    hf.comap' comap_quotient_le_uniformity <| hf.left.comap_of_surj (surjective_quotient_mk _)
+    hf.comap' comap_quotient_le_uniformity <| hf.left.comap_of_surj (surjective_quotient_mk' _)
   let ⟨x, (hx : (f.comap fun x => ⟦x⟧) ≤ 𝓝 x)⟩ := CompleteSpace.complete this
   exact ⟨⟦x⟧,
     (comap_le_comap_iff <| by simp).1

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -281,7 +281,7 @@ end Extend
 
 end
 
-theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpace α]
+theorem cauchyFilter_eq {α : Type*} [Inhabited α] [UniformSpace α] [CompleteSpace α]
     [SeparatedSpace α] {f g : CauchyFilter α} :
     lim f.1 = lim g.1 ↔ (f, g) ∈ separationRel (CauchyFilter α) := by
   constructor
@@ -318,7 +318,7 @@ section
 attribute [local instance] UniformSpace.separationSetoid
 
 -- porting note: added types in Function.Injective
-theorem separated_pureCauchy_injective {α : Type _} [UniformSpace α] [s : SeparatedSpace α] :
+theorem separated_pureCauchy_injective {α : Type*} [UniformSpace α] [s : SeparatedSpace α] :
     @Function.Injective α (Quotient (UniformSpace.separationSetoid (CauchyFilter α)))
       fun a : α => ⟦pureCauchy a⟧
   | a, b, h => by
@@ -339,11 +339,11 @@ open CauchyFilter Set
 
 namespace UniformSpace
 
-variable (α : Type _) [UniformSpace α]
+variable (α : Type*) [UniformSpace α]
 
-variable {β : Type _} [UniformSpace β]
+variable {β : Type*} [UniformSpace β]
 
-variable {γ : Type _} [UniformSpace γ]
+variable {γ : Type*} [UniformSpace γ]
 
 instance completeSpace_separation [h : CompleteSpace α] :
     CompleteSpace (Quotient (separationSetoid α)) := by
@@ -418,7 +418,7 @@ theorem denseRange_coe : DenseRange ((↑) : α → Completion α) :=
 variable (α)
 
 /-- The Haudorff completion as an abstract completion. -/
-def cPkg {α : Type _} [UniformSpace α] : AbstractCompletion α where
+def cPkg {α : Type*} [UniformSpace α] : AbstractCompletion α where
   space := Completion α
   coe := (↑)
   uniformStruct := by infer_instance
@@ -513,12 +513,12 @@ theorem induction_on₃ {p : Completion α → Completion β → Completion γ 
   this (a, b, c)
 #align uniform_space.completion.induction_on₃ UniformSpace.Completion.induction_on₃
 
-theorem ext {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
+theorem ext {Y : Type*} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
     (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) : f = g :=
   cPkg.funext hf hg h
 #align uniform_space.completion.ext UniformSpace.Completion.ext
 
-theorem ext' {Y : Type _} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
+theorem ext' {Y : Type*} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
     (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) (a : Completion α) :
     f a = g a :=
   congr_fun (ext hf hg h) a

Per https://github.com/leanprover/lean4/issues/2343, we are going to need to change the automatic generation of instance names, as they become too long.

This PR ensures that everywhere in Mathlib that refers to an instance by name, that name is given explicitly, rather than being automatically generated.

There are four exceptions, which are now commented, with links to https://github.com/leanprover/lean4/issues/2343.

This was implemented by running Mathlib against a modified Lean that appended _ᾰ to all automatically generated names, and fixing everything.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -365,7 +365,7 @@ def Completion :=
 namespace Completion
 
 instance inhabited [Inhabited α] : Inhabited (Completion α) :=
-  Quotient.instInhabitedQuotient (separationSetoid (CauchyFilter α))
+  inferInstanceAs <| Inhabited (Quotient _)
 
 instance (priority := 50) uniformSpace : UniformSpace (Completion α) :=
   separationSetoid.uniformSpace

• depends on: #5966

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

@@ -2,14 +2,11 @@
 Copyright (c) 2018 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot, Johannes Hölzl
-
-! This file was ported from Lean 3 source module topology.uniform_space.completion
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.UniformSpace.AbstractCompletion
 
+#align_import topology.uniform_space.completion from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+
 /-!
 # Hausdorff completions of uniform spaces
 

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

@@ -188,7 +188,7 @@ theorem denseRange_pureCauchy : DenseRange (pureCauchy : α → CauchyFilter α)
         ⟨t, ht, { y : α | (x, y) ∈ t' }, h <| mk_mem_prod hx hx,
           fun ⟨a, b⟩ ⟨(h₁ : a ∈ t), (h₂ : (x, b) ∈ t')⟩ =>
           ht'₂ <| prod_mk_mem_compRel (@h (a, x) ⟨h₁, hx⟩) h₂⟩
-    ⟨x, ht''₂ <| by dsimp [gen] ; exact this⟩
+    ⟨x, ht''₂ <| by dsimp [gen]; exact this⟩
   simp only [closure_eq_cluster_pts, ClusterPt, nhds_eq_uniformity, lift'_inf_principal_eq,
     Set.inter_comm _ (range pureCauchy), mem_setOf_eq]
   refine (lift'_neBot_iff ?_).mpr (fun s hs => ?_)
@@ -236,7 +236,7 @@ instance : CompleteSpace (CauchyFilter α) :=
         have : t' ⊆ { y : α | (f', pureCauchy y) ∈ gen t } := fun x hx =>
           (f ×ˢ pure x).sets_of_superset (prod_mem_prod ht' hx) h
         f.sets_of_superset ht' <| Subset.trans this (preimage_mono ht₂)
-    ⟨f', by simp [nhds_eq_uniformity] ; assumption⟩
+    ⟨f', by simp [nhds_eq_uniformity]; assumption⟩
 
 end
 

This PR is the result of running

find . -type f -name "*.lean" -exec sed -i -E 's/^( +)\. /\1· /' {} \;
find . -type f -name "*.lean" -exec sed -i -E 'N;s/^( +·)\n +(.*)$/\1 \2/;P;D' {} \;

which firstly replaces . focusing dots with · and secondly removes isolated instances of such dots, unifying them with the following line. A new rule is placed in the style linter to verify this.

@@ -192,10 +192,10 @@ theorem denseRange_pureCauchy : DenseRange (pureCauchy : α → CauchyFilter α)
   simp only [closure_eq_cluster_pts, ClusterPt, nhds_eq_uniformity, lift'_inf_principal_eq,
     Set.inter_comm _ (range pureCauchy), mem_setOf_eq]
   refine (lift'_neBot_iff ?_).mpr (fun s hs => ?_)
-  . refine monotone_const.inter ?_
+  · refine monotone_const.inter ?_
     simp_rw [UniformSpace.ball]
     exact monotone_preimage
-  . let ⟨y, hy⟩ := h_ex s hs
+  · let ⟨y, hy⟩ := h_ex s hs
     have : pureCauchy y ∈ range pureCauchy ∩ { y : CauchyFilter α | (f, y) ∈ s } :=
       ⟨mem_range_self y, hy⟩
     exact ⟨_, this⟩
@@ -644,16 +644,16 @@ def completionSeparationQuotientEquiv (α : Type u) [UniformSpace α] :
     -- porting note: had to insert rewrites to switch between Quot.mk, Quotient.mk, Quotient.mk'
     rw [← Quotient.mk,extension_coe (SeparationQuotient.uniformContinuous_lift _),
       SeparationQuotient.lift_mk (uniformContinuous_coe α), map_coe]
-    . rfl
-    . exact uniformContinuous_quotient_mk
+    · rfl
+    · exact uniformContinuous_quotient_mk
   · intro a
     refine' Completion.induction_on a
         (isClosed_eq (continuous_extension.comp continuous_map) continuous_id) fun a => _
     rw [map_coe]
     -- porting note: add SeparationQuotient.lift_mk' for Quotient.mk' ?
-    . rw [extension_coe (SeparationQuotient.uniformContinuous_lift _), Quotient.mk',
+    · rw [extension_coe (SeparationQuotient.uniformContinuous_lift _), Quotient.mk',
         SeparationQuotient.lift_mk (uniformContinuous_coe α) _]
-    . exact uniformContinuous_quotient_mk
+    · exact uniformContinuous_quotient_mk
 #align uniform_space.completion.completion_separation_quotient_equiv UniformSpace.Completion.completionSeparationQuotientEquiv
 
 theorem uniformContinuous_completionSeparationQuotientEquiv :

Currently, the following notations are changed from · ×ˢ · because Lean 4 can't deal with ambiguous notations. | Definition | Notation | | :

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Chris Hughes <chrishughes24@gmail.com>

@@ -77,19 +77,19 @@ variable [UniformSpace β] [UniformSpace γ]
 
 /-- The pairs of Cauchy filters generated by a set. -/
 def gen (s : Set (α × α)) : Set (CauchyFilter α × CauchyFilter α) :=
-  { p | s ∈ p.1.val ×ᶠ p.2.val }
+  { p | s ∈ p.1.val ×ˢ p.2.val }
 set_option linter.uppercaseLean3 false in
 #align Cauchy.gen CauchyFilter.gen
 
 theorem monotone_gen : Monotone (gen : Set (α × α) → _) :=
-  monotone_setOf fun p => @Filter.monotone_mem _ (p.1.val ×ᶠ p.2.val)
+  monotone_setOf fun p => @Filter.monotone_mem _ (p.1.val ×ˢ p.2.val)
 set_option linter.uppercaseLean3 false in
 #align Cauchy.monotone_gen CauchyFilter.monotone_gen
 
 -- porting note: this was a calc proof, but I could not make it work
 private theorem symm_gen : map Prod.swap ((𝓤 α).lift' gen) ≤ (𝓤 α).lift' gen := by
   let f := fun s : Set (α × α) =>
-        { p : CauchyFilter α × CauchyFilter α | s ∈ (p.2.val ×ᶠ p.1.val : Filter (α × α)) }
+        { p : CauchyFilter α × CauchyFilter α | s ∈ (p.2.val ×ˢ p.1.val : Filter (α × α)) }
   have h₁ : map Prod.swap ((𝓤 α).lift' gen) = (𝓤 α).lift' f := by
     delta gen
     simp [map_lift'_eq, monotone_setOf, Filter.monotone_mem, Function.comp,
@@ -97,7 +97,7 @@ private theorem symm_gen : map Prod.swap ((𝓤 α).lift' gen) ≤ (𝓤 α).lif
   have h₂ : (𝓤 α).lift' f ≤ (𝓤 α).lift' gen :=
     uniformity_lift_le_swap
       (monotone_principal.comp
-        (monotone_setOf fun p => @Filter.monotone_mem _ (p.2.val ×ᶠ p.1.val)))
+        (monotone_setOf fun p => @Filter.monotone_mem _ (p.2.val ×ˢ p.1.val)))
       (by
         have h := fun p : CauchyFilter α × CauchyFilter α => @Filter.prod_comm _ _ p.2.val p.1.val
         simp [Function.comp, h, mem_map']
@@ -111,7 +111,7 @@ private theorem compRel_gen_gen_subset_gen_compRel {s t : Set (α × α)} :
   let ⟨t₃, (ht₃ : t₃ ∈ h.val), t₄, (ht₄ : t₄ ∈ g.val), (h₂ : t₃ ×ˢ t₄ ⊆ t)⟩ := mem_prod_iff.mp h₂
   have : t₂ ∩ t₃ ∈ h.val := inter_mem ht₂ ht₃
   let ⟨x, xt₂, xt₃⟩ := h.property.left.nonempty_of_mem this
-  (f.val ×ᶠ g.val).sets_of_superset (prod_mem_prod ht₁ ht₄)
+  (f.val ×ˢ g.val).sets_of_superset (prod_mem_prod ht₁ ht₄)
     fun ⟨a, b⟩ ⟨(ha : a ∈ t₁), (hb : b ∈ t₄)⟩ =>
     ⟨x, h₁ (show (a, x) ∈ t₁ ×ˢ t₂ from ⟨ha, xt₂⟩), h₂ (show (x, b) ∈ t₃ ×ˢ t₄ from ⟨xt₃, hb⟩)⟩
 
@@ -145,7 +145,7 @@ set_option linter.uppercaseLean3 false in
 #align Cauchy.mem_uniformity CauchyFilter.mem_uniformity
 
 theorem mem_uniformity' {s : Set (CauchyFilter α × CauchyFilter α)} :
-    s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ f g : CauchyFilter α, t ∈ f.1 ×ᶠ g.1 → (f, g) ∈ s := by
+    s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ f g : CauchyFilter α, t ∈ f.1 ×ˢ g.1 → (f, g) ∈ s := by
   refine mem_uniformity.trans (exists_congr (fun t => and_congr_right_iff.mpr (fun _h => ?_)))
   exact ⟨fun h _f _g ht => h ht, fun h _p hp => h _ _ hp⟩
 set_option linter.uppercaseLean3 false in
@@ -180,10 +180,10 @@ theorem denseRange_pureCauchy : DenseRange (pureCauchy : α → CauchyFilter α)
   have h_ex : ∀ s ∈ 𝓤 (CauchyFilter α), ∃ y : α, (f, pureCauchy y) ∈ s := fun s hs =>
     let ⟨t'', ht''₁, (ht''₂ : gen t'' ⊆ s)⟩ := (mem_lift'_sets monotone_gen).mp hs
     let ⟨t', ht'₁, ht'₂⟩ := comp_mem_uniformity_sets ht''₁
-    have : t' ∈ f.val ×ᶠ f.val := f.property.right ht'₁
+    have : t' ∈ f.val ×ˢ f.val := f.property.right ht'₁
     let ⟨t, ht, (h : t ×ˢ t ⊆ t')⟩ := mem_prod_same_iff.mp this
     let ⟨x, (hx : x ∈ t)⟩ := f.property.left.nonempty_of_mem ht
-    have : t'' ∈ f.val ×ᶠ pure x :=
+    have : t'' ∈ f.val ×ˢ pure x :=
       mem_prod_iff.mpr
         ⟨t, ht, { y : α | (x, y) ∈ t' }, h <| mk_mem_prod hx hx,
           fun ⟨a, b⟩ ⟨(h₁ : a ∈ t), (h₂ : (x, b) ∈ t')⟩ =>
@@ -234,7 +234,7 @@ instance : CompleteSpace (CauchyFilter α) :=
         let ⟨t, ht₁, (ht₂ : gen t ⊆ s)⟩ := (mem_lift'_sets monotone_gen).mp hs
         let ⟨t', ht', (h : t' ×ˢ t' ⊆ t)⟩ := mem_prod_same_iff.mp (hf.right ht₁)
         have : t' ⊆ { y : α | (f', pureCauchy y) ∈ gen t } := fun x hx =>
-          (f ×ᶠ pure x).sets_of_superset (prod_mem_prod ht' hx) h
+          (f ×ˢ pure x).sets_of_superset (prod_mem_prod ht' hx) h
         f.sets_of_superset ht' <| Subset.trans this (preimage_mono ht₂)
     ⟨f', by simp [nhds_eq_uniformity] ; assumption⟩
 

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -117,18 +117,17 @@ private theorem compRel_gen_gen_subset_gen_compRel {s t : Set (α × α)} :
 
 private theorem comp_gen : (((𝓤 α).lift' gen).lift' fun s => compRel s s) ≤ (𝓤 α).lift' gen :=
   calc
-    (((𝓤 α).lift' gen).lift' fun s => compRel s s) = (𝓤 α).lift' fun s => compRel (gen s) (gen s) :=
-      by
-        rw [lift'_lift'_assoc]
-        . exact monotone_gen
-        . exact monotone_id.compRel monotone_id
+    (((𝓤 α).lift' gen).lift' fun s => compRel s s) =
+        (𝓤 α).lift' fun s => compRel (gen s) (gen s) := by
+      rw [lift'_lift'_assoc]
+      · exact monotone_gen
+      · exact monotone_id.compRel monotone_id
     _ ≤ (𝓤 α).lift' fun s => gen <| compRel s s :=
       lift'_mono' fun s _hs => compRel_gen_gen_subset_gen_compRel
-    _ = ((𝓤 α).lift' fun s : Set (α × α) => compRel s s).lift' gen :=
-      by
-        rw [lift'_lift'_assoc]
-        . exact monotone_id.compRel monotone_id
-        . exact monotone_gen
+    _ = ((𝓤 α).lift' fun s : Set (α × α) => compRel s s).lift' gen := by
+      rw [lift'_lift'_assoc]
+      · exact monotone_id.compRel monotone_id
+      · exact monotone_gen
     _ ≤ (𝓤 α).lift' gen := lift'_mono comp_le_uniformity le_rfl
 
 instance : UniformSpace (CauchyFilter α) :=

@@ -546,6 +546,7 @@ theorem uniformContinuous_extension : UniformContinuous (Completion.extension f)
   cPkg.uniformContinuous_extend
 #align uniform_space.completion.uniform_continuous_extension UniformSpace.Completion.uniformContinuous_extension
 
+@[continuity]
 theorem continuous_extension : Continuous (Completion.extension f) :=
   cPkg.continuous_extend
 #align uniform_space.completion.continuous_extension UniformSpace.Completion.continuous_extension
@@ -588,6 +589,7 @@ theorem uniformContinuous_map : UniformContinuous (Completion.map f) :=
   cPkg.uniformContinuous_map cPkg f
 #align uniform_space.completion.uniform_continuous_map UniformSpace.Completion.uniformContinuous_map
 
+@[continuity]
 theorem continuous_map : Continuous (Completion.map f) :=
   cPkg.continuous_map cPkg f
 #align uniform_space.completion.continuous_map UniformSpace.Completion.continuous_map

Also names instances in Topology.UniformSpace.Completion

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -368,19 +368,19 @@ def Completion :=
 
 namespace Completion
 
-instance [Inhabited α] : Inhabited (Completion α) :=
+instance inhabited [Inhabited α] : Inhabited (Completion α) :=
   Quotient.instInhabitedQuotient (separationSetoid (CauchyFilter α))
 
-instance (priority := 50) : UniformSpace (Completion α) :=
+instance (priority := 50) uniformSpace : UniformSpace (Completion α) :=
   separationSetoid.uniformSpace
 
-instance : CompleteSpace (Completion α) :=
+instance completeSpace : CompleteSpace (Completion α) :=
   UniformSpace.completeSpace_separation (CauchyFilter α)
 
-instance : SeparatedSpace (Completion α) :=
+instance separatedSpace : SeparatedSpace (Completion α) :=
   UniformSpace.separated_separation
 
-instance : T3Space (Completion α) :=
+instance t3Space : T3Space (Completion α) :=
   separated_t3
 
 /-- The map from a uniform space to its completion.

@@ -383,9 +383,14 @@ instance : SeparatedSpace (Completion α) :=
 instance : T3Space (Completion α) :=
   separated_t3
 
+/-- The map from a uniform space to its completion.
+
+porting note: this was added to create a target for the `@[coe]` attribute. -/
+@[coe] def coe' : α → Completion α := Quotient.mk' ∘ pureCauchy
+
 /-- Automatic coercion from `α` to its completion. Not always injective. -/
-instance : CoeTC α (Completion α) :=
-  ⟨Quotient.mk' ∘ pureCauchy⟩
+instance : Coe α (Completion α) :=
+  ⟨coe' α⟩
 
 -- note [use has_coe_t]
 protected theorem coe_eq : ((↑) : α → Completion α) = Quotient.mk' ∘ pureCauchy :=
@@ -637,7 +642,7 @@ def completionSeparationQuotientEquiv (α : Type u) [UniformSpace α] :
     rintro ⟨a⟩
     -- porting note: had to insert rewrites to switch between Quot.mk, Quotient.mk, Quotient.mk'
     rw [← Quotient.mk,extension_coe (SeparationQuotient.uniformContinuous_lift _),
-      SeparationQuotient.lift_mk (uniformContinuous_coe α), UniformSpace.Completion.coe_eq, map_coe]
+      SeparationQuotient.lift_mk (uniformContinuous_coe α), map_coe]
     . rfl
     . exact uniformContinuous_quotient_mk
   · intro a

@@ -35,7 +35,7 @@ In this file we introduce the following concepts:
 * `CauchyFilter α` the uniform completion of the uniform space `α` (using Cauchy filters).
   These are not minimal filters.
 
-* `Completion α := quotient (separation_setoid (CauchyFilter α))` the Hausdorff completion.
+* `Completion α := Quotient (separationSetoid (CauchyFilter α))` the Hausdorff completion.
 
 ## References
 
@@ -213,14 +213,14 @@ theorem denseEmbedding_pureCauchy : DenseEmbedding (pureCauchy : α → CauchyFi
 set_option linter.uppercaseLean3 false in
 #align Cauchy.dense_embedding_pure_cauchy CauchyFilter.denseEmbedding_pureCauchy
 
-theorem nonempty_cauchyCat_iff : Nonempty (CauchyFilter α) ↔ Nonempty α := by
+theorem nonempty_cauchyFilter_iff : Nonempty (CauchyFilter α) ↔ Nonempty α := by
   constructor <;> rintro ⟨c⟩
   · have := eq_univ_iff_forall.1 denseEmbedding_pureCauchy.toDenseInducing.closure_range c
     obtain ⟨_, ⟨_, a, _⟩⟩ := mem_closure_iff.1 this _ isOpen_univ trivial
     exact ⟨a⟩
   · exact ⟨pureCauchy c⟩
 set_option linter.uppercaseLean3 false in
-#align Cauchy.nonempty_Cauchy_iff CauchyFilter.nonempty_cauchyCat_iff
+#align Cauchy.nonempty_Cauchy_iff CauchyFilter.nonempty_cauchyFilter_iff
 
 section
 
@@ -253,7 +253,7 @@ section Extend
 Outputs junk when `f` is not uniformly continuous. -/
 def extend (f : α → β) : CauchyFilter α → β :=
   if UniformContinuous f then denseInducing_pureCauchy.extend f
-  else fun x => f (nonempty_cauchyCat_iff.1 ⟨x⟩).some
+  else fun x => f (nonempty_cauchyFilter_iff.1 ⟨x⟩).some
 set_option linter.uppercaseLean3 false in
 #align Cauchy.extend CauchyFilter.extend
 
@@ -285,7 +285,7 @@ end Extend
 
 end
 
-theorem cauchyCat_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpace α]
+theorem cauchyFilter_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpace α]
     [SeparatedSpace α] {f g : CauchyFilter α} :
     lim f.1 = lim g.1 ↔ (f, g) ∈ separationRel (CauchyFilter α) := by
   constructor
@@ -307,8 +307,7 @@ theorem cauchyCat_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpa
     refine'
       H { p | (lim p.1.1, lim p.2.1) ∈ t } (CauchyFilter.mem_uniformity'.2 ⟨d, du, fun f g h => _⟩)
     rcases mem_prod_iff.1 h with ⟨x, xf, y, yg, h⟩
-    have limc : ∀ (f : CauchyFilter α), ∀ x ∈ f.1, lim f.1 ∈ closure x :=
-      by
+    have limc : ∀ (f : CauchyFilter α), ∀ x ∈ f.1, lim f.1 ∈ closure x := by
       intro f x xf
       rw [closure_eq_cluster_pts]
       exact f.2.1.mono (le_inf f.2.le_nhds_lim (le_principal_iff.2 xf))
@@ -316,7 +315,7 @@ theorem cauchyCat_eq {α : Type _} [Inhabited α] [UniformSpace α] [CompleteSpa
     rw [closure_prod_eq] at this
     refine' dt (this ⟨_, _⟩) <;> dsimp <;> apply limc <;> assumption
 set_option linter.uppercaseLean3 false in
-#align Cauchy.Cauchy_eq CauchyFilter.cauchyCat_eq
+#align Cauchy.Cauchy_eq CauchyFilter.cauchyFilter_eq
 
 section
 
@@ -418,8 +417,7 @@ theorem denseRange_coe : DenseRange ((↑) : α → Completion α) :=
 variable (α)
 
 /-- The Haudorff completion as an abstract completion. -/
-def cPkg {α : Type _} [UniformSpace α] : AbstractCompletion α
-    where
+def cPkg {α : Type _} [UniformSpace α] : AbstractCompletion α where
   space := Completion α
   coe := (↑)
   uniformStruct := by infer_instance

Co-authored-by: Jireh Loreaux <loreaujy@gmail.com> Co-authored-by: Rémy Degenne <remydegenne@gmail.com>