topology.uniform_space.abstract_completion ⟷ Mathlib.Topology.UniformSpace.AbstractCompletion

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

@@ -65,7 +65,7 @@ structure AbstractCompletion (α : Type u) [UniformSpace α] where
   coe : α → space
   uniformStruct : UniformSpace space
   complete : CompleteSpace space
-  separation : SeparatedSpace space
+  separation : T0Space space
   UniformInducing : UniformInducing coe
   dense : DenseRange coe
 #align abstract_completion AbstractCompletion
@@ -84,7 +84,7 @@ local notation "ι" => pkg.coe
 
 #print AbstractCompletion.ofComplete /-
 /-- If `α` is complete, then it is an abstract completion of itself. -/
-def ofComplete [SeparatedSpace α] [CompleteSpace α] : AbstractCompletion α :=
+def ofComplete [T0Space α] [CompleteSpace α] : AbstractCompletion α :=
   mk α id inferInstance inferInstance inferInstance uniformInducing_id denseRange_id
 #align abstract_completion.of_complete AbstractCompletion.ofComplete
 -/
@@ -177,7 +177,7 @@ theorem continuous_extend : Continuous (pkg.extend f) :=
 #align abstract_completion.continuous_extend AbstractCompletion.continuous_extend
 -/
 
-variable [SeparatedSpace β]
+variable [T0Space β]
 
 #print AbstractCompletion.extend_unique /-
 theorem extend_unique (hf : UniformContinuous f) {g : hatα → β} (hg : UniformContinuous g)
@@ -261,9 +261,8 @@ theorem map_id : pkg.map pkg id = id :=
 variable {γ : Type _} [UniformSpace γ]
 
 #print AbstractCompletion.extend_map /-
-theorem extend_map [CompleteSpace γ] [SeparatedSpace γ] {f : β → γ} {g : α → β}
-    (hf : UniformContinuous f) (hg : UniformContinuous g) :
-    pkg'.extend f ∘ map g = pkg.extend (f ∘ g) :=
+theorem extend_map [CompleteSpace γ] [T0Space γ] {f : β → γ} {g : α → β} (hf : UniformContinuous f)
+    (hg : UniformContinuous g) : pkg'.extend f ∘ map g = pkg.extend (f ∘ g) :=
   pkg.funext (pkg'.continuous_extend.comp (pkg.continuous_map pkg' _)) pkg.continuous_extend
     fun a => by rw [pkg.extend_coe (hf.comp hg), comp_app, pkg.map_coe pkg' hg, pkg'.extend_coe hf]
 #align abstract_completion.extend_map AbstractCompletion.extend_map
@@ -386,9 +385,9 @@ protected def extend₂ (f : α → β → γ) : hatα → hatβ → γ :=
 #align abstract_completion.extend₂ AbstractCompletion.extend₂
 -/
 
-section SeparatedSpace
+section T0Space
 
-variable [SeparatedSpace γ] {f : α → β → γ}
+variable [T0Space γ] {f : α → β → γ}
 
 #print AbstractCompletion.extension₂_coe_coe /-
 theorem extension₂_coe_coe (hf : UniformContinuous <| uncurry f) (a : α) (b : β) :
@@ -398,7 +397,7 @@ theorem extension₂_coe_coe (hf : UniformContinuous <| uncurry f) (a : α) (b :
 #align abstract_completion.extension₂_coe_coe AbstractCompletion.extension₂_coe_coe
 -/
 
-end SeparatedSpace
+end T0Space
 
 variable {f : α → β → γ}
 

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

@@ -3,8 +3,8 @@ Copyright (c) 2019 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot
 -/
-import Mathbin.Topology.UniformSpace.UniformEmbedding
-import Mathbin.Topology.UniformSpace.Equiv
+import Topology.UniformSpace.UniformEmbedding
+import Topology.UniformSpace.Equiv
 
 #align_import topology.uniform_space.abstract_completion from "leanprover-community/mathlib"@"34ee86e6a59d911a8e4f89b68793ee7577ae79c7"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2019 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot
-
-! This file was ported from Lean 3 source module topology.uniform_space.abstract_completion
-! leanprover-community/mathlib commit 34ee86e6a59d911a8e4f89b68793ee7577ae79c7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.UniformSpace.UniformEmbedding
 import Mathbin.Topology.UniformSpace.Equiv
 
+#align_import topology.uniform_space.abstract_completion from "leanprover-community/mathlib"@"34ee86e6a59d911a8e4f89b68793ee7577ae79c7"
+
 /-!
 # Abstract theory of Hausdorff completions of uniform spaces
 

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

@@ -81,10 +81,8 @@ namespace AbstractCompletion
 
 variable {α : Type _} [UniformSpace α] (pkg : AbstractCompletion α)
 
--- mathport name: exprhatα
 local notation "hatα" => pkg.Space
 
--- mathport name: exprι
 local notation "ι" => pkg.coe
 
 #print AbstractCompletion.ofComplete /-
@@ -148,9 +146,11 @@ protected def extend (f : α → β) : hatα → β :=
 
 variable {f : α → β}
 
+#print AbstractCompletion.extend_def /-
 theorem extend_def (hf : UniformContinuous f) : pkg.extend f = pkg.DenseInducing.extend f :=
   if_pos hf
 #align abstract_completion.extend_def AbstractCompletion.extend_def
+-/
 
 #print AbstractCompletion.extend_coe /-
 theorem extend_coe [T2Space β] (hf : UniformContinuous f) (a : α) : (pkg.extend f) (ι a) = f a :=
@@ -162,6 +162,7 @@ theorem extend_coe [T2Space β] (hf : UniformContinuous f) (a : α) : (pkg.exten
 
 variable [CompleteSpace β]
 
+#print AbstractCompletion.uniformContinuous_extend /-
 theorem uniformContinuous_extend : UniformContinuous (pkg.extend f) :=
   by
   by_cases hf : UniformContinuous f
@@ -171,26 +172,33 @@ theorem uniformContinuous_extend : UniformContinuous (pkg.extend f) :=
     rw [if_neg hf]
     exact uniformContinuous_of_const fun a b => by congr
 #align abstract_completion.uniform_continuous_extend AbstractCompletion.uniformContinuous_extend
+-/
 
+#print AbstractCompletion.continuous_extend /-
 theorem continuous_extend : Continuous (pkg.extend f) :=
   pkg.uniformContinuous_extend.Continuous
 #align abstract_completion.continuous_extend AbstractCompletion.continuous_extend
+-/
 
 variable [SeparatedSpace β]
 
+#print AbstractCompletion.extend_unique /-
 theorem extend_unique (hf : UniformContinuous f) {g : hatα → β} (hg : UniformContinuous g)
     (h : ∀ a : α, f a = g (ι a)) : pkg.extend f = g :=
   by
   apply pkg.funext pkg.continuous_extend hg.continuous
   simpa only [pkg.extend_coe hf] using h
 #align abstract_completion.extend_unique AbstractCompletion.extend_unique
+-/
 
+#print AbstractCompletion.extend_comp_coe /-
 @[simp]
 theorem extend_comp_coe {f : hatα → β} (hf : UniformContinuous f) : pkg.extend (f ∘ ι) = f :=
   funext fun x =>
     pkg.inductionOn x (isClosed_eq pkg.continuous_extend hf.Continuous) fun y =>
       pkg.extend_coe (hf.comp <| pkg.uniformContinuous_coe) y
 #align abstract_completion.extend_comp_coe AbstractCompletion.extend_comp_coe
+-/
 
 end Extend
 
@@ -198,10 +206,8 @@ section MapSec
 
 variable (pkg' : AbstractCompletion β)
 
--- mathport name: exprhatβ
 local notation "hatβ" => pkg'.Space
 
--- mathport name: exprι'
 local notation "ι'" => pkg'.coe
 
 #print AbstractCompletion.map /-
@@ -211,26 +217,32 @@ protected def map (f : α → β) : hatα → hatβ :=
 #align abstract_completion.map AbstractCompletion.map
 -/
 
--- mathport name: exprmap
 local notation "map" => pkg.map pkg'
 
 variable (f : α → β)
 
+#print AbstractCompletion.uniformContinuous_map /-
 theorem uniformContinuous_map : UniformContinuous (map f) :=
   pkg.uniformContinuous_extend
 #align abstract_completion.uniform_continuous_map AbstractCompletion.uniformContinuous_map
+-/
 
+#print AbstractCompletion.continuous_map /-
 theorem continuous_map : Continuous (map f) :=
   pkg.continuous_extend
 #align abstract_completion.continuous_map AbstractCompletion.continuous_map
+-/
 
 variable {f}
 
+#print AbstractCompletion.map_coe /-
 @[simp]
 theorem map_coe (hf : UniformContinuous f) (a : α) : map f (ι a) = ι' (f a) :=
   pkg.extend_coe (pkg'.uniformContinuous_coe.comp hf) a
 #align abstract_completion.map_coe AbstractCompletion.map_coe
+-/
 
+#print AbstractCompletion.map_unique /-
 theorem map_unique {f : α → β} {g : hatα → hatβ} (hg : UniformContinuous g)
     (h : ∀ a, ι' (f a) = g (ι a)) : map f = g :=
   pkg.funext (pkg.continuous_map _ _) hg.Continuous <|
@@ -240,6 +252,7 @@ theorem map_unique {f : α → β} {g : hatα → hatβ} (hg : UniformContinuous
     simp only [(· ∘ ·), h]
     rw [pkg.extend_coe (hg.comp pkg.uniform_continuous_coe)]
 #align abstract_completion.map_unique AbstractCompletion.map_unique
+-/
 
 #print AbstractCompletion.map_id /-
 @[simp]
@@ -261,10 +274,12 @@ theorem extend_map [CompleteSpace γ] [SeparatedSpace γ] {f : β → γ} {g : 
 
 variable (pkg'' : AbstractCompletion γ)
 
+#print AbstractCompletion.map_comp /-
 theorem map_comp {g : β → γ} {f : α → β} (hg : UniformContinuous g) (hf : UniformContinuous f) :
     pkg'.map pkg'' g ∘ pkg.map pkg' f = pkg.map pkg'' (g ∘ f) :=
   pkg.extend_map pkg' (pkg''.uniformContinuous_coe.comp hg) hf
 #align abstract_completion.map_comp AbstractCompletion.map_comp
+-/
 
 end MapSec
 
@@ -317,13 +332,17 @@ def compareEquiv : pkg.Space ≃ᵤ pkg'.Space
 #align abstract_completion.compare_equiv AbstractCompletion.compareEquiv
 -/
 
+#print AbstractCompletion.uniformContinuous_compareEquiv /-
 theorem uniformContinuous_compareEquiv : UniformContinuous (pkg.compareEquiv pkg') :=
   pkg.uniformContinuous_compare pkg'
 #align abstract_completion.uniform_continuous_compare_equiv AbstractCompletion.uniformContinuous_compareEquiv
+-/
 
+#print AbstractCompletion.uniformContinuous_compareEquiv_symm /-
 theorem uniformContinuous_compareEquiv_symm : UniformContinuous (pkg.compareEquiv pkg').symm :=
   pkg'.uniformContinuous_compare pkg
 #align abstract_completion.uniform_continuous_compare_equiv_symm AbstractCompletion.uniformContinuous_compareEquiv_symm
+-/
 
 end Compare
 
@@ -331,12 +350,11 @@ section Prod
 
 variable (pkg' : AbstractCompletion β)
 
--- mathport name: exprhatβ
 local notation "hatβ" => pkg'.Space
 
--- mathport name: exprι'
 local notation "ι'" => pkg'.coe
 
+#print AbstractCompletion.prod /-
 /-- Products of completions -/
 protected def prod : AbstractCompletion (α × β)
     where
@@ -348,6 +366,7 @@ protected def prod : AbstractCompletion (α × β)
   UniformInducing := UniformInducing.prod pkg.UniformInducing pkg'.UniformInducing
   dense := pkg.dense.Prod_map pkg'.dense
 #align abstract_completion.prod AbstractCompletion.prod
+-/
 
 end Prod
 
@@ -355,10 +374,8 @@ section Extension₂
 
 variable (pkg' : AbstractCompletion β)
 
--- mathport name: exprhatβ
 local notation "hatβ" => pkg'.Space
 
--- mathport name: exprι'
 local notation "ι'" => pkg'.coe
 
 variable {γ : Type _} [UniformSpace γ]
@@ -376,11 +393,13 @@ section SeparatedSpace
 
 variable [SeparatedSpace γ] {f : α → β → γ}
 
+#print AbstractCompletion.extension₂_coe_coe /-
 theorem extension₂_coe_coe (hf : UniformContinuous <| uncurry f) (a : α) (b : β) :
     pkg.extend₂ pkg' f (ι a) (ι' b) = f a b :=
   show (pkg.Prod pkg').extend (uncurry f) ((pkg.Prod pkg').coe (a, b)) = uncurry f (a, b) from
     (pkg.Prod pkg').extend_coe hf _
 #align abstract_completion.extension₂_coe_coe AbstractCompletion.extension₂_coe_coe
+-/
 
 end SeparatedSpace
 
@@ -388,11 +407,13 @@ variable {f : α → β → γ}
 
 variable [CompleteSpace γ] (f)
 
+#print AbstractCompletion.uniformContinuous_extension₂ /-
 theorem uniformContinuous_extension₂ : UniformContinuous₂ (pkg.extend₂ pkg' f) :=
   by
   rw [uniformContinuous₂_def, AbstractCompletion.extend₂, uncurry_curry]
   apply uniform_continuous_extend
 #align abstract_completion.uniform_continuous_extension₂ AbstractCompletion.uniformContinuous_extension₂
+-/
 
 end Extension₂
 
@@ -400,21 +421,16 @@ section Map₂
 
 variable (pkg' : AbstractCompletion β)
 
--- mathport name: exprhatβ
 local notation "hatβ" => pkg'.Space
 
--- mathport name: exprι'
 local notation "ι'" => pkg'.coe
 
 variable {γ : Type _} [UniformSpace γ] (pkg'' : AbstractCompletion γ)
 
--- mathport name: exprhatγ
 local notation "hatγ" => pkg''.Space
 
--- mathport name: exprι''
 local notation "ι''" => pkg''.coe
 
--- mathport name: «expr ∘₂ »
 local notation f " ∘₂ " g => bicompr f g
 
 #print AbstractCompletion.map₂ /-
@@ -424,20 +440,26 @@ protected def map₂ (f : α → β → γ) : hatα → hatβ → hatγ :=
 #align abstract_completion.map₂ AbstractCompletion.map₂
 -/
 
+#print AbstractCompletion.uniformContinuous_map₂ /-
 theorem uniformContinuous_map₂ (f : α → β → γ) : UniformContinuous₂ (pkg.zipWith pkg' pkg'' f) :=
   pkg.uniformContinuous_extension₂ pkg' _
 #align abstract_completion.uniform_continuous_map₂ AbstractCompletion.uniformContinuous_map₂
+-/
 
+#print AbstractCompletion.continuous_map₂ /-
 theorem continuous_map₂ {δ} [TopologicalSpace δ] {f : α → β → γ} {a : δ → hatα} {b : δ → hatβ}
     (ha : Continuous a) (hb : Continuous b) :
     Continuous fun d : δ => pkg.zipWith pkg' pkg'' f (a d) (b d) :=
   ((pkg.uniformContinuous_map₂ pkg' pkg'' f).Continuous.comp (Continuous.prod_mk ha hb) : _)
 #align abstract_completion.continuous_map₂ AbstractCompletion.continuous_map₂
+-/
 
+#print AbstractCompletion.map₂_coe_coe /-
 theorem map₂_coe_coe (a : α) (b : β) (f : α → β → γ) (hf : UniformContinuous₂ f) :
     pkg.zipWith pkg' pkg'' f (ι a) (ι' b) = ι'' (f a b) :=
   pkg.extension₂_coe_coe pkg' (pkg''.uniformContinuous_coe.comp hf) a b
 #align abstract_completion.map₂_coe_coe AbstractCompletion.map₂_coe_coe
+-/
 
 end Map₂
 

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

@@ -120,7 +120,7 @@ theorem continuous_coe : Continuous ι :=
 
 #print AbstractCompletion.induction_on /-
 @[elab_as_elim]
-theorem induction_on {p : hatα → Prop} (a : hatα) (hp : IsClosed { a | p a }) (ih : ∀ a, p (ι a)) :
+theorem induction_on {p : hatα → Prop} (a : hatα) (hp : IsClosed {a | p a}) (ih : ∀ a, p (ι a)) :
     p a :=
   isClosed_property pkg.dense hp ih a
 #align abstract_completion.induction_on AbstractCompletion.induction_on

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

@@ -74,8 +74,8 @@ structure AbstractCompletion (α : Type u) [UniformSpace α] where
 #align abstract_completion AbstractCompletion
 -/
 
-attribute [local instance]
-  AbstractCompletion.uniformStruct AbstractCompletion.complete AbstractCompletion.separation
+attribute [local instance] AbstractCompletion.uniformStruct AbstractCompletion.complete
+  AbstractCompletion.separation
 
 namespace AbstractCompletion
 

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

@@ -148,12 +148,6 @@ protected def extend (f : α → β) : hatα → β :=
 
 variable {f : α → β}
 
-/- warning: abstract_completion.extend_def -> AbstractCompletion.extend_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β}, (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (Eq.{max (succ u1) (succ u2)} ((AbstractCompletion.Space.{u1} α _inst_1 pkg) -> β) (AbstractCompletion.extend.{u1, u2} α _inst_1 pkg β _inst_2 f) (DenseInducing.extend.{u1, u1, u2} α (AbstractCompletion.Space.{u1} α _inst_1 pkg) β (UniformSpace.toTopologicalSpace.{u1} α _inst_1) (UniformSpace.toTopologicalSpace.{u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)) (AbstractCompletion.coe.{u1} α _inst_1 pkg) (UniformSpace.toTopologicalSpace.{u2} β _inst_2) (AbstractCompletion.denseInducing.{u1} α _inst_1 pkg) f))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] (pkg : AbstractCompletion.{u2} α _inst_1) {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β}, (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (Eq.{max (succ u2) (succ u1)} ((AbstractCompletion.space.{u2} α _inst_1 pkg) -> β) (AbstractCompletion.extend.{u2, u1} α _inst_1 pkg β _inst_2 f) (DenseInducing.extend.{u2, u2, u1} α (AbstractCompletion.space.{u2} α _inst_1 pkg) β (UniformSpace.toTopologicalSpace.{u2} α _inst_1) (UniformSpace.toTopologicalSpace.{u2} (AbstractCompletion.space.{u2} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u2} α _inst_1 pkg)) (AbstractCompletion.coe.{u2} α _inst_1 pkg) (UniformSpace.toTopologicalSpace.{u1} β _inst_2) (AbstractCompletion.denseInducing.{u2} α _inst_1 pkg) f))
-Case conversion may be inaccurate. Consider using '#align abstract_completion.extend_def AbstractCompletion.extend_defₓ'. -/
 theorem extend_def (hf : UniformContinuous f) : pkg.extend f = pkg.DenseInducing.extend f :=
   if_pos hf
 #align abstract_completion.extend_def AbstractCompletion.extend_def
@@ -168,12 +162,6 @@ theorem extend_coe [T2Space β] (hf : UniformContinuous f) (a : α) : (pkg.exten
 
 variable [CompleteSpace β]
 
-/- warning: abstract_completion.uniform_continuous_extend -> AbstractCompletion.uniformContinuous_extend is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_3 : CompleteSpace.{u2} β _inst_2], UniformContinuous.{u1, u2} (AbstractCompletion.Space.{u1} α _inst_1 pkg) β (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) _inst_2 (AbstractCompletion.extend.{u1, u2} α _inst_1 pkg β _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] (pkg : AbstractCompletion.{u2} α _inst_1) {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_3 : CompleteSpace.{u1} β _inst_2], UniformContinuous.{u2, u1} (AbstractCompletion.space.{u2} α _inst_1 pkg) β (AbstractCompletion.uniformStruct.{u2} α _inst_1 pkg) _inst_2 (AbstractCompletion.extend.{u2, u1} α _inst_1 pkg β _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align abstract_completion.uniform_continuous_extend AbstractCompletion.uniformContinuous_extendₓ'. -/
 theorem uniformContinuous_extend : UniformContinuous (pkg.extend f) :=
   by
   by_cases hf : UniformContinuous f
@@ -184,24 +172,12 @@ theorem uniformContinuous_extend : UniformContinuous (pkg.extend f) :=
     exact uniformContinuous_of_const fun a b => by congr
 #align abstract_completion.uniform_continuous_extend AbstractCompletion.uniformContinuous_extend
 
-/- warning: abstract_completion.continuous_extend -> AbstractCompletion.continuous_extend is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_3 : CompleteSpace.{u2} β _inst_2], Continuous.{u1, u2} (AbstractCompletion.Space.{u1} α _inst_1 pkg) β (UniformSpace.toTopologicalSpace.{u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)) (UniformSpace.toTopologicalSpace.{u2} β _inst_2) (AbstractCompletion.extend.{u1, u2} α _inst_1 pkg β _inst_2 f)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] (pkg : AbstractCompletion.{u2} α _inst_1) {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_3 : CompleteSpace.{u1} β _inst_2], Continuous.{u2, u1} (AbstractCompletion.space.{u2} α _inst_1 pkg) β (UniformSpace.toTopologicalSpace.{u2} (AbstractCompletion.space.{u2} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u2} α _inst_1 pkg)) (UniformSpace.toTopologicalSpace.{u1} β _inst_2) (AbstractCompletion.extend.{u2, u1} α _inst_1 pkg β _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align abstract_completion.continuous_extend AbstractCompletion.continuous_extendₓ'. -/
 theorem continuous_extend : Continuous (pkg.extend f) :=
   pkg.uniformContinuous_extend.Continuous
 #align abstract_completion.continuous_extend AbstractCompletion.continuous_extend
 
 variable [SeparatedSpace β]
 
-/- warning: abstract_completion.extend_unique -> AbstractCompletion.extend_unique is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] {f : α -> β} [_inst_3 : CompleteSpace.{u2} β _inst_2] [_inst_4 : SeparatedSpace.{u2} β _inst_2], (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall {g : (AbstractCompletion.Space.{u1} α _inst_1 pkg) -> β}, (UniformContinuous.{u1, u2} (AbstractCompletion.Space.{u1} α _inst_1 pkg) β (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) _inst_2 g) -> (forall (a : α), Eq.{succ u2} β (f a) (g (AbstractCompletion.coe.{u1} α _inst_1 pkg a))) -> (Eq.{max (succ u1) (succ u2)} ((AbstractCompletion.Space.{u1} α _inst_1 pkg) -> β) (AbstractCompletion.extend.{u1, u2} α _inst_1 pkg β _inst_2 f) g))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] (pkg : AbstractCompletion.{u2} α _inst_1) {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] {f : α -> β} [_inst_3 : CompleteSpace.{u1} β _inst_2] [_inst_4 : SeparatedSpace.{u1} β _inst_2], (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (forall {g : (AbstractCompletion.space.{u2} α _inst_1 pkg) -> β}, (UniformContinuous.{u2, u1} (AbstractCompletion.space.{u2} α _inst_1 pkg) β (AbstractCompletion.uniformStruct.{u2} α _inst_1 pkg) _inst_2 g) -> (forall (a : α), Eq.{succ u1} β (f a) (g (AbstractCompletion.coe.{u2} α _inst_1 pkg a))) -> (Eq.{max (succ u2) (succ u1)} ((AbstractCompletion.space.{u2} α _inst_1 pkg) -> β) (AbstractCompletion.extend.{u2, u1} α _inst_1 pkg β _inst_2 f) g))
-Case conversion may be inaccurate. Consider using '#align abstract_completion.extend_unique AbstractCompletion.extend_uniqueₓ'. -/
 theorem extend_unique (hf : UniformContinuous f) {g : hatα → β} (hg : UniformContinuous g)
     (h : ∀ a : α, f a = g (ι a)) : pkg.extend f = g :=
   by
@@ -209,12 +185,6 @@ theorem extend_unique (hf : UniformContinuous f) {g : hatα → β} (hg : Unifor
   simpa only [pkg.extend_coe hf] using h
 #align abstract_completion.extend_unique AbstractCompletion.extend_unique
 
-/- warning: abstract_completion.extend_comp_coe -> AbstractCompletion.extend_comp_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] [_inst_3 : CompleteSpace.{u2} β _inst_2] [_inst_4 : SeparatedSpace.{u2} β _inst_2] {f : (AbstractCompletion.Space.{u1} α _inst_1 pkg) -> β}, (UniformContinuous.{u1, u2} (AbstractCompletion.Space.{u1} α _inst_1 pkg) β (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) _inst_2 f) -> (Eq.{max (succ u1) (succ u2)} ((AbstractCompletion.Space.{u1} α _inst_1 pkg) -> β) (AbstractCompletion.extend.{u1, u2} α _inst_1 pkg β _inst_2 (Function.comp.{succ u1, succ u1, succ u2} α (AbstractCompletion.Space.{u1} α _inst_1 pkg) β f (AbstractCompletion.coe.{u1} α _inst_1 pkg))) f)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] (pkg : AbstractCompletion.{u2} α _inst_1) {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] [_inst_3 : CompleteSpace.{u1} β _inst_2] [_inst_4 : SeparatedSpace.{u1} β _inst_2] {f : (AbstractCompletion.space.{u2} α _inst_1 pkg) -> β}, (UniformContinuous.{u2, u1} (AbstractCompletion.space.{u2} α _inst_1 pkg) β (AbstractCompletion.uniformStruct.{u2} α _inst_1 pkg) _inst_2 f) -> (Eq.{max (succ u2) (succ u1)} ((AbstractCompletion.space.{u2} α _inst_1 pkg) -> β) (AbstractCompletion.extend.{u2, u1} α _inst_1 pkg β _inst_2 (Function.comp.{succ u2, succ u2, succ u1} α (AbstractCompletion.space.{u2} α _inst_1 pkg) β f (AbstractCompletion.coe.{u2} α _inst_1 pkg))) f)
-Case conversion may be inaccurate. Consider using '#align abstract_completion.extend_comp_coe AbstractCompletion.extend_comp_coeₓ'. -/
 @[simp]
 theorem extend_comp_coe {f : hatα → β} (hf : UniformContinuous f) : pkg.extend (f ∘ ι) = f :=
   funext fun x =>
@@ -246,45 +216,21 @@ local notation "map" => pkg.map pkg'
 
 variable (f : α → β)
 
-/- warning: abstract_completion.uniform_continuous_map -> AbstractCompletion.uniformContinuous_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) (f : α -> β), UniformContinuous.{u1, u2} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u2} β _inst_2 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u2} β _inst_2 pkg') (AbstractCompletion.map.{u1, u2} α _inst_1 pkg β _inst_2 pkg' f)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] (pkg : AbstractCompletion.{u2} α _inst_1) {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] (pkg' : AbstractCompletion.{u1} β _inst_2) (f : α -> β), UniformContinuous.{u2, u1} (AbstractCompletion.space.{u2} α _inst_1 pkg) (AbstractCompletion.space.{u1} β _inst_2 pkg') (AbstractCompletion.uniformStruct.{u2} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} β _inst_2 pkg') (AbstractCompletion.map.{u2, u1} α _inst_1 pkg β _inst_2 pkg' f)
-Case conversion may be inaccurate. Consider using '#align abstract_completion.uniform_continuous_map AbstractCompletion.uniformContinuous_mapₓ'. -/
 theorem uniformContinuous_map : UniformContinuous (map f) :=
   pkg.uniformContinuous_extend
 #align abstract_completion.uniform_continuous_map AbstractCompletion.uniformContinuous_map
 
-/- warning: abstract_completion.continuous_map -> AbstractCompletion.continuous_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) (f : α -> β), Continuous.{u1, u2} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u2} β _inst_2 pkg') (UniformSpace.toTopologicalSpace.{u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)) (UniformSpace.toTopologicalSpace.{u2} (AbstractCompletion.Space.{u2} β _inst_2 pkg') (AbstractCompletion.uniformStruct.{u2} β _inst_2 pkg')) (AbstractCompletion.map.{u1, u2} α _inst_1 pkg β _inst_2 pkg' f)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] (pkg : AbstractCompletion.{u2} α _inst_1) {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] (pkg' : AbstractCompletion.{u1} β _inst_2) (f : α -> β), Continuous.{u2, u1} (AbstractCompletion.space.{u2} α _inst_1 pkg) (AbstractCompletion.space.{u1} β _inst_2 pkg') (UniformSpace.toTopologicalSpace.{u2} (AbstractCompletion.space.{u2} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u2} α _inst_1 pkg)) (UniformSpace.toTopologicalSpace.{u1} (AbstractCompletion.space.{u1} β _inst_2 pkg') (AbstractCompletion.uniformStruct.{u1} β _inst_2 pkg')) (AbstractCompletion.map.{u2, u1} α _inst_1 pkg β _inst_2 pkg' f)
-Case conversion may be inaccurate. Consider using '#align abstract_completion.continuous_map AbstractCompletion.continuous_mapₓ'. -/
 theorem continuous_map : Continuous (map f) :=
   pkg.continuous_extend
 #align abstract_completion.continuous_map AbstractCompletion.continuous_map
 
 variable {f}
 
-/- warning: abstract_completion.map_coe -> AbstractCompletion.map_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {f : α -> β}, (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u2} (AbstractCompletion.Space.{u2} β _inst_2 pkg') (AbstractCompletion.map.{u1, u2} α _inst_1 pkg β _inst_2 pkg' f (AbstractCompletion.coe.{u1} α _inst_1 pkg a)) (AbstractCompletion.coe.{u2} β _inst_2 pkg' (f a)))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] (pkg : AbstractCompletion.{u2} α _inst_1) {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] (pkg' : AbstractCompletion.{u1} β _inst_2) {f : α -> β}, (UniformContinuous.{u2, u1} α β _inst_1 _inst_2 f) -> (forall (a : α), Eq.{succ u1} (AbstractCompletion.space.{u1} β _inst_2 pkg') (AbstractCompletion.map.{u2, u1} α _inst_1 pkg β _inst_2 pkg' f (AbstractCompletion.coe.{u2} α _inst_1 pkg a)) (AbstractCompletion.coe.{u1} β _inst_2 pkg' (f a)))
-Case conversion may be inaccurate. Consider using '#align abstract_completion.map_coe AbstractCompletion.map_coeₓ'. -/
 @[simp]
 theorem map_coe (hf : UniformContinuous f) (a : α) : map f (ι a) = ι' (f a) :=
   pkg.extend_coe (pkg'.uniformContinuous_coe.comp hf) a
 #align abstract_completion.map_coe AbstractCompletion.map_coe
 
-/- warning: abstract_completion.map_unique -> AbstractCompletion.map_unique is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {f : α -> β} {g : (AbstractCompletion.Space.{u1} α _inst_1 pkg) -> (AbstractCompletion.Space.{u2} β _inst_2 pkg')}, (UniformContinuous.{u1, u2} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u2} β _inst_2 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u2} β _inst_2 pkg') g) -> (forall (a : α), Eq.{succ u2} (AbstractCompletion.Space.{u2} β _inst_2 pkg') (AbstractCompletion.coe.{u2} β _inst_2 pkg' (f a)) (g (AbstractCompletion.coe.{u1} α _inst_1 pkg a))) -> (Eq.{max (succ u1) (succ u2)} ((AbstractCompletion.Space.{u1} α _inst_1 pkg) -> (AbstractCompletion.Space.{u2} β _inst_2 pkg')) (AbstractCompletion.map.{u1, u2} α _inst_1 pkg β _inst_2 pkg' f) g)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] (pkg : AbstractCompletion.{u2} α _inst_1) {β : Type.{u1}} [_inst_2 : UniformSpace.{u1} β] (pkg' : AbstractCompletion.{u1} β _inst_2) {f : α -> β} {g : (AbstractCompletion.space.{u2} α _inst_1 pkg) -> (AbstractCompletion.space.{u1} β _inst_2 pkg')}, (UniformContinuous.{u2, u1} (AbstractCompletion.space.{u2} α _inst_1 pkg) (AbstractCompletion.space.{u1} β _inst_2 pkg') (AbstractCompletion.uniformStruct.{u2} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} β _inst_2 pkg') g) -> (forall (a : α), Eq.{succ u1} (AbstractCompletion.space.{u1} β _inst_2 pkg') (AbstractCompletion.coe.{u1} β _inst_2 pkg' (f a)) (g (AbstractCompletion.coe.{u2} α _inst_1 pkg a))) -> (Eq.{max (succ u2) (succ u1)} ((AbstractCompletion.space.{u2} α _inst_1 pkg) -> (AbstractCompletion.space.{u1} β _inst_2 pkg')) (AbstractCompletion.map.{u2, u1} α _inst_1 pkg β _inst_2 pkg' f) g)
-Case conversion may be inaccurate. Consider using '#align abstract_completion.map_unique AbstractCompletion.map_uniqueₓ'. -/
 theorem map_unique {f : α → β} {g : hatα → hatβ} (hg : UniformContinuous g)
     (h : ∀ a, ι' (f a) = g (ι a)) : map f = g :=
   pkg.funext (pkg.continuous_map _ _) hg.Continuous <|
@@ -315,12 +261,6 @@ theorem extend_map [CompleteSpace γ] [SeparatedSpace γ] {f : β → γ} {g : 
 
 variable (pkg'' : AbstractCompletion γ)
 
-/- warning: abstract_completion.map_comp -> AbstractCompletion.map_comp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (pkg'' : AbstractCompletion.{u3} γ _inst_3) {g : β -> γ} {f : α -> β}, (UniformContinuous.{u2, u3} β γ _inst_2 _inst_3 g) -> (UniformContinuous.{u1, u2} α β _inst_1 _inst_2 f) -> (Eq.{max (succ u1) (succ u3)} ((AbstractCompletion.Space.{u1} α _inst_1 pkg) -> (AbstractCompletion.Space.{u3} γ _inst_3 pkg'')) (Function.comp.{succ u1, succ u2, succ u3} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u2} β _inst_2 pkg') (AbstractCompletion.Space.{u3} γ _inst_3 pkg'') (AbstractCompletion.map.{u2, u3} β _inst_2 pkg' γ _inst_3 pkg'' g) (AbstractCompletion.map.{u1, u2} α _inst_1 pkg β _inst_2 pkg' f)) (AbstractCompletion.map.{u1, u3} α _inst_1 pkg γ _inst_3 pkg'' (Function.comp.{succ u1, succ u2, succ u3} α β γ g f)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u3}} [_inst_2 : UniformSpace.{u3} β] (pkg' : AbstractCompletion.{u3} β _inst_2) {γ : Type.{u2}} [_inst_3 : UniformSpace.{u2} γ] (pkg'' : AbstractCompletion.{u2} γ _inst_3) {g : β -> γ} {f : α -> β}, (UniformContinuous.{u3, u2} β γ _inst_2 _inst_3 g) -> (UniformContinuous.{u1, u3} α β _inst_1 _inst_2 f) -> (Eq.{max (succ u1) (succ u2)} ((AbstractCompletion.space.{u1} α _inst_1 pkg) -> (AbstractCompletion.space.{u2} γ _inst_3 pkg'')) (Function.comp.{succ u1, succ u3, succ u2} (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.space.{u3} β _inst_2 pkg') (AbstractCompletion.space.{u2} γ _inst_3 pkg'') (AbstractCompletion.map.{u3, u2} β _inst_2 pkg' γ _inst_3 pkg'' g) (AbstractCompletion.map.{u1, u3} α _inst_1 pkg β _inst_2 pkg' f)) (AbstractCompletion.map.{u1, u2} α _inst_1 pkg γ _inst_3 pkg'' (Function.comp.{succ u1, succ u3, succ u2} α β γ g f)))
-Case conversion may be inaccurate. Consider using '#align abstract_completion.map_comp AbstractCompletion.map_compₓ'. -/
 theorem map_comp {g : β → γ} {f : α → β} (hg : UniformContinuous g) (hf : UniformContinuous f) :
     pkg'.map pkg'' g ∘ pkg.map pkg' f = pkg.map pkg'' (g ∘ f) :=
   pkg.extend_map pkg' (pkg''.uniformContinuous_coe.comp hg) hf
@@ -377,22 +317,10 @@ def compareEquiv : pkg.Space ≃ᵤ pkg'.Space
 #align abstract_completion.compare_equiv AbstractCompletion.compareEquiv
 -/
 
-/- warning: abstract_completion.uniform_continuous_compare_equiv -> AbstractCompletion.uniformContinuous_compareEquiv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) (pkg' : AbstractCompletion.{u1} α _inst_1), UniformContinuous.{u1, u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (coeFn.{succ u1, succ u1} (UniformEquiv.{u1, u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg')) (fun (_x : UniformEquiv.{u1, u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg')) => (AbstractCompletion.Space.{u1} α _inst_1 pkg) -> (AbstractCompletion.Space.{u1} α _inst_1 pkg')) (UniformEquiv.hasCoeToFun.{u1, u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg')) (AbstractCompletion.compareEquiv.{u1} α _inst_1 pkg pkg'))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) (pkg' : AbstractCompletion.{u1} α _inst_1), UniformContinuous.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (FunLike.coe.{succ u1, succ u1, succ u1} (UniformEquiv.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg')) (AbstractCompletion.space.{u1} α _inst_1 pkg) (fun (_x : AbstractCompletion.space.{u1} α _inst_1 pkg) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : AbstractCompletion.space.{u1} α _inst_1 pkg) => AbstractCompletion.space.{u1} α _inst_1 pkg') _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (UniformEquiv.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg')) (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.space.{u1} α _inst_1 pkg') (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (UniformEquiv.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg')) (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.space.{u1} α _inst_1 pkg') (UniformEquiv.instEquivLikeUniformEquiv.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg')))) (AbstractCompletion.compareEquiv.{u1} α _inst_1 pkg pkg'))
-Case conversion may be inaccurate. Consider using '#align abstract_completion.uniform_continuous_compare_equiv AbstractCompletion.uniformContinuous_compareEquivₓ'. -/
 theorem uniformContinuous_compareEquiv : UniformContinuous (pkg.compareEquiv pkg') :=
   pkg.uniformContinuous_compare pkg'
 #align abstract_completion.uniform_continuous_compare_equiv AbstractCompletion.uniformContinuous_compareEquiv
 
-/- warning: abstract_completion.uniform_continuous_compare_equiv_symm -> AbstractCompletion.uniformContinuous_compareEquiv_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) (pkg' : AbstractCompletion.{u1} α _inst_1), UniformContinuous.{u1, u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg') (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (coeFn.{succ u1, succ u1} (UniformEquiv.{u1, u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg') (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)) (fun (_x : UniformEquiv.{u1, u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg') (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)) => (AbstractCompletion.Space.{u1} α _inst_1 pkg') -> (AbstractCompletion.Space.{u1} α _inst_1 pkg)) (UniformEquiv.hasCoeToFun.{u1, u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg') (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)) (UniformEquiv.symm.{u1, u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.compareEquiv.{u1} α _inst_1 pkg pkg')))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) (pkg' : AbstractCompletion.{u1} α _inst_1), UniformContinuous.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (FunLike.coe.{succ u1, succ u1, succ u1} (UniformEquiv.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)) (AbstractCompletion.space.{u1} α _inst_1 pkg') (fun (_x : AbstractCompletion.space.{u1} α _inst_1 pkg') => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : AbstractCompletion.space.{u1} α _inst_1 pkg') => AbstractCompletion.space.{u1} α _inst_1 pkg) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (UniformEquiv.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)) (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.space.{u1} α _inst_1 pkg) (EquivLike.toEmbeddingLike.{succ u1, succ u1, succ u1} (UniformEquiv.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)) (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.space.{u1} α _inst_1 pkg) (UniformEquiv.instEquivLikeUniformEquiv.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)))) (UniformEquiv.symm.{u1, u1} (AbstractCompletion.space.{u1} α _inst_1 pkg) (AbstractCompletion.space.{u1} α _inst_1 pkg') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg') (AbstractCompletion.compareEquiv.{u1} α _inst_1 pkg pkg')))
-Case conversion may be inaccurate. Consider using '#align abstract_completion.uniform_continuous_compare_equiv_symm AbstractCompletion.uniformContinuous_compareEquiv_symmₓ'. -/
 theorem uniformContinuous_compareEquiv_symm : UniformContinuous (pkg.compareEquiv pkg').symm :=
   pkg'.uniformContinuous_compare pkg
 #align abstract_completion.uniform_continuous_compare_equiv_symm AbstractCompletion.uniformContinuous_compareEquiv_symm
@@ -409,12 +337,6 @@ local notation "hatβ" => pkg'.Space
 -- mathport name: exprι'
 local notation "ι'" => pkg'.coe
 
-/- warning: abstract_completion.prod -> AbstractCompletion.prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], (AbstractCompletion.{u1} α _inst_1) -> (forall {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β], (AbstractCompletion.{u2} β _inst_2) -> (AbstractCompletion.{max u1 u2} (Prod.{u1, u2} α β) (Prod.uniformSpace.{u1, u2} α β _inst_1 _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α], (AbstractCompletion.{u1} α _inst_1) -> (forall {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β], (AbstractCompletion.{u2} β _inst_2) -> (AbstractCompletion.{max u2 u1} (Prod.{u1, u2} α β) (instUniformSpaceProd.{u1, u2} α β _inst_1 _inst_2)))
-Case conversion may be inaccurate. Consider using '#align abstract_completion.prod AbstractCompletion.prodₓ'. -/
 /-- Products of completions -/
 protected def prod : AbstractCompletion (α × β)
     where
@@ -454,12 +376,6 @@ section SeparatedSpace
 
 variable [SeparatedSpace γ] {f : α → β → γ}
 
-/- warning: abstract_completion.extension₂_coe_coe -> AbstractCompletion.extension₂_coe_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] [_inst_4 : SeparatedSpace.{u3} γ _inst_3] {f : α -> β -> γ}, (UniformContinuous.{max u1 u2, u3} (Prod.{u1, u2} α β) γ (Prod.uniformSpace.{u1, u2} α β _inst_1 _inst_2) _inst_3 (Function.uncurry.{u1, u2, u3} α β γ f)) -> (forall (a : α) (b : β), Eq.{succ u3} γ (AbstractCompletion.extend₂.{u1, u2, u3} α _inst_1 pkg β _inst_2 pkg' γ _inst_3 f (AbstractCompletion.coe.{u1} α _inst_1 pkg a) (AbstractCompletion.coe.{u2} β _inst_2 pkg' b)) (f a b))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : UniformSpace.{u2} α] (pkg : AbstractCompletion.{u2} α _inst_1) {β : Type.{u3}} [_inst_2 : UniformSpace.{u3} β] (pkg' : AbstractCompletion.{u3} β _inst_2) {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] [_inst_4 : SeparatedSpace.{u1} γ _inst_3] {f : α -> β -> γ}, (UniformContinuous.{max u3 u2, u1} (Prod.{u2, u3} α β) γ (instUniformSpaceProd.{u2, u3} α β _inst_1 _inst_2) _inst_3 (Function.uncurry.{u2, u3, u1} α β γ f)) -> (forall (a : α) (b : β), Eq.{succ u1} γ (AbstractCompletion.extend₂.{u2, u3, u1} α _inst_1 pkg β _inst_2 pkg' γ _inst_3 f (AbstractCompletion.coe.{u2} α _inst_1 pkg a) (AbstractCompletion.coe.{u3} β _inst_2 pkg' b)) (f a b))
-Case conversion may be inaccurate. Consider using '#align abstract_completion.extension₂_coe_coe AbstractCompletion.extension₂_coe_coeₓ'. -/
 theorem extension₂_coe_coe (hf : UniformContinuous <| uncurry f) (a : α) (b : β) :
     pkg.extend₂ pkg' f (ι a) (ι' b) = f a b :=
   show (pkg.Prod pkg').extend (uncurry f) ((pkg.Prod pkg').coe (a, b)) = uncurry f (a, b) from
@@ -472,12 +388,6 @@ variable {f : α → β → γ}
 
 variable [CompleteSpace γ] (f)
 
-/- warning: abstract_completion.uniform_continuous_extension₂ -> AbstractCompletion.uniformContinuous_extension₂ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (f : α -> β -> γ) [_inst_4 : CompleteSpace.{u3} γ _inst_3], UniformContinuous₂.{u1, u2, u3} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u2} β _inst_2 pkg') γ (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u2} β _inst_2 pkg') _inst_3 (AbstractCompletion.extend₂.{u1, u2, u3} α _inst_1 pkg β _inst_2 pkg' γ _inst_3 f)
-but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] (pkg : AbstractCompletion.{u3} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (f : α -> β -> γ) [_inst_4 : CompleteSpace.{u1} γ _inst_3], UniformContinuous₂.{u3, u2, u1} (AbstractCompletion.space.{u3} α _inst_1 pkg) (AbstractCompletion.space.{u2} β _inst_2 pkg') γ (AbstractCompletion.uniformStruct.{u3} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u2} β _inst_2 pkg') _inst_3 (AbstractCompletion.extend₂.{u3, u2, u1} α _inst_1 pkg β _inst_2 pkg' γ _inst_3 f)
-Case conversion may be inaccurate. Consider using '#align abstract_completion.uniform_continuous_extension₂ AbstractCompletion.uniformContinuous_extension₂ₓ'. -/
 theorem uniformContinuous_extension₂ : UniformContinuous₂ (pkg.extend₂ pkg' f) :=
   by
   rw [uniformContinuous₂_def, AbstractCompletion.extend₂, uncurry_curry]
@@ -514,34 +424,16 @@ protected def map₂ (f : α → β → γ) : hatα → hatβ → hatγ :=
 #align abstract_completion.map₂ AbstractCompletion.map₂
 -/
 
-/- warning: abstract_completion.uniform_continuous_map₂ -> AbstractCompletion.uniformContinuous_map₂ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (pkg'' : AbstractCompletion.{u3} γ _inst_3) (f : α -> β -> γ), UniformContinuous₂.{u1, u2, u3} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.Space.{u2} β _inst_2 pkg') (AbstractCompletion.Space.{u3} γ _inst_3 pkg'') (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u2} β _inst_2 pkg') (AbstractCompletion.uniformStruct.{u3} γ _inst_3 pkg'') (AbstractCompletion.map₂.{u1, u2, u3} α _inst_1 pkg β _inst_2 pkg' γ _inst_3 pkg'' f)
-but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] (pkg : AbstractCompletion.{u3} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (pkg'' : AbstractCompletion.{u1} γ _inst_3) (f : α -> β -> γ), UniformContinuous₂.{u3, u2, u1} (AbstractCompletion.space.{u3} α _inst_1 pkg) (AbstractCompletion.space.{u2} β _inst_2 pkg') (AbstractCompletion.space.{u1} γ _inst_3 pkg'') (AbstractCompletion.uniformStruct.{u3} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u2} β _inst_2 pkg') (AbstractCompletion.uniformStruct.{u1} γ _inst_3 pkg'') (AbstractCompletion.map₂.{u3, u2, u1} α _inst_1 pkg β _inst_2 pkg' γ _inst_3 pkg'' f)
-Case conversion may be inaccurate. Consider using '#align abstract_completion.uniform_continuous_map₂ AbstractCompletion.uniformContinuous_map₂ₓ'. -/
 theorem uniformContinuous_map₂ (f : α → β → γ) : UniformContinuous₂ (pkg.zipWith pkg' pkg'' f) :=
   pkg.uniformContinuous_extension₂ pkg' _
 #align abstract_completion.uniform_continuous_map₂ AbstractCompletion.uniformContinuous_map₂
 
-/- warning: abstract_completion.continuous_map₂ -> AbstractCompletion.continuous_map₂ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (pkg'' : AbstractCompletion.{u3} γ _inst_3) {δ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} δ] {f : α -> β -> γ} {a : δ -> (AbstractCompletion.Space.{u1} α _inst_1 pkg)} {b : δ -> (AbstractCompletion.Space.{u2} β _inst_2 pkg')}, (Continuous.{u4, u1} δ (AbstractCompletion.Space.{u1} α _inst_1 pkg) _inst_4 (UniformSpace.toTopologicalSpace.{u1} (AbstractCompletion.Space.{u1} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u1} α _inst_1 pkg)) a) -> (Continuous.{u4, u2} δ (AbstractCompletion.Space.{u2} β _inst_2 pkg') _inst_4 (UniformSpace.toTopologicalSpace.{u2} (AbstractCompletion.Space.{u2} β _inst_2 pkg') (AbstractCompletion.uniformStruct.{u2} β _inst_2 pkg')) b) -> (Continuous.{u4, u3} δ (AbstractCompletion.Space.{u3} γ _inst_3 pkg'') _inst_4 (UniformSpace.toTopologicalSpace.{u3} (AbstractCompletion.Space.{u3} γ _inst_3 pkg'') (AbstractCompletion.uniformStruct.{u3} γ _inst_3 pkg'')) (fun (d : δ) => AbstractCompletion.map₂.{u1, u2, u3} α _inst_1 pkg β _inst_2 pkg' γ _inst_3 pkg'' f (a d) (b d)))
-but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] (pkg : AbstractCompletion.{u3} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (pkg'' : AbstractCompletion.{u1} γ _inst_3) {δ : Type.{u4}} [_inst_4 : TopologicalSpace.{u4} δ] {f : α -> β -> γ} {a : δ -> (AbstractCompletion.space.{u3} α _inst_1 pkg)} {b : δ -> (AbstractCompletion.space.{u2} β _inst_2 pkg')}, (Continuous.{u4, u3} δ (AbstractCompletion.space.{u3} α _inst_1 pkg) _inst_4 (UniformSpace.toTopologicalSpace.{u3} (AbstractCompletion.space.{u3} α _inst_1 pkg) (AbstractCompletion.uniformStruct.{u3} α _inst_1 pkg)) a) -> (Continuous.{u4, u2} δ (AbstractCompletion.space.{u2} β _inst_2 pkg') _inst_4 (UniformSpace.toTopologicalSpace.{u2} (AbstractCompletion.space.{u2} β _inst_2 pkg') (AbstractCompletion.uniformStruct.{u2} β _inst_2 pkg')) b) -> (Continuous.{u4, u1} δ (AbstractCompletion.space.{u1} γ _inst_3 pkg'') _inst_4 (UniformSpace.toTopologicalSpace.{u1} (AbstractCompletion.space.{u1} γ _inst_3 pkg'') (AbstractCompletion.uniformStruct.{u1} γ _inst_3 pkg'')) (fun (d : δ) => AbstractCompletion.map₂.{u3, u2, u1} α _inst_1 pkg β _inst_2 pkg' γ _inst_3 pkg'' f (a d) (b d)))
-Case conversion may be inaccurate. Consider using '#align abstract_completion.continuous_map₂ AbstractCompletion.continuous_map₂ₓ'. -/
 theorem continuous_map₂ {δ} [TopologicalSpace δ] {f : α → β → γ} {a : δ → hatα} {b : δ → hatβ}
     (ha : Continuous a) (hb : Continuous b) :
     Continuous fun d : δ => pkg.zipWith pkg' pkg'' f (a d) (b d) :=
   ((pkg.uniformContinuous_map₂ pkg' pkg'' f).Continuous.comp (Continuous.prod_mk ha hb) : _)
 #align abstract_completion.continuous_map₂ AbstractCompletion.continuous_map₂
 
-/- warning: abstract_completion.map₂_coe_coe -> AbstractCompletion.map₂_coe_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : UniformSpace.{u1} α] (pkg : AbstractCompletion.{u1} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {γ : Type.{u3}} [_inst_3 : UniformSpace.{u3} γ] (pkg'' : AbstractCompletion.{u3} γ _inst_3) (a : α) (b : β) (f : α -> β -> γ), (UniformContinuous₂.{u1, u2, u3} α β γ _inst_1 _inst_2 _inst_3 f) -> (Eq.{succ u3} (AbstractCompletion.Space.{u3} γ _inst_3 pkg'') (AbstractCompletion.map₂.{u1, u2, u3} α _inst_1 pkg β _inst_2 pkg' γ _inst_3 pkg'' f (AbstractCompletion.coe.{u1} α _inst_1 pkg a) (AbstractCompletion.coe.{u2} β _inst_2 pkg' b)) (AbstractCompletion.coe.{u3} γ _inst_3 pkg'' (f a b)))
-but is expected to have type
-  forall {α : Type.{u3}} [_inst_1 : UniformSpace.{u3} α] (pkg : AbstractCompletion.{u3} α _inst_1) {β : Type.{u2}} [_inst_2 : UniformSpace.{u2} β] (pkg' : AbstractCompletion.{u2} β _inst_2) {γ : Type.{u1}} [_inst_3 : UniformSpace.{u1} γ] (pkg'' : AbstractCompletion.{u1} γ _inst_3) (a : α) (b : β) (f : α -> β -> γ), (UniformContinuous₂.{u3, u2, u1} α β γ _inst_1 _inst_2 _inst_3 f) -> (Eq.{succ u1} (AbstractCompletion.space.{u1} γ _inst_3 pkg'') (AbstractCompletion.map₂.{u3, u2, u1} α _inst_1 pkg β _inst_2 pkg' γ _inst_3 pkg'' f (AbstractCompletion.coe.{u3} α _inst_1 pkg a) (AbstractCompletion.coe.{u2} β _inst_2 pkg' b)) (AbstractCompletion.coe.{u1} γ _inst_3 pkg'' (f a b)))
-Case conversion may be inaccurate. Consider using '#align abstract_completion.map₂_coe_coe AbstractCompletion.map₂_coe_coeₓ'. -/
 theorem map₂_coe_coe (a : α) (b : β) (f : α → β → γ) (hf : UniformContinuous₂ f) :
     pkg.zipWith pkg' pkg'' f (ι a) (ι' b) = ι'' (f a b) :=
   pkg.extension₂_coe_coe pkg' (pkg''.uniformContinuous_coe.comp hf) a b

mathlib commit https://github.com/leanprover-community/mathlib/commit/09079525fd01b3dda35e96adaa08d2f943e1648c

@@ -54,7 +54,7 @@ uniform spaces, completion, universal property
 
 noncomputable section
 
-attribute [local instance] Classical.propDecidable
+attribute [local instance 10] Classical.propDecidable
 
 open Filter Set Function
 

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

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)

@@ -337,7 +337,6 @@ theorem extension₂_coe_coe (hf : UniformContinuous <| uncurry f) (a : α) (b :
 end T0Space
 
 variable {f : α → β → γ}
-
 variable [CompleteSpace γ] (f)
 
 theorem uniformContinuous_extension₂ : UniformContinuous₂ (pkg.extend₂ pkg' f) := by

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

@@ -65,8 +65,8 @@ structure AbstractCompletion (α : Type u) [UniformSpace α] where
   uniformStruct : UniformSpace space
   /-- The completion is complete. -/
   complete : CompleteSpace space
-  /-- The completion is a separated space. -/
-  separation : SeparatedSpace space
+  /-- The completion is a T₀ space. -/
+  separation : T0Space space
   /-- The map into the completion is uniform-inducing. -/
   uniformInducing : UniformInducing coe
   /-- The map into the completion has dense range. -/
@@ -85,7 +85,7 @@ local notation "hatα" => pkg.space
 local notation "ι" => pkg.coe
 
 /-- If `α` is complete, then it is an abstract completion of itself. -/
-def ofComplete [SeparatedSpace α] [CompleteSpace α] : AbstractCompletion α :=
+def ofComplete [T0Space α] [CompleteSpace α] : AbstractCompletion α :=
   mk α id inferInstance inferInstance inferInstance uniformInducing_id denseRange_id
 #align abstract_completion.of_complete AbstractCompletion.ofComplete
 
@@ -153,7 +153,7 @@ theorem continuous_extend : Continuous (pkg.extend f) :=
   pkg.uniformContinuous_extend.continuous
 #align abstract_completion.continuous_extend AbstractCompletion.continuous_extend
 
-variable [SeparatedSpace β]
+variable [T0Space β]
 
 theorem extend_unique (hf : UniformContinuous f) {g : hatα → β} (hg : UniformContinuous g)
     (h : ∀ a : α, f a = g (ι a)) : pkg.extend f = g := by
@@ -219,7 +219,7 @@ theorem map_id : pkg.map pkg id = id :=
 
 variable {γ : Type*} [UniformSpace γ]
 
-theorem extend_map [CompleteSpace γ] [SeparatedSpace γ] {f : β → γ} {g : α → β}
+theorem extend_map [CompleteSpace γ] [T0Space γ] {f : β → γ} {g : α → β}
     (hf : UniformContinuous f) (hg : UniformContinuous g) :
     pkg'.extend f ∘ map g = pkg.extend (f ∘ g) :=
   pkg.funext (pkg'.continuous_extend.comp (pkg.continuous_map pkg' _)) pkg.continuous_extend
@@ -324,9 +324,9 @@ protected def extend₂ (f : α → β → γ) : hatα → hatβ → γ :=
   curry <| (pkg.prod pkg').extend (uncurry f)
 #align abstract_completion.extend₂ AbstractCompletion.extend₂
 
-section SeparatedSpace
+section T0Space
 
-variable [SeparatedSpace γ] {f : α → β → γ}
+variable [T0Space γ] {f : α → β → γ}
 
 theorem extension₂_coe_coe (hf : UniformContinuous <| uncurry f) (a : α) (b : β) :
     pkg.extend₂ pkg' f (ι a) (ι' b) = f a b :=
@@ -334,7 +334,7 @@ theorem extension₂_coe_coe (hf : UniformContinuous <| uncurry f) (a : α) (b :
     (pkg.prod pkg').extend_coe hf _
 #align abstract_completion.extension₂_coe_coe AbstractCompletion.extension₂_coe_coe
 
-end SeparatedSpace
+end T0Space
 
 variable {f : α → β → γ}
 

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -208,7 +208,7 @@ theorem map_unique {f : α → β} {g : hatα → hatβ} (hg : UniformContinuous
   pkg.funext (pkg.continuous_map _ _) hg.continuous <| by
     intro a
     change pkg.extend (ι' ∘ f) _ = _
-    simp_rw [(· ∘ ·), h, ←comp_apply (f := g)]
+    simp_rw [(· ∘ ·), h, ← comp_apply (f := g)]
     rw [pkg.extend_coe (hg.comp pkg.uniformContinuous_coe)]
 #align abstract_completion.map_unique AbstractCompletion.map_unique
 

This will mostly be a no-op in the current version of Lean, but will override the new behavior from leanprover/lean4#2783.

Once consequence of this is that rw [comp] no longer uses "smart unfolding"; it introduces a non-beta reduced term if the composition was applied. As a result, these places need to use rw [comp_apply] instead. My claim is that this is no big deal.

This is split from the lean bump PR #8023, targeting master, to make clear what the fallout is.

@@ -208,7 +208,7 @@ theorem map_unique {f : α → β} {g : hatα → hatβ} (hg : UniformContinuous
   pkg.funext (pkg.continuous_map _ _) hg.continuous <| by
     intro a
     change pkg.extend (ι' ∘ f) _ = _
-    simp only [(· ∘ ·), h, ←comp_apply (f := g)]
+    simp_rw [(· ∘ ·), h, ←comp_apply (f := g)]
     rw [pkg.extend_coe (hg.comp pkg.uniformContinuous_coe)]
 #align abstract_completion.map_unique AbstractCompletion.map_unique
 

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

This has nice performance benefits.

@@ -78,7 +78,7 @@ attribute [local instance]
 
 namespace AbstractCompletion
 
-variable {α : Type _} [UniformSpace α] (pkg : AbstractCompletion α)
+variable {α : Type*} [UniformSpace α] (pkg : AbstractCompletion α)
 
 local notation "hatα" => pkg.space
 
@@ -111,7 +111,7 @@ theorem induction_on {p : hatα → Prop} (a : hatα) (hp : IsClosed { a | p a }
   isClosed_property pkg.dense hp ih a
 #align abstract_completion.induction_on AbstractCompletion.induction_on
 
-variable {β : Type _}
+variable {β : Type*}
 
 protected theorem funext [TopologicalSpace β] [T2Space β] {f g : hatα → β} (hf : Continuous f)
     (hg : Continuous g) (h : ∀ a, f (ι a) = g (ι a)) : f = g :=
@@ -217,7 +217,7 @@ theorem map_id : pkg.map pkg id = id :=
   pkg.map_unique pkg uniformContinuous_id fun _ => rfl
 #align abstract_completion.map_id AbstractCompletion.map_id
 
-variable {γ : Type _} [UniformSpace γ]
+variable {γ : Type*} [UniformSpace γ]
 
 theorem extend_map [CompleteSpace γ] [SeparatedSpace γ] {f : β → γ} {g : α → β}
     (hf : UniformContinuous f) (hg : UniformContinuous g) :
@@ -315,7 +315,7 @@ local notation "hatβ" => pkg'.space
 
 local notation "ι'" => pkg'.coe
 
-variable {γ : Type _} [UniformSpace γ]
+variable {γ : Type*} [UniformSpace γ]
 
 open Function
 
@@ -355,7 +355,7 @@ local notation "hatβ" => pkg'.space
 
 local notation "ι'" => pkg'.coe
 
-variable {γ : Type _} [UniformSpace γ] (pkg'' : AbstractCompletion γ)
+variable {γ : Type*} [UniformSpace γ] (pkg'' : AbstractCompletion γ)
 
 local notation "hatγ" => pkg''.space
 

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2019 Patrick Massot. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Patrick Massot
-
-! This file was ported from Lean 3 source module topology.uniform_space.abstract_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.UniformEmbedding
 import Mathlib.Topology.UniformSpace.Equiv
 
+#align_import topology.uniform_space.abstract_completion from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+
 /-!
 # Abstract theory of Hausdorff completions of uniform spaces
 

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".

@@ -208,8 +208,7 @@ theorem map_coe (hf : UniformContinuous f) (a : α) : map f (ι a) = ι' (f a) :
 
 theorem map_unique {f : α → β} {g : hatα → hatβ} (hg : UniformContinuous g)
     (h : ∀ a, ι' (f a) = g (ι a)) : map f = g :=
-  pkg.funext (pkg.continuous_map _ _) hg.continuous <|
-    by
+  pkg.funext (pkg.continuous_map _ _) hg.continuous <| by
     intro a
     change pkg.extend (ι' ∘ f) _ = _
     simp only [(· ∘ ·), h, ←comp_apply (f := g)]

Restore the remaining @[continuity] attributes that were ported while the continuity tactic was in the works.

@@ -194,7 +194,7 @@ theorem uniformContinuous_map : UniformContinuous (map f) :=
   pkg.uniformContinuous_extend
 #align abstract_completion.uniform_continuous_map AbstractCompletion.uniformContinuous_map
 
--- @[continuity] -- Porting note: Add tag once implemented
+@[continuity]
 theorem continuous_map : Continuous (map f) :=
   pkg.continuous_extend
 #align abstract_completion.continuous_map AbstractCompletion.continuous_map