topology.category.Profinite.basic ⟷ Mathlib.Topology.Category.Profinite.Basic

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

@@ -131,7 +131,7 @@ end Profinite
 @[simps]
 def profiniteToCompHaus : Profinite ⥤ CompHaus :=
   inducedFunctor _
-deriving Full, Faithful
+deriving CategoryTheory.Functor.Full, CategoryTheory.Functor.Faithful
 #align Profinite_to_CompHaus profiniteToCompHaus
 -/
 
@@ -141,7 +141,7 @@ obvious composite. -/
 @[simps]
 def Profinite.toTopCat : Profinite ⥤ TopCat :=
   forget₂ _ _
-deriving Full, Faithful
+deriving CategoryTheory.Functor.Full, CategoryTheory.Functor.Faithful
 #align Profinite.to_Top Profinite.toTopCat
 -/
 
@@ -344,7 +344,8 @@ noncomputable def isoOfBijective (bij : Function.Bijective f) : X ≅ Y :=
 -/
 
 #print Profinite.forget_reflectsIsomorphisms /-
-instance forget_reflectsIsomorphisms : ReflectsIsomorphisms (forget Profinite) :=
+instance forget_reflectsIsomorphisms :
+    CategoryTheory.Functor.ReflectsIsomorphisms (forget Profinite) :=
   ⟨by intro A B f hf <;> exact Profinite.isIso_of_bijective _ ((is_iso_iff_bijective f).mp hf)⟩
 #align Profinite.forget_reflects_isomorphisms Profinite.forget_reflectsIsomorphisms
 -/

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

@@ -4,12 +4,12 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kevin Buzzard, Calle Sönne
 -/
 import Topology.Category.CompHaus.Basic
-import Topology.Connected
+import Topology.Connected.Basic
 import Topology.SubsetProperties
 import Topology.LocallyConstant.Basic
 import CategoryTheory.Adjunction.Reflective
 import CategoryTheory.Monad.Limits
-import CategoryTheory.Fintype
+import CategoryTheory.FintypeCat
 
 #align_import topology.category.Profinite.basic from "leanprover-community/mathlib"@"ef55335933293309ff8c0b1d20ffffeecbe5c39f"
 

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

@@ -409,9 +409,9 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
       rw [if_neg]; · rfl
       refine' mt (fun α => hVU α) _
       simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
-    apply_fun fun e => (e y).down at H 
-    dsimp [LocallyConstant.ofIsClopen] at H 
-    rw [if_pos hyV] at H 
+    apply_fun fun e => (e y).down at H
+    dsimp [LocallyConstant.ofIsClopen] at H
+    rw [if_pos hyV] at H
     exact top_ne_bot H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget Profinite).epi_of_epi_map

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

@@ -400,6 +400,19 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
     have hUy : U ∈ 𝓝 y := hC.compl_mem_nhds hyU
     obtain ⟨V, hV, hyV, hVU⟩ := is_topological_basis_clopen.mem_nhds_iff.mp hUy
     classical
+    let Z := of (ULift.{u} <| Fin 2)
+    let g : Y ⟶ Z := ⟨(LocallyConstant.ofIsClopen hV).map ULift.up, LocallyConstant.continuous _⟩
+    let h : Y ⟶ Z := ⟨fun _ => ⟨1⟩, continuous_const⟩
+    have H : h = g := by
+      rw [← cancel_epi f]
+      ext x; dsimp [LocallyConstant.ofIsClopen]
+      rw [if_neg]; · rfl
+      refine' mt (fun α => hVU α) _
+      simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
+    apply_fun fun e => (e y).down at H 
+    dsimp [LocallyConstant.ofIsClopen] at H 
+    rw [if_pos hyV] at H 
+    exact top_ne_bot H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget Profinite).epi_of_epi_map
 #align Profinite.epi_iff_surjective Profinite.epi_iff_surjective

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

@@ -400,19 +400,6 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
     have hUy : U ∈ 𝓝 y := hC.compl_mem_nhds hyU
     obtain ⟨V, hV, hyV, hVU⟩ := is_topological_basis_clopen.mem_nhds_iff.mp hUy
     classical
-    let Z := of (ULift.{u} <| Fin 2)
-    let g : Y ⟶ Z := ⟨(LocallyConstant.ofIsClopen hV).map ULift.up, LocallyConstant.continuous _⟩
-    let h : Y ⟶ Z := ⟨fun _ => ⟨1⟩, continuous_const⟩
-    have H : h = g := by
-      rw [← cancel_epi f]
-      ext x; dsimp [LocallyConstant.ofIsClopen]
-      rw [if_neg]; · rfl
-      refine' mt (fun α => hVU α) _
-      simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
-    apply_fun fun e => (e y).down at H 
-    dsimp [LocallyConstant.ofIsClopen] at H 
-    rw [if_pos hyV] at H 
-    exact top_ne_bot H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget Profinite).epi_of_epi_map
 #align Profinite.epi_iff_surjective Profinite.epi_iff_surjective

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

@@ -401,16 +401,16 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
     obtain ⟨V, hV, hyV, hVU⟩ := is_topological_basis_clopen.mem_nhds_iff.mp hUy
     classical
     let Z := of (ULift.{u} <| Fin 2)
-    let g : Y ⟶ Z := ⟨(LocallyConstant.ofClopen hV).map ULift.up, LocallyConstant.continuous _⟩
+    let g : Y ⟶ Z := ⟨(LocallyConstant.ofIsClopen hV).map ULift.up, LocallyConstant.continuous _⟩
     let h : Y ⟶ Z := ⟨fun _ => ⟨1⟩, continuous_const⟩
     have H : h = g := by
       rw [← cancel_epi f]
-      ext x; dsimp [LocallyConstant.ofClopen]
+      ext x; dsimp [LocallyConstant.ofIsClopen]
       rw [if_neg]; · rfl
       refine' mt (fun α => hVU α) _
       simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
     apply_fun fun e => (e y).down at H 
-    dsimp [LocallyConstant.ofClopen] at H 
+    dsimp [LocallyConstant.ofIsClopen] at H 
     rw [if_pos hyV] at H 
     exact top_ne_bot H
   · rw [← CategoryTheory.epi_iff_surjective]

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

@@ -3,13 +3,13 @@ Copyright (c) 2020 Kevin Buzzard. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kevin Buzzard, Calle Sönne
 -/
-import Mathbin.Topology.Category.CompHaus.Basic
-import Mathbin.Topology.Connected
-import Mathbin.Topology.SubsetProperties
-import Mathbin.Topology.LocallyConstant.Basic
-import Mathbin.CategoryTheory.Adjunction.Reflective
-import Mathbin.CategoryTheory.Monad.Limits
-import Mathbin.CategoryTheory.Fintype
+import Topology.Category.CompHaus.Basic
+import Topology.Connected
+import Topology.SubsetProperties
+import Topology.LocallyConstant.Basic
+import CategoryTheory.Adjunction.Reflective
+import CategoryTheory.Monad.Limits
+import CategoryTheory.Fintype
 
 #align_import topology.category.Profinite.basic from "leanprover-community/mathlib"@"ef55335933293309ff8c0b1d20ffffeecbe5c39f"
 

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

@@ -2,11 +2,6 @@
 Copyright (c) 2020 Kevin Buzzard. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kevin Buzzard, Calle Sönne
-
-! This file was ported from Lean 3 source module topology.category.Profinite.basic
-! leanprover-community/mathlib commit ef55335933293309ff8c0b1d20ffffeecbe5c39f
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.Category.CompHaus.Basic
 import Mathbin.Topology.Connected
@@ -16,6 +11,8 @@ import Mathbin.CategoryTheory.Adjunction.Reflective
 import Mathbin.CategoryTheory.Monad.Limits
 import Mathbin.CategoryTheory.Fintype
 
+#align_import topology.category.Profinite.basic from "leanprover-community/mathlib"@"ef55335933293309ff8c0b1d20ffffeecbe5c39f"
+
 /-!
 # The category of Profinite Types
 

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

@@ -89,9 +89,11 @@ instance concreteCategory : ConcreteCategory Profinite :=
 #align Profinite.concrete_category Profinite.concreteCategory
 -/
 
+#print Profinite.hasForget₂ /-
 instance hasForget₂ : HasForget₂ Profinite TopCat :=
   InducedCategory.hasForget₂ _
 #align Profinite.has_forget₂ Profinite.hasForget₂
+-/
 
 instance : CoeSort Profinite (Type _) :=
   ⟨fun X => X.toCompHaus⟩
@@ -111,15 +113,19 @@ theorem coe_toCompHaus {X : Profinite} : (X.toCompHaus : Type _) = X :=
   rfl
 #align Profinite.coe_to_CompHaus Profinite.coe_toCompHaus
 
+#print Profinite.coe_id /-
 @[simp]
 theorem coe_id (X : Profinite) : (𝟙 X : X → X) = id :=
   rfl
 #align Profinite.coe_id Profinite.coe_id
+-/
 
+#print Profinite.coe_comp /-
 @[simp]
 theorem coe_comp {X Y Z : Profinite} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g : X → Z) = g ∘ f :=
   rfl
 #align Profinite.coe_comp Profinite.coe_comp
+-/
 
 end Profinite
 
@@ -169,6 +175,7 @@ def CompHaus.toProfiniteObj (X : CompHaus.{u}) : Profinite.{u}
 #align CompHaus.to_Profinite_obj CompHaus.toProfiniteObj
 -/
 
+#print Profinite.toCompHausEquivalence /-
 /-- (Implementation) The bijection of homsets to establish the reflective adjunction of Profinite
 spaces in compact Hausdorff spaces.
 -/
@@ -182,6 +189,7 @@ def Profinite.toCompHausEquivalence (X : CompHaus.{u}) (Y : Profinite.{u}) :
   left_inv f := ContinuousMap.ext <| ConnectedComponents.surjective_coe.forall.2 fun a => rfl
   right_inv f := ContinuousMap.ext fun x => rfl
 #align Profinite.to_CompHaus_equivalence Profinite.toCompHausEquivalence
+-/
 
 #print CompHaus.toProfinite /-
 /-- The connected_components functor from compact Hausdorff spaces to profinite spaces,
@@ -192,10 +200,12 @@ def CompHaus.toProfinite : CompHaus ⥤ Profinite :=
 #align CompHaus.to_Profinite CompHaus.toProfinite
 -/
 
+#print CompHaus.toProfinite_obj' /-
 theorem CompHaus.toProfinite_obj' (X : CompHaus) :
     ↥(CompHaus.toProfinite.obj X) = ConnectedComponents X :=
   rfl
 #align CompHaus.to_Profinite_obj' CompHaus.toProfinite_obj'
+-/
 
 #print FintypeCat.botTopology /-
 /-- Finite types are given the discrete topology. -/
@@ -313,22 +323,28 @@ noncomputable instance forgetPreservesLimits : Limits.PreservesLimits (forget Pr
 
 variable {X Y : Profinite.{u}} (f : X ⟶ Y)
 
+#print Profinite.isClosedMap /-
 /-- Any morphism of profinite spaces is a closed map. -/
 theorem isClosedMap : IsClosedMap f :=
   CompHaus.isClosedMap _
 #align Profinite.is_closed_map Profinite.isClosedMap
+-/
 
+#print Profinite.isIso_of_bijective /-
 /-- Any continuous bijection of profinite spaces induces an isomorphism. -/
 theorem isIso_of_bijective (bij : Function.Bijective f) : IsIso f :=
   haveI := CompHaus.isIso_of_bijective (Profinite_to_CompHaus.map f) bij
   is_iso_of_fully_faithful profiniteToCompHaus _
 #align Profinite.is_iso_of_bijective Profinite.isIso_of_bijective
+-/
 
+#print Profinite.isoOfBijective /-
 /-- Any continuous bijection of profinite spaces induces an isomorphism. -/
 noncomputable def isoOfBijective (bij : Function.Bijective f) : X ≅ Y :=
   letI := Profinite.isIso_of_bijective f bij
   as_iso f
 #align Profinite.iso_of_bijective Profinite.isoOfBijective
+-/
 
 #print Profinite.forget_reflectsIsomorphisms /-
 instance forget_reflectsIsomorphisms : ReflectsIsomorphisms (forget Profinite) :=
@@ -374,6 +390,7 @@ def isoEquivHomeo : (X ≅ Y) ≃ (X ≃ₜ Y)
 #align Profinite.iso_equiv_homeo Profinite.isoEquivHomeo
 -/
 
+#print Profinite.epi_iff_surjective /-
 theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f :=
   by
   constructor
@@ -402,7 +419,9 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget Profinite).epi_of_epi_map
 #align Profinite.epi_iff_surjective Profinite.epi_iff_surjective
+-/
 
+#print Profinite.mono_iff_injective /-
 theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f :=
   by
   constructor
@@ -413,6 +432,7 @@ theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Func
   · rw [← CategoryTheory.mono_iff_injective]
     apply (forget Profinite).mono_of_mono_map
 #align Profinite.mono_iff_injective Profinite.mono_iff_injective
+-/
 
 end Profinite
 

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

@@ -89,11 +89,9 @@ instance concreteCategory : ConcreteCategory Profinite :=
 #align Profinite.concrete_category Profinite.concreteCategory
 -/
 
-#print Profinite.hasForget₂ /-
 instance hasForget₂ : HasForget₂ Profinite TopCat :=
   InducedCategory.hasForget₂ _
 #align Profinite.has_forget₂ Profinite.hasForget₂
--/
 
 instance : CoeSort Profinite (Type _) :=
   ⟨fun X => X.toCompHaus⟩

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

@@ -245,7 +245,7 @@ def limitCone {J : Type u} [SmallCategory J] (F : J ⥤ Profinite.{u}) : Limits.
     { toCompHaus := (CompHaus.limitCone.{u, u} (F ⋙ profiniteToCompHaus)).pt
       IsTotallyDisconnected :=
         by
-        change TotallyDisconnectedSpace ↥{ u : ∀ j : J, F.obj j | _ }
+        change TotallyDisconnectedSpace ↥{u : ∀ j : J, F.obj j | _}
         exact Subtype.totallyDisconnectedSpace }
   π := { app := (CompHaus.limitCone.{u, u} (F ⋙ profiniteToCompHaus)).π.app }
 #align Profinite.limit_cone Profinite.limitCone
@@ -297,13 +297,13 @@ noncomputable instance toTopCat.createsLimits : CreatesLimits Profinite.toTopCat
 
 #print Profinite.hasLimits /-
 instance hasLimits : Limits.HasLimits Profinite :=
-  has_limits_of_has_limits_creates_limits Profinite.toTopCat
+  hasLimits_of_hasLimits_createsLimits Profinite.toTopCat
 #align Profinite.has_limits Profinite.hasLimits
 -/
 
 #print Profinite.hasColimits /-
 instance hasColimits : Limits.HasColimits Profinite :=
-  has_colimits_of_reflective profiniteToCompHaus
+  hasColimits_of_reflective profiniteToCompHaus
 #align Profinite.has_colimits Profinite.hasColimits
 -/
 
@@ -388,19 +388,19 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
     have hUy : U ∈ 𝓝 y := hC.compl_mem_nhds hyU
     obtain ⟨V, hV, hyV, hVU⟩ := is_topological_basis_clopen.mem_nhds_iff.mp hUy
     classical
-      let Z := of (ULift.{u} <| Fin 2)
-      let g : Y ⟶ Z := ⟨(LocallyConstant.ofClopen hV).map ULift.up, LocallyConstant.continuous _⟩
-      let h : Y ⟶ Z := ⟨fun _ => ⟨1⟩, continuous_const⟩
-      have H : h = g := by
-        rw [← cancel_epi f]
-        ext x; dsimp [LocallyConstant.ofClopen]
-        rw [if_neg]; · rfl
-        refine' mt (fun α => hVU α) _
-        simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
-      apply_fun fun e => (e y).down  at H 
-      dsimp [LocallyConstant.ofClopen] at H 
-      rw [if_pos hyV] at H 
-      exact top_ne_bot H
+    let Z := of (ULift.{u} <| Fin 2)
+    let g : Y ⟶ Z := ⟨(LocallyConstant.ofClopen hV).map ULift.up, LocallyConstant.continuous _⟩
+    let h : Y ⟶ Z := ⟨fun _ => ⟨1⟩, continuous_const⟩
+    have H : h = g := by
+      rw [← cancel_epi f]
+      ext x; dsimp [LocallyConstant.ofClopen]
+      rw [if_neg]; · rfl
+      refine' mt (fun α => hVU α) _
+      simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
+    apply_fun fun e => (e y).down at H 
+    dsimp [LocallyConstant.ofClopen] at H 
+    rw [if_pos hyV] at H 
+    exact top_ne_bot H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget Profinite).epi_of_epi_map
 #align Profinite.epi_iff_surjective Profinite.epi_iff_surjective

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

@@ -129,7 +129,8 @@ end Profinite
 /-- The fully faithful embedding of `Profinite` in `CompHaus`. -/
 @[simps]
 def profiniteToCompHaus : Profinite ⥤ CompHaus :=
-  inducedFunctor _ deriving Full, Faithful
+  inducedFunctor _
+deriving Full, Faithful
 #align Profinite_to_CompHaus profiniteToCompHaus
 -/
 
@@ -138,7 +139,8 @@ def profiniteToCompHaus : Profinite ⥤ CompHaus :=
 obvious composite. -/
 @[simps]
 def Profinite.toTopCat : Profinite ⥤ TopCat :=
-  forget₂ _ _ deriving Full, Faithful
+  forget₂ _ _
+deriving Full, Faithful
 #align Profinite.to_Top Profinite.toTopCat
 -/
 
@@ -395,9 +397,9 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
         rw [if_neg]; · rfl
         refine' mt (fun α => hVU α) _
         simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
-      apply_fun fun e => (e y).down  at H
-      dsimp [LocallyConstant.ofClopen] at H
-      rw [if_pos hyV] at H
+      apply_fun fun e => (e y).down  at H 
+      dsimp [LocallyConstant.ofClopen] at H 
+      rw [if_pos hyV] at H 
       exact top_ne_bot H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget Profinite).epi_of_epi_map

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

@@ -52,7 +52,7 @@ universe u
 
 open CategoryTheory
 
-open Topology
+open scoped Topology
 
 #print Profinite /-
 /-- The type of profinite topological spaces. -/

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

@@ -113,20 +113,11 @@ theorem coe_toCompHaus {X : Profinite} : (X.toCompHaus : Type _) = X :=
   rfl
 #align Profinite.coe_to_CompHaus Profinite.coe_toCompHaus
 
-/- warning: Profinite.coe_id -> Profinite.coe_id is a dubious translation:
-lean 3 declaration is
-  forall (X : Profinite.{u1}), Eq.{succ u1} ((fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X)))) (CategoryTheory.CategoryStruct.id.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1}) X)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X X) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X)))) (CategoryTheory.CategoryStruct.id.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1}) X)) (id.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))))
-but is expected to have type
-  forall (X : Profinite.{u1}), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X)) (CategoryTheory.CategoryStruct.id.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1}) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X)) (id.{succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X))
-Case conversion may be inaccurate. Consider using '#align Profinite.coe_id Profinite.coe_idₓ'. -/
 @[simp]
 theorem coe_id (X : Profinite) : (𝟙 X : X → X) = id :=
   rfl
 #align Profinite.coe_id Profinite.coe_id
 
-/- warning: Profinite.coe_comp -> Profinite.coe_comp is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align Profinite.coe_comp Profinite.coe_compₓ'. -/
 @[simp]
 theorem coe_comp {X Y Z : Profinite} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g : X → Z) = g ∘ f :=
   rfl
@@ -178,12 +169,6 @@ def CompHaus.toProfiniteObj (X : CompHaus.{u}) : Profinite.{u}
 #align CompHaus.to_Profinite_obj CompHaus.toProfiniteObj
 -/
 
-/- warning: Profinite.to_CompHaus_equivalence -> Profinite.toCompHausEquivalence is a dubious translation:
-lean 3 declaration is
-  forall (X : CompHaus.{u1}) (Y : Profinite.{u1}), Equiv.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) (CompHaus.toProfiniteObj.{u1} X) Y) (Quiver.Hom.{succ u1, succ u1} CompHaus.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CompHaus.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1})) X (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} CompHaus.{u1} CompHaus.category.{u1} profiniteToCompHaus.{u1} Y))
-but is expected to have type
-  forall (X : CompHaus.{u1}) (Y : Profinite.{u1}), Equiv.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) (CompHaus.toProfiniteObj.{u1} X) Y) (Quiver.Hom.{succ u1, succ u1} CompHaus.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CompHaus.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1})) X (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) CompHaus.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CompHaus.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} CompHaus.{u1} CompHaus.category.{u1} profiniteToCompHaus.{u1}) Y))
-Case conversion may be inaccurate. Consider using '#align Profinite.to_CompHaus_equivalence Profinite.toCompHausEquivalenceₓ'. -/
 /-- (Implementation) The bijection of homsets to establish the reflective adjunction of Profinite
 spaces in compact Hausdorff spaces.
 -/
@@ -207,12 +192,6 @@ def CompHaus.toProfinite : CompHaus ⥤ Profinite :=
 #align CompHaus.to_Profinite CompHaus.toProfinite
 -/
 
-/- warning: CompHaus.to_Profinite_obj' -> CompHaus.toProfinite_obj' is a dubious translation:
-lean 3 declaration is
-  forall (X : CompHaus.{u1}), Eq.{succ (succ u1)} Type.{u1} (coeSort.{succ (succ u1), succ (succ u1)} Profinite.{u1} Type.{u1} Profinite.hasCoeToSort.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} Profinite.{u1} Profinite.category.{u1} CompHaus.toProfinite.{u1} X)) (ConnectedComponents.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CompHaus.{u1} Type.{u1} CompHaus.hasCoeToSort.{u1} X) (TopCat.topologicalSpace.{u1} (CompHaus.toTop.{u1} X)))
-but is expected to have type
-  forall (X : CompHaus.{u1}), Eq.{succ (succ u1)} Type.{u1} (CategoryTheory.Bundled.α.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} CompHaus.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CompHaus.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1})) Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} Profinite.{u1} Profinite.category.{u1} CompHaus.toProfinite.{u1}) X)))) (ConnectedComponents.{u1} (CategoryTheory.Bundled.α.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (TopCat.topologicalSpace_coe.{u1} (CompHaus.toTop.{u1} X)))
-Case conversion may be inaccurate. Consider using '#align CompHaus.to_Profinite_obj' CompHaus.toProfinite_obj'ₓ'. -/
 theorem CompHaus.toProfinite_obj' (X : CompHaus) :
     ↥(CompHaus.toProfinite.obj X) = ConnectedComponents X :=
   rfl
@@ -334,35 +313,17 @@ noncomputable instance forgetPreservesLimits : Limits.PreservesLimits (forget Pr
 
 variable {X Y : Profinite.{u}} (f : X ⟶ Y)
 
-/- warning: Profinite.is_closed_map -> Profinite.isClosedMap is a dubious translation:
-lean 3 declaration is
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), IsClosedMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (TopCat.topologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (TopCat.topologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f)
-but is expected to have type
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), IsClosedMap.{u1, u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Profinite.instTopologicalSpaceObjProfiniteToQuiverToCategoryStructCategoryTypeTypesToPrefunctorForgetConcreteCategory.{u1} X) (Profinite.instTopologicalSpaceObjProfiniteToQuiverToCategoryStructCategoryTypeTypesToPrefunctorForgetConcreteCategory.{u1} Y) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f)
-Case conversion may be inaccurate. Consider using '#align Profinite.is_closed_map Profinite.isClosedMapₓ'. -/
 /-- Any morphism of profinite spaces is a closed map. -/
 theorem isClosedMap : IsClosedMap f :=
   CompHaus.isClosedMap _
 #align Profinite.is_closed_map Profinite.isClosedMap
 
-/- warning: Profinite.is_iso_of_bijective -> Profinite.isIso_of_bijective is a dubious translation:
-lean 3 declaration is
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), (Function.Bijective.{succ u1, succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f)) -> (CategoryTheory.IsIso.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f)
-but is expected to have type
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), (Function.Bijective.{succ u1, succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f)) -> (CategoryTheory.IsIso.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f)
-Case conversion may be inaccurate. Consider using '#align Profinite.is_iso_of_bijective Profinite.isIso_of_bijectiveₓ'. -/
 /-- Any continuous bijection of profinite spaces induces an isomorphism. -/
 theorem isIso_of_bijective (bij : Function.Bijective f) : IsIso f :=
   haveI := CompHaus.isIso_of_bijective (Profinite_to_CompHaus.map f) bij
   is_iso_of_fully_faithful profiniteToCompHaus _
 #align Profinite.is_iso_of_bijective Profinite.isIso_of_bijective
 
-/- warning: Profinite.iso_of_bijective -> Profinite.isoOfBijective is a dubious translation:
-lean 3 declaration is
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), (Function.Bijective.{succ u1, succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f)) -> (CategoryTheory.Iso.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y)
-but is expected to have type
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), (Function.Bijective.{succ u1, succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f)) -> (CategoryTheory.Iso.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y)
-Case conversion may be inaccurate. Consider using '#align Profinite.iso_of_bijective Profinite.isoOfBijectiveₓ'. -/
 /-- Any continuous bijection of profinite spaces induces an isomorphism. -/
 noncomputable def isoOfBijective (bij : Function.Bijective f) : X ≅ Y :=
   letI := Profinite.isIso_of_bijective f bij
@@ -413,12 +374,6 @@ def isoEquivHomeo : (X ≅ Y) ≃ (X ≃ₜ Y)
 #align Profinite.iso_equiv_homeo Profinite.isoEquivHomeo
 -/
 
-/- warning: Profinite.epi_iff_surjective -> Profinite.epi_iff_surjective is a dubious translation:
-lean 3 declaration is
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), Iff (CategoryTheory.Epi.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f) (Function.Surjective.{succ u1, succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f))
-but is expected to have type
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), Iff (CategoryTheory.Epi.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f) (Function.Surjective.{succ u1, succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f))
-Case conversion may be inaccurate. Consider using '#align Profinite.epi_iff_surjective Profinite.epi_iff_surjectiveₓ'. -/
 theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f :=
   by
   constructor
@@ -448,12 +403,6 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
     apply (forget Profinite).epi_of_epi_map
 #align Profinite.epi_iff_surjective Profinite.epi_iff_surjective
 
-/- warning: Profinite.mono_iff_injective -> Profinite.mono_iff_injective is a dubious translation:
-lean 3 declaration is
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), Iff (CategoryTheory.Mono.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f) (Function.Injective.{succ u1, succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f))
-but is expected to have type
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), Iff (CategoryTheory.Mono.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f) (Function.Injective.{succ u1, succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f))
-Case conversion may be inaccurate. Consider using '#align Profinite.mono_iff_injective Profinite.mono_iff_injectiveₓ'. -/
 theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f :=
   by
   constructor

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

@@ -382,12 +382,8 @@ def isoOfHomeo (f : X ≃ₜ Y) : X ≅ Y
     where
   Hom := ⟨f, f.Continuous⟩
   inv := ⟨f.symm, f.symm.Continuous⟩
-  hom_inv_id' := by
-    ext x
-    exact f.symm_apply_apply x
-  inv_hom_id' := by
-    ext x
-    exact f.apply_symm_apply x
+  hom_inv_id' := by ext x; exact f.symm_apply_apply x
+  inv_hom_id' := by ext x; exact f.apply_symm_apply x
 #align Profinite.iso_of_homeo Profinite.isoOfHomeo
 -/
 
@@ -397,12 +393,8 @@ def isoOfHomeo (f : X ≃ₜ Y) : X ≅ Y
 def homeoOfIso (f : X ≅ Y) : X ≃ₜ Y where
   toFun := f.Hom
   invFun := f.inv
-  left_inv x := by
-    change (f.hom ≫ f.inv) x = x
-    rw [iso.hom_inv_id, coe_id, id.def]
-  right_inv x := by
-    change (f.inv ≫ f.hom) x = x
-    rw [iso.inv_hom_id, coe_id, id.def]
+  left_inv x := by change (f.hom ≫ f.inv) x = x; rw [iso.hom_inv_id, coe_id, id.def]
+  right_inv x := by change (f.inv ≫ f.hom) x = x; rw [iso.inv_hom_id, coe_id, id.def]
   continuous_toFun := f.Hom.Continuous
   continuous_invFun := f.inv.Continuous
 #align Profinite.homeo_of_iso Profinite.homeoOfIso
@@ -416,12 +408,8 @@ def isoEquivHomeo : (X ≅ Y) ≃ (X ≃ₜ Y)
     where
   toFun := homeoOfIso
   invFun := isoOfHomeo
-  left_inv f := by
-    ext
-    rfl
-  right_inv f := by
-    ext
-    rfl
+  left_inv f := by ext; rfl
+  right_inv f := by ext; rfl
 #align Profinite.iso_equiv_homeo Profinite.isoEquivHomeo
 -/
 
@@ -435,15 +423,11 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
   by
   constructor
   · contrapose!
-    rintro ⟨y, hy⟩ hf
-    skip
+    rintro ⟨y, hy⟩ hf; skip
     let C := Set.range f
     have hC : IsClosed C := (isCompact_range f.continuous).IsClosed
     let U := Cᶜ
-    have hyU : y ∈ U := by
-      refine' Set.mem_compl _
-      rintro ⟨y', hy'⟩
-      exact hy y' hy'
+    have hyU : y ∈ U := by refine' Set.mem_compl _; rintro ⟨y', hy'⟩; exact hy y' hy'
     have hUy : U ∈ 𝓝 y := hC.compl_mem_nhds hyU
     obtain ⟨V, hV, hyV, hVU⟩ := is_topological_basis_clopen.mem_nhds_iff.mp hUy
     classical
@@ -452,10 +436,8 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
       let h : Y ⟶ Z := ⟨fun _ => ⟨1⟩, continuous_const⟩
       have H : h = g := by
         rw [← cancel_epi f]
-        ext x
-        dsimp [LocallyConstant.ofClopen]
-        rw [if_neg]
-        · rfl
+        ext x; dsimp [LocallyConstant.ofClopen]
+        rw [if_neg]; · rfl
         refine' mt (fun α => hVU α) _
         simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
       apply_fun fun e => (e y).down  at H

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

@@ -125,10 +125,7 @@ theorem coe_id (X : Profinite) : (𝟙 X : X → X) = id :=
 #align Profinite.coe_id Profinite.coe_id
 
 /- warning: Profinite.coe_comp -> Profinite.coe_comp is a dubious translation:
-lean 3 declaration is
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} {Z : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (g : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Y Z), Eq.{succ u1} ((fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1}) X Y Z f g)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Z) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1}) X Y Z f g)) (Function.comp.{succ u1, succ u1, succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Y Z) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) g) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f))
-but is expected to have type
-  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} {Z : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (g : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Y Z), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Z)) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1}) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Z) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y Z g)) (Function.comp.{succ u1, succ u1, succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Z) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y Z g) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f))
+<too large>
 Case conversion may be inaccurate. Consider using '#align Profinite.coe_comp Profinite.coe_compₓ'. -/
 @[simp]
 theorem coe_comp {X Y Z : Profinite} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g : X → Z) = g ∘ f :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/36b8aa61ea7c05727161f96a0532897bd72aedab

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kevin Buzzard, Calle Sönne
 
 ! This file was ported from Lean 3 source module topology.category.Profinite.basic
-! leanprover-community/mathlib commit bcfa726826abd57587355b4b5b7e78ad6527b7e4
+! leanprover-community/mathlib commit ef55335933293309ff8c0b1d20ffffeecbe5c39f
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -19,6 +19,9 @@ import Mathbin.CategoryTheory.Fintype
 /-!
 # The category of Profinite Types
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We construct the category of profinite topological spaces,
 often called profinite sets -- perhaps they could be called
 profinite types in Lean.

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

@@ -51,14 +51,17 @@ open CategoryTheory
 
 open Topology
 
+#print Profinite /-
 /-- The type of profinite topological spaces. -/
 structure Profinite where
   toCompHaus : CompHaus
   [IsTotallyDisconnected : TotallyDisconnectedSpace to_CompHaus]
 #align Profinite Profinite
+-/
 
 namespace Profinite
 
+#print Profinite.of /-
 /-- Construct a term of `Profinite` from a type endowed with the structure of a
 compact, Hausdorff and totally disconnected topological space.
 -/
@@ -66,21 +69,28 @@ def of (X : Type _) [TopologicalSpace X] [CompactSpace X] [T2Space X] [TotallyDi
     Profinite :=
   ⟨⟨⟨X⟩⟩⟩
 #align Profinite.of Profinite.of
+-/
 
 instance : Inhabited Profinite :=
   ⟨Profinite.of PEmpty⟩
 
+#print Profinite.category /-
 instance category : Category Profinite :=
   InducedCategory.category toCompHaus
 #align Profinite.category Profinite.category
+-/
 
+#print Profinite.concreteCategory /-
 instance concreteCategory : ConcreteCategory Profinite :=
   InducedCategory.concreteCategory _
 #align Profinite.concrete_category Profinite.concreteCategory
+-/
 
+#print Profinite.hasForget₂ /-
 instance hasForget₂ : HasForget₂ Profinite TopCat :=
   InducedCategory.hasForget₂ _
 #align Profinite.has_forget₂ Profinite.hasForget₂
+-/
 
 instance : CoeSort Profinite (Type _) :=
   ⟨fun X => X.toCompHaus⟩
@@ -100,11 +110,23 @@ theorem coe_toCompHaus {X : Profinite} : (X.toCompHaus : Type _) = X :=
   rfl
 #align Profinite.coe_to_CompHaus Profinite.coe_toCompHaus
 
+/- warning: Profinite.coe_id -> Profinite.coe_id is a dubious translation:
+lean 3 declaration is
+  forall (X : Profinite.{u1}), Eq.{succ u1} ((fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X)))) (CategoryTheory.CategoryStruct.id.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1}) X)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X X) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X)))) (CategoryTheory.CategoryStruct.id.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1}) X)) (id.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))))
+but is expected to have type
+  forall (X : Profinite.{u1}), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X)) (CategoryTheory.CategoryStruct.id.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1}) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X)) (id.{succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X))
+Case conversion may be inaccurate. Consider using '#align Profinite.coe_id Profinite.coe_idₓ'. -/
 @[simp]
 theorem coe_id (X : Profinite) : (𝟙 X : X → X) = id :=
   rfl
 #align Profinite.coe_id Profinite.coe_id
 
+/- warning: Profinite.coe_comp -> Profinite.coe_comp is a dubious translation:
+lean 3 declaration is
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} {Z : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (g : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Y Z), Eq.{succ u1} ((fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1}) X Y Z f g)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Z) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1}) X Y Z f g)) (Function.comp.{succ u1, succ u1, succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Y Z) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Z)))) g) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f))
+but is expected to have type
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} {Z : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (g : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Y Z), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Z)) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1}) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Z) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y Z g)) (Function.comp.{succ u1, succ u1, succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Z) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y Z g) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f))
+Case conversion may be inaccurate. Consider using '#align Profinite.coe_comp Profinite.coe_compₓ'. -/
 @[simp]
 theorem coe_comp {X Y Z : Profinite} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g : X → Z) = g ∘ f :=
   rfl
@@ -112,26 +134,33 @@ theorem coe_comp {X Y Z : Profinite} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g : X
 
 end Profinite
 
+#print profiniteToCompHaus /-
 /-- The fully faithful embedding of `Profinite` in `CompHaus`. -/
 @[simps]
 def profiniteToCompHaus : Profinite ⥤ CompHaus :=
   inducedFunctor _ deriving Full, Faithful
 #align Profinite_to_CompHaus profiniteToCompHaus
+-/
 
+#print Profinite.toTopCat /-
 /-- The fully faithful embedding of `Profinite` in `Top`. This is definitionally the same as the
 obvious composite. -/
 @[simps]
-def Profinite.toTop : Profinite ⥤ TopCat :=
+def Profinite.toTopCat : Profinite ⥤ TopCat :=
   forget₂ _ _ deriving Full, Faithful
-#align Profinite.to_Top Profinite.toTop
+#align Profinite.to_Top Profinite.toTopCat
+-/
 
+#print Profinite.to_compHausToTopCat /-
 @[simp]
-theorem Profinite.to_compHausToTop : profiniteToCompHaus ⋙ compHausToTop = Profinite.toTop :=
+theorem Profinite.to_compHausToTopCat : profiniteToCompHaus ⋙ compHausToTop = Profinite.toTopCat :=
   rfl
-#align Profinite.to_CompHaus_to_Top Profinite.to_compHausToTop
+#align Profinite.to_CompHaus_to_Top Profinite.to_compHausToTopCat
+-/
 
 section Profinite
 
+#print CompHaus.toProfiniteObj /-
 -- Without explicit universe annotations here, Lean introduces two universe variables and
 -- unhelpfully defines a function `CompHaus.{max u₁ u₂} → Profinite.{max u₁ u₂}`.
 /--
@@ -147,7 +176,14 @@ def CompHaus.toProfiniteObj (X : CompHaus.{u}) : Profinite.{u}
       is_hausdorff := ConnectedComponents.t2 }
   IsTotallyDisconnected := ConnectedComponents.totallyDisconnectedSpace
 #align CompHaus.to_Profinite_obj CompHaus.toProfiniteObj
+-/
 
+/- warning: Profinite.to_CompHaus_equivalence -> Profinite.toCompHausEquivalence is a dubious translation:
+lean 3 declaration is
+  forall (X : CompHaus.{u1}) (Y : Profinite.{u1}), Equiv.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) (CompHaus.toProfiniteObj.{u1} X) Y) (Quiver.Hom.{succ u1, succ u1} CompHaus.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CompHaus.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1})) X (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} CompHaus.{u1} CompHaus.category.{u1} profiniteToCompHaus.{u1} Y))
+but is expected to have type
+  forall (X : CompHaus.{u1}) (Y : Profinite.{u1}), Equiv.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) (CompHaus.toProfiniteObj.{u1} X) Y) (Quiver.Hom.{succ u1, succ u1} CompHaus.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CompHaus.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1})) X (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) CompHaus.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CompHaus.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} CompHaus.{u1} CompHaus.category.{u1} profiniteToCompHaus.{u1}) Y))
+Case conversion may be inaccurate. Consider using '#align Profinite.to_CompHaus_equivalence Profinite.toCompHausEquivalenceₓ'. -/
 /-- (Implementation) The bijection of homsets to establish the reflective adjunction of Profinite
 spaces in compact Hausdorff spaces.
 -/
@@ -162,32 +198,45 @@ def Profinite.toCompHausEquivalence (X : CompHaus.{u}) (Y : Profinite.{u}) :
   right_inv f := ContinuousMap.ext fun x => rfl
 #align Profinite.to_CompHaus_equivalence Profinite.toCompHausEquivalence
 
+#print CompHaus.toProfinite /-
 /-- The connected_components functor from compact Hausdorff spaces to profinite spaces,
 left adjoint to the inclusion functor.
 -/
 def CompHaus.toProfinite : CompHaus ⥤ Profinite :=
   Adjunction.leftAdjointOfEquiv Profinite.toCompHausEquivalence fun _ _ _ _ _ => rfl
 #align CompHaus.to_Profinite CompHaus.toProfinite
+-/
 
+/- warning: CompHaus.to_Profinite_obj' -> CompHaus.toProfinite_obj' is a dubious translation:
+lean 3 declaration is
+  forall (X : CompHaus.{u1}), Eq.{succ (succ u1)} Type.{u1} (coeSort.{succ (succ u1), succ (succ u1)} Profinite.{u1} Type.{u1} Profinite.hasCoeToSort.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} Profinite.{u1} Profinite.category.{u1} CompHaus.toProfinite.{u1} X)) (ConnectedComponents.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CompHaus.{u1} Type.{u1} CompHaus.hasCoeToSort.{u1} X) (TopCat.topologicalSpace.{u1} (CompHaus.toTop.{u1} X)))
+but is expected to have type
+  forall (X : CompHaus.{u1}), Eq.{succ (succ u1)} Type.{u1} (CategoryTheory.Bundled.α.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} CompHaus.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CompHaus.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1})) Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} Profinite.{u1} Profinite.category.{u1} CompHaus.toProfinite.{u1}) X)))) (ConnectedComponents.{u1} (CategoryTheory.Bundled.α.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (TopCat.topologicalSpace_coe.{u1} (CompHaus.toTop.{u1} X)))
+Case conversion may be inaccurate. Consider using '#align CompHaus.to_Profinite_obj' CompHaus.toProfinite_obj'ₓ'. -/
 theorem CompHaus.toProfinite_obj' (X : CompHaus) :
     ↥(CompHaus.toProfinite.obj X) = ConnectedComponents X :=
   rfl
 #align CompHaus.to_Profinite_obj' CompHaus.toProfinite_obj'
 
+#print FintypeCat.botTopology /-
 /-- Finite types are given the discrete topology. -/
 def FintypeCat.botTopology (A : FintypeCat) : TopologicalSpace A :=
   ⊥
 #align Fintype.bot_topology FintypeCat.botTopology
+-/
 
 section DiscreteTopology
 
 attribute [local instance] FintypeCat.botTopology
 
+#print FintypeCat.discreteTopology /-
 @[local instance]
 theorem FintypeCat.discreteTopology (A : FintypeCat) : DiscreteTopology A :=
   ⟨rfl⟩
 #align Fintype.discrete_topology FintypeCat.discreteTopology
+-/
 
+#print FintypeCat.toProfinite /-
 /-- The natural functor from `Fintype` to `Profinite`, endowing a finite type with the
 discrete topology. -/
 @[simps]
@@ -196,6 +245,7 @@ def FintypeCat.toProfinite : FintypeCat ⥤ Profinite
   obj A := Profinite.of A
   map _ _ f := ⟨f⟩
 #align Fintype.to_Profinite FintypeCat.toProfinite
+-/
 
 end DiscreteTopology
 
@@ -203,6 +253,7 @@ end Profinite
 
 namespace Profinite
 
+#print Profinite.limitCone /-
 -- TODO the following construction of limits could be generalised
 -- to allow diagrams in lower universes.
 /-- An explicit limit cone for a functor `F : J ⥤ Profinite`, defined in terms of
@@ -217,7 +268,9 @@ def limitCone {J : Type u} [SmallCategory J] (F : J ⥤ Profinite.{u}) : Limits.
         exact Subtype.totallyDisconnectedSpace }
   π := { app := (CompHaus.limitCone.{u, u} (F ⋙ profiniteToCompHaus)).π.app }
 #align Profinite.limit_cone Profinite.limitCone
+-/
 
+#print Profinite.limitConeIsLimit /-
 /-- The limit cone `Profinite.limit_cone F` is indeed a limit cone. -/
 def limitConeIsLimit {J : Type u} [SmallCategory J] (F : J ⥤ Profinite.{u}) :
     Limits.IsLimit (limitCone F)
@@ -227,64 +280,102 @@ def limitConeIsLimit {J : Type u} [SmallCategory J] (F : J ⥤ Profinite.{u}) :
       (profiniteToCompHaus.mapCone S)
   uniq S m h := (CompHaus.limitConeIsLimit.{u, u} _).uniq (profiniteToCompHaus.mapCone S) _ h
 #align Profinite.limit_cone_is_limit Profinite.limitConeIsLimit
+-/
 
+#print Profinite.toProfiniteAdjToCompHaus /-
 /-- The adjunction between CompHaus.to_Profinite and Profinite.to_CompHaus -/
 def toProfiniteAdjToCompHaus : CompHaus.toProfinite ⊣ profiniteToCompHaus :=
   Adjunction.adjunctionOfEquivLeft _ _
 #align Profinite.to_Profinite_adj_to_CompHaus Profinite.toProfiniteAdjToCompHaus
+-/
 
+#print Profinite.toCompHaus.reflective /-
 /-- The category of profinite sets is reflective in the category of compact hausdroff spaces -/
 instance toCompHaus.reflective : Reflective profiniteToCompHaus
     where toIsRightAdjoint := ⟨CompHaus.toProfinite, Profinite.toProfiniteAdjToCompHaus⟩
 #align Profinite.to_CompHaus.reflective Profinite.toCompHaus.reflective
+-/
 
+#print Profinite.toCompHaus.createsLimits /-
 noncomputable instance toCompHaus.createsLimits : CreatesLimits profiniteToCompHaus :=
   monadicCreatesLimits _
 #align Profinite.to_CompHaus.creates_limits Profinite.toCompHaus.createsLimits
+-/
 
-noncomputable instance toTop.reflective : Reflective Profinite.toTop :=
+#print Profinite.toTopCat.reflective /-
+noncomputable instance toTopCat.reflective : Reflective Profinite.toTopCat :=
   Reflective.comp profiniteToCompHaus compHausToTop
-#align Profinite.to_Top.reflective Profinite.toTop.reflective
+#align Profinite.to_Top.reflective Profinite.toTopCat.reflective
+-/
 
-noncomputable instance toTop.createsLimits : CreatesLimits Profinite.toTop :=
+#print Profinite.toTopCat.createsLimits /-
+noncomputable instance toTopCat.createsLimits : CreatesLimits Profinite.toTopCat :=
   monadicCreatesLimits _
-#align Profinite.to_Top.creates_limits Profinite.toTop.createsLimits
+#align Profinite.to_Top.creates_limits Profinite.toTopCat.createsLimits
+-/
 
+#print Profinite.hasLimits /-
 instance hasLimits : Limits.HasLimits Profinite :=
-  has_limits_of_has_limits_creates_limits Profinite.toTop
+  has_limits_of_has_limits_creates_limits Profinite.toTopCat
 #align Profinite.has_limits Profinite.hasLimits
+-/
 
+#print Profinite.hasColimits /-
 instance hasColimits : Limits.HasColimits Profinite :=
   has_colimits_of_reflective profiniteToCompHaus
 #align Profinite.has_colimits Profinite.hasColimits
+-/
 
+#print Profinite.forgetPreservesLimits /-
 noncomputable instance forgetPreservesLimits : Limits.PreservesLimits (forget Profinite) := by
-  apply limits.comp_preserves_limits Profinite.toTop (forget TopCat)
+  apply limits.comp_preserves_limits Profinite.toTopCat (forget TopCat)
 #align Profinite.forget_preserves_limits Profinite.forgetPreservesLimits
+-/
 
 variable {X Y : Profinite.{u}} (f : X ⟶ Y)
 
+/- warning: Profinite.is_closed_map -> Profinite.isClosedMap is a dubious translation:
+lean 3 declaration is
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), IsClosedMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (TopCat.topologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (TopCat.topologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f)
+but is expected to have type
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), IsClosedMap.{u1, u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Profinite.instTopologicalSpaceObjProfiniteToQuiverToCategoryStructCategoryTypeTypesToPrefunctorForgetConcreteCategory.{u1} X) (Profinite.instTopologicalSpaceObjProfiniteToQuiverToCategoryStructCategoryTypeTypesToPrefunctorForgetConcreteCategory.{u1} Y) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f)
+Case conversion may be inaccurate. Consider using '#align Profinite.is_closed_map Profinite.isClosedMapₓ'. -/
 /-- Any morphism of profinite spaces is a closed map. -/
 theorem isClosedMap : IsClosedMap f :=
   CompHaus.isClosedMap _
 #align Profinite.is_closed_map Profinite.isClosedMap
 
+/- warning: Profinite.is_iso_of_bijective -> Profinite.isIso_of_bijective is a dubious translation:
+lean 3 declaration is
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), (Function.Bijective.{succ u1, succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f)) -> (CategoryTheory.IsIso.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f)
+but is expected to have type
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), (Function.Bijective.{succ u1, succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f)) -> (CategoryTheory.IsIso.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f)
+Case conversion may be inaccurate. Consider using '#align Profinite.is_iso_of_bijective Profinite.isIso_of_bijectiveₓ'. -/
 /-- Any continuous bijection of profinite spaces induces an isomorphism. -/
 theorem isIso_of_bijective (bij : Function.Bijective f) : IsIso f :=
   haveI := CompHaus.isIso_of_bijective (Profinite_to_CompHaus.map f) bij
   is_iso_of_fully_faithful profiniteToCompHaus _
 #align Profinite.is_iso_of_bijective Profinite.isIso_of_bijective
 
+/- warning: Profinite.iso_of_bijective -> Profinite.isoOfBijective is a dubious translation:
+lean 3 declaration is
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), (Function.Bijective.{succ u1, succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f)) -> (CategoryTheory.Iso.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y)
+but is expected to have type
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), (Function.Bijective.{succ u1, succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f)) -> (CategoryTheory.Iso.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y)
+Case conversion may be inaccurate. Consider using '#align Profinite.iso_of_bijective Profinite.isoOfBijectiveₓ'. -/
 /-- Any continuous bijection of profinite spaces induces an isomorphism. -/
 noncomputable def isoOfBijective (bij : Function.Bijective f) : X ≅ Y :=
   letI := Profinite.isIso_of_bijective f bij
   as_iso f
 #align Profinite.iso_of_bijective Profinite.isoOfBijective
 
+#print Profinite.forget_reflectsIsomorphisms /-
 instance forget_reflectsIsomorphisms : ReflectsIsomorphisms (forget Profinite) :=
   ⟨by intro A B f hf <;> exact Profinite.isIso_of_bijective _ ((is_iso_iff_bijective f).mp hf)⟩
 #align Profinite.forget_reflects_isomorphisms Profinite.forget_reflectsIsomorphisms
+-/
 
+#print Profinite.isoOfHomeo /-
 /-- Construct an isomorphism from a homeomorphism. -/
 @[simps Hom inv]
 def isoOfHomeo (f : X ≃ₜ Y) : X ≅ Y
@@ -298,7 +389,9 @@ def isoOfHomeo (f : X ≃ₜ Y) : X ≅ Y
     ext x
     exact f.apply_symm_apply x
 #align Profinite.iso_of_homeo Profinite.isoOfHomeo
+-/
 
+#print Profinite.homeoOfIso /-
 /-- Construct a homeomorphism from an isomorphism. -/
 @[simps]
 def homeoOfIso (f : X ≅ Y) : X ≃ₜ Y where
@@ -313,7 +406,9 @@ def homeoOfIso (f : X ≅ Y) : X ≃ₜ Y where
   continuous_toFun := f.Hom.Continuous
   continuous_invFun := f.inv.Continuous
 #align Profinite.homeo_of_iso Profinite.homeoOfIso
+-/
 
+#print Profinite.isoEquivHomeo /-
 /-- The equivalence between isomorphisms in `Profinite` and homeomorphisms
 of topological spaces. -/
 @[simps]
@@ -328,7 +423,14 @@ def isoEquivHomeo : (X ≅ Y) ≃ (X ≃ₜ Y)
     ext
     rfl
 #align Profinite.iso_equiv_homeo Profinite.isoEquivHomeo
+-/
 
+/- warning: Profinite.epi_iff_surjective -> Profinite.epi_iff_surjective is a dubious translation:
+lean 3 declaration is
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), Iff (CategoryTheory.Epi.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f) (Function.Surjective.{succ u1, succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f))
+but is expected to have type
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), Iff (CategoryTheory.Epi.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f) (Function.Surjective.{succ u1, succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f))
+Case conversion may be inaccurate. Consider using '#align Profinite.epi_iff_surjective Profinite.epi_iff_surjectiveₓ'. -/
 theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f :=
   by
   constructor
@@ -364,6 +466,12 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
     apply (forget Profinite).epi_of_epi_map
 #align Profinite.epi_iff_surjective Profinite.epi_iff_surjective
 
+/- warning: Profinite.mono_iff_injective -> Profinite.mono_iff_injective is a dubious translation:
+lean 3 declaration is
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), Iff (CategoryTheory.Mono.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f) (Function.Injective.{succ u1, succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y) (fun (_x : ContinuousMap.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) (ContinuousMap.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} TopologicalSpace.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} TopologicalSpace.{u1}) (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} X))) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Profinite.toCompHaus.{u1} Y)))) f))
+but is expected to have type
+  forall {X : Profinite.{u1}} {Y : Profinite.{u1}} (f : Quiver.Hom.{succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) X Y), Iff (CategoryTheory.Mono.{u1, succ u1} Profinite.{u1} Profinite.category.{u1} X Y f) (Function.Injective.{succ u1, succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X) (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) Y) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} Profinite.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Profinite.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Profinite.{u1} Profinite.category.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} Profinite.{u1} Profinite.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} Profinite.{u1} Profinite.category.{u1} Profinite.concreteCategory.{u1})) X Y f))
+Case conversion may be inaccurate. Consider using '#align Profinite.mono_iff_injective Profinite.mono_iff_injectiveₓ'. -/
 theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f :=
   by
   constructor

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

@@ -209,8 +209,8 @@ namespace Profinite
 `Top.limit_cone`. -/
 def limitCone {J : Type u} [SmallCategory J] (F : J ⥤ Profinite.{u}) : Limits.Cone F
     where
-  x :=
-    { toCompHaus := (CompHaus.limitCone.{u, u} (F ⋙ profiniteToCompHaus)).x
+  pt :=
+    { toCompHaus := (CompHaus.limitCone.{u, u} (F ⋙ profiniteToCompHaus)).pt
       IsTotallyDisconnected :=
         by
         change TotallyDisconnectedSpace ↥{ u : ∀ j : J, F.obj j | _ }

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

@@ -225,7 +225,7 @@ def limitConeIsLimit {J : Type u} [SmallCategory J] (F : J ⥤ Profinite.{u}) :
   lift S :=
     (CompHaus.limitConeIsLimit.{u, u} (F ⋙ profiniteToCompHaus)).lift
       (profiniteToCompHaus.mapCone S)
-  uniq' S m h := (CompHaus.limitConeIsLimit.{u, u} _).uniq (profiniteToCompHaus.mapCone S) _ h
+  uniq S m h := (CompHaus.limitConeIsLimit.{u, u} _).uniq (profiniteToCompHaus.mapCone S) _ h
 #align Profinite.limit_cone_is_limit Profinite.limitConeIsLimit
 
 /-- The adjunction between CompHaus.to_Profinite and Profinite.to_CompHaus -/
@@ -251,11 +251,11 @@ noncomputable instance toTop.createsLimits : CreatesLimits Profinite.toTop :=
 #align Profinite.to_Top.creates_limits Profinite.toTop.createsLimits
 
 instance hasLimits : Limits.HasLimits Profinite :=
-  hasLimitsOfHasLimitsCreatesLimits Profinite.toTop
+  has_limits_of_has_limits_creates_limits Profinite.toTop
 #align Profinite.has_limits Profinite.hasLimits
 
 instance hasColimits : Limits.HasColimits Profinite :=
-  hasColimitsOfReflective profiniteToCompHaus
+  has_colimits_of_reflective profiniteToCompHaus
 #align Profinite.has_colimits Profinite.hasColimits
 
 noncomputable instance forgetPreservesLimits : Limits.PreservesLimits (forget Profinite) := by

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

Before this PR, Functor.Full contained the data of the preimage of maps by a full functor F. This PR makes Functor.Full a proposition. This is to prevent any diamond to appear.

The lemma Functor.image_preimage is also renamed Functor.map_preimage.

Co-authored-by: Joël Riou <37772949+joelriou@users.noreply.github.com>

@@ -240,8 +240,7 @@ instance : FintypeCat.toProfinite.Faithful where
   map_injective h := funext fun _ ↦ (DFunLike.ext_iff.mp h) _
 
 instance : FintypeCat.toProfinite.Full where
-  preimage f := fun x ↦ f x
-  witness _ := rfl
+  map_surjective f := ⟨fun x ↦ f x, rfl⟩
 
 end DiscreteTopology
 

(both to LightProfinite and Profinite)

@@ -236,6 +236,13 @@ def FintypeCat.toProfinite : FintypeCat ⥤ Profinite where
   map f := ⟨f, by continuity⟩
 #align Fintype.to_Profinite FintypeCat.toProfinite
 
+instance : FintypeCat.toProfinite.Faithful where
+  map_injective h := funext fun _ ↦ (DFunLike.ext_iff.mp h) _
+
+instance : FintypeCat.toProfinite.Full where
+  preimage f := fun x ↦ f x
+  witness _ := rfl
+
 end DiscreteTopology
 
 end Profinite

These notions on functors are now Functor.Full, Functor.Faithful, Functor.EssSurj, Functor.IsEquivalence, Functor.ReflectsIsomorphisms. Deprecated aliases are introduced for the previous names.

@@ -141,11 +141,11 @@ def profiniteToCompHaus : Profinite ⥤ CompHaus :=
 -- deriving Full, Faithful
 #align Profinite_to_CompHaus profiniteToCompHaus
 
-instance : Full profiniteToCompHaus :=
-show Full <| inducedFunctor _ from inferInstance
+instance : profiniteToCompHaus.Full :=
+  show (inducedFunctor _).Full from inferInstance
 
-instance : Faithful profiniteToCompHaus :=
-show Faithful <| inducedFunctor _ from inferInstance
+instance : profiniteToCompHaus.Faithful :=
+  show (inducedFunctor _).Faithful from inferInstance
 
 -- Porting note: added, as it is not found otherwise.
 instance {X : Profinite} : TotallyDisconnectedSpace (profiniteToCompHaus.obj X) :=
@@ -160,11 +160,11 @@ def Profinite.toTopCat : Profinite ⥤ TopCat :=
 -- deriving Full, Faithful
 #align Profinite.to_Top Profinite.toTopCat
 
-instance : Full Profinite.toTopCat :=
-show Full <| inducedFunctor _ from inferInstance
+instance : Profinite.toTopCat.Full :=
+  show (inducedFunctor _).Full from inferInstance
 
-instance : Faithful Profinite.toTopCat :=
-show Faithful <| inducedFunctor _ from inferInstance
+instance : Profinite.toTopCat.Faithful :=
+  show (inducedFunctor _).Faithful from inferInstance
 
 @[simp]
 theorem Profinite.to_compHausToTopCat :
@@ -334,7 +334,7 @@ noncomputable def isoOfBijective (bij : Function.Bijective f) : X ≅ Y :=
   asIso f
 #align Profinite.iso_of_bijective Profinite.isoOfBijective
 
-instance forget_reflectsIsomorphisms : ReflectsIsomorphisms (forget Profinite) := by
+instance forget_reflectsIsomorphisms : (forget Profinite).ReflectsIsomorphisms := by
   constructor
   intro A B f hf
   exact Profinite.isIso_of_bijective _ ((isIso_iff_bijective f).mp hf)

More tactics that are not used, found using the linter at #11308.

The PR consists of tactic removals, whitespace changes and replacing a porting note by an explanation.

@@ -370,7 +370,6 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
     dsimp [Function.Surjective]
     contrapose!
     rintro ⟨y, hy⟩ hf
-    skip
     let C := Set.range f
     have hC : IsClosed C := (isCompact_range f.continuous).isClosed
     let U := Cᶜ

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

@@ -388,14 +388,14 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
         rw [← cancel_epi f]
         ext x
         apply ULift.ext
-        dsimp [LocallyConstant.ofIsClopen]
+        dsimp [g, LocallyConstant.ofIsClopen]
         -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
         erw [comp_apply, ContinuousMap.coe_mk, comp_apply, ContinuousMap.coe_mk,
           Function.comp_apply, if_neg]
         refine' mt (fun α => hVU α) _
-        simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
+        simp only [U, C, Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
       apply_fun fun e => (e y).down at H
-      dsimp [LocallyConstant.ofIsClopen] at H
+      dsimp [g, LocallyConstant.ofIsClopen] at H
       -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
       erw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
       exact top_ne_bot H

Classifies by adding issue number (#10688) to porting notes claiming ext/simp lemma was not necessary.

Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr>

@@ -79,7 +79,7 @@ instance hasForget₂ : HasForget₂ Profinite TopCat :=
 instance : CoeSort Profinite (Type*) :=
   ⟨fun X => X.toCompHaus⟩
 
--- Porting note: This lemma was not needed in mathlib3
+-- Porting note (#10688): This lemma was not needed in mathlib3
 @[simp]
 lemma forget_ContinuousMap_mk {X Y : Profinite} (f : X → Y) (hf : Continuous f) :
     (forget Profinite).map (ContinuousMap.mk f hf) = f :=

Mostly, this means replacing "of_open" by "of_isOpen". A few lemmas names were misleading and are corrected differently. Zulip discussion.

@@ -379,7 +379,7 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
       rintro ⟨y', hy'⟩
       exact hy y' hy'
     have hUy : U ∈ 𝓝 y := hC.compl_mem_nhds hyU
-    obtain ⟨V, hV, hyV, hVU⟩ := isTopologicalBasis_clopen.mem_nhds_iff.mp hUy
+    obtain ⟨V, hV, hyV, hVU⟩ := isTopologicalBasis_isClopen.mem_nhds_iff.mp hUy
     classical
       let Z := of (ULift.{u} <| Fin 2)
       let g : Y ⟶ Z := ⟨(LocallyConstant.ofIsClopen hV).map ULift.up, LocallyConstant.continuous _⟩

This PR renames the field Clopens.clopen' -> Clopens.isClopen', and the lemmas

• preimage_closed_of_closed -> ContinuousOn.preimage_isClosed_of_isClosed

as well as: ClopenUpperSet.clopen -> ClopenUpperSet.isClopen connectedComponent_eq_iInter_clopen -> connectedComponent_eq_iInter_isClopen connectedComponent_subset_iInter_clopen -> connectedComponent_subset_iInter_isClopen continuous_boolIndicator_iff_clopen -> continuous_boolIndicator_iff_isClopen continuousOn_boolIndicator_iff_clopen -> continuousOn_boolIndicator_iff_isClopen DiscreteQuotient.ofClopen -> DiscreteQuotient.ofIsClopen disjoint_or_subset_of_clopen -> disjoint_or_subset_of_isClopen exists_clopen_{lower,upper}of_not_le -> exists_isClopen{lower,upper}_of_not_le exists_clopen_of_cofiltered -> exists_isClopen_of_cofiltered exists_clopen_of_totally_separated -> exists_isClopen_of_totally_separated exists_clopen_upper_or_lower_of_ne -> exists_isClopen_upper_or_lower_of_ne IsPreconnected.subset_clopen -> IsPreconnected.subset_isClopen isTotallyDisconnected_of_clopen_set -> isTotallyDisconnected_of_isClopen_set LocallyConstant.ofClopen_fiber_one -> LocallyConstant.ofIsClopen_fiber_one LocallyConstant.ofClopen_fiber_zero -> LocallyConstant.ofIsClopen_fiber_zero LocallyConstant.ofClopen -> LocallyConstant.ofIsClopen preimage_clopen_of_clopen -> preimage_isClopen_of_isClopen TopologicalSpace.Clopens.clopen -> TopologicalSpace.Clopens.isClopen

@@ -382,20 +382,20 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
     obtain ⟨V, hV, hyV, hVU⟩ := isTopologicalBasis_clopen.mem_nhds_iff.mp hUy
     classical
       let Z := of (ULift.{u} <| Fin 2)
-      let g : Y ⟶ Z := ⟨(LocallyConstant.ofClopen hV).map ULift.up, LocallyConstant.continuous _⟩
+      let g : Y ⟶ Z := ⟨(LocallyConstant.ofIsClopen hV).map ULift.up, LocallyConstant.continuous _⟩
       let h : Y ⟶ Z := ⟨fun _ => ⟨1⟩, continuous_const⟩
       have H : h = g := by
         rw [← cancel_epi f]
         ext x
         apply ULift.ext
-        dsimp [LocallyConstant.ofClopen]
+        dsimp [LocallyConstant.ofIsClopen]
         -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
         erw [comp_apply, ContinuousMap.coe_mk, comp_apply, ContinuousMap.coe_mk,
           Function.comp_apply, if_neg]
         refine' mt (fun α => hVU α) _
         simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
       apply_fun fun e => (e y).down at H
-      dsimp [LocallyConstant.ofClopen] at H
+      dsimp [LocallyConstant.ofIsClopen] at H
       -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
       erw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
       exact top_ne_bot H

We allow the indexing category for the cofiltered limit in the result Profinite.exists_locallyConstant to live in a smaller universe than our profinite sets.

@@ -27,9 +27,7 @@ compact, Hausdorff and totally disconnected.
 
 ## TODO
 
-0. Link to category of projective limits of finite discrete sets.
-1. finite coproducts
-2. Clausen/Scholze topology on the category `Profinite`.
+* Define procategories and prove that `Profinite` is equivalent to `Pro (FintypeCat)`.
 
 ## Tags
 
@@ -39,7 +37,7 @@ profinite
 
 set_option linter.uppercaseLean3 false
 
-universe u
+universe v u
 
 open CategoryTheory
 
@@ -242,20 +240,31 @@ end DiscreteTopology
 
 end Profinite
 
+/--
+Many definitions involving universe inequalities in Mathlib are expressed through use of `max u v`.
+Unfortunately, this leads to unbound universes which cannot be solved for during unification, eg
+`max u v =?= max v ?`.
+The current solution is to wrap `Type max u v` in `TypeMax.{u,v}`
+to expose both universe parameters directly.
+
+Similarly, for other concrete categories for which we need to refer to the maximum of two universes
+(e.g. any category for which we are constructing limits), we need an analogous abbreviation.
+-/
+@[nolint checkUnivs]
+abbrev ProfiniteMax.{w, w'} := Profinite.{max w w'}
+
 namespace Profinite
 
--- TODO the following construction of limits could be generalised
--- to allow diagrams in lower universes.
 /-- An explicit limit cone for a functor `F : J ⥤ Profinite`, defined in terms of
 `CompHaus.limitCone`, which is defined in terms of `TopCat.limitCone`. -/
-def limitCone {J : Type u} [SmallCategory J] (F : J ⥤ Profinite.{u}) : Limits.Cone F where
+def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ ProfiniteMax.{v, u}) : Limits.Cone F where
   pt :=
-    { toCompHaus := (CompHaus.limitCone.{u, u} (F ⋙ profiniteToCompHaus)).pt
+    { toCompHaus := (CompHaus.limitCone.{v, u} (F ⋙ profiniteToCompHaus)).pt
       isTotallyDisconnected := by
         change TotallyDisconnectedSpace ({ u : ∀ j : J, F.obj j | _ } : Type _)
         exact Subtype.totallyDisconnectedSpace }
   π :=
-  { app := (CompHaus.limitCone.{u, u} (F ⋙ profiniteToCompHaus)).π.app
+  { app := (CompHaus.limitCone.{v, u} (F ⋙ profiniteToCompHaus)).π.app
     -- Porting note: was `by tidy`:
     naturality := by
       intro j k f
@@ -264,12 +273,12 @@ def limitCone {J : Type u} [SmallCategory J] (F : J ⥤ Profinite.{u}) : Limits.
 #align Profinite.limit_cone Profinite.limitCone
 
 /-- The limit cone `Profinite.limitCone F` is indeed a limit cone. -/
-def limitConeIsLimit {J : Type u} [SmallCategory J] (F : J ⥤ Profinite.{u}) :
+def limitConeIsLimit {J : Type v} [SmallCategory J] (F : J ⥤ ProfiniteMax.{v, u}) :
     Limits.IsLimit (limitCone F) where
   lift S :=
-    (CompHaus.limitConeIsLimit.{u, u} (F ⋙ profiniteToCompHaus)).lift
+    (CompHaus.limitConeIsLimit.{v, u} (F ⋙ profiniteToCompHaus)).lift
       (profiniteToCompHaus.mapCone S)
-  uniq S m h := (CompHaus.limitConeIsLimit.{u, u} _).uniq (profiniteToCompHaus.mapCone S) _ h
+  uniq S m h := (CompHaus.limitConeIsLimit.{v, u} _).uniq (profiniteToCompHaus.mapCone S) _ h
 #align Profinite.limit_cone_is_limit Profinite.limitConeIsLimit
 
 /-- The adjunction between CompHaus.to_Profinite and Profinite.to_CompHaus -/

Only Prop-values fields should be capitalized, not P-valued fields where P is Prop-valued.

Rather than fixing Nonempty := in constructors, I just deleted the line as the instance can almost always be found automatically.

@@ -50,7 +50,7 @@ structure Profinite where
   /-- The underlying compact Hausdorff space of a profinite space. -/
   toCompHaus : CompHaus
   /-- A profinite space is totally disconnected. -/
-  [IsTotallyDisconnected : TotallyDisconnectedSpace toCompHaus]
+  [isTotallyDisconnected : TotallyDisconnectedSpace toCompHaus]
 #align Profinite Profinite
 
 namespace Profinite
@@ -88,7 +88,7 @@ lemma forget_ContinuousMap_mk {X Y : Profinite} (f : X → Y) (hf : Continuous f
   rfl
 
 instance {X : Profinite} : TotallyDisconnectedSpace X :=
-  X.IsTotallyDisconnected
+  X.isTotallyDisconnected
 
 -- We check that we automatically infer that Profinite sets are compact and Hausdorff.
 example {X : Profinite} : CompactSpace X :=
@@ -151,7 +151,7 @@ show Faithful <| inducedFunctor _ from inferInstance
 
 -- Porting note: added, as it is not found otherwise.
 instance {X : Profinite} : TotallyDisconnectedSpace (profiniteToCompHaus.obj X) :=
-  X.IsTotallyDisconnected
+  X.isTotallyDisconnected
 
 /-- The fully faithful embedding of `Profinite` in `TopCat`.
 This is definitionally the same as the obvious composite. -/
@@ -188,7 +188,7 @@ def CompHaus.toProfiniteObj (X : CompHaus.{u}) : Profinite.{u} where
     { toTop := TopCat.of (ConnectedComponents X)
       is_compact := Quotient.compactSpace
       is_hausdorff := ConnectedComponents.t2 }
-  IsTotallyDisconnected := ConnectedComponents.totallyDisconnectedSpace
+  isTotallyDisconnected := ConnectedComponents.totallyDisconnectedSpace
 #align CompHaus.to_Profinite_obj CompHaus.toProfiniteObj
 
 /-- (Implementation) The bijection of homsets to establish the reflective adjunction of Profinite
@@ -251,7 +251,7 @@ namespace Profinite
 def limitCone {J : Type u} [SmallCategory J] (F : J ⥤ Profinite.{u}) : Limits.Cone F where
   pt :=
     { toCompHaus := (CompHaus.limitCone.{u, u} (F ⋙ profiniteToCompHaus)).pt
-      IsTotallyDisconnected := by
+      isTotallyDisconnected := by
         change TotallyDisconnectedSpace ({ u : ∀ j : J, F.obj j | _ } : Type _)
         exact Subtype.totallyDisconnectedSpace }
   π :=

Co-authored-by: Junyan Xu <junyanxu.math@gmail.com>

@@ -411,7 +411,7 @@ theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Func
     erw [← CompHaus.mono_iff_injective]
     assumption
   · rw [← CategoryTheory.mono_iff_injective]
-    apply (forget Profinite).mono_of_mono_map
+    exact (forget Profinite).mono_of_mono_map (f := f)
 #align Profinite.mono_iff_injective Profinite.mono_iff_injective
 
 end Profinite

In the last step, I have removed redundant imports: those which are implied by the other imports. I can revert those changes if desired/if this seems too brittle.

@@ -4,10 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kevin Buzzard, Calle Sönne
 -/
 import Mathlib.Topology.Category.CompHaus.Basic
-import Mathlib.Topology.Connected
 import Mathlib.Topology.LocallyConstant.Basic
-import Mathlib.CategoryTheory.Adjunction.Reflective
-import Mathlib.CategoryTheory.Monad.Limits
 import Mathlib.CategoryTheory.FintypeCat
 
 #align_import topology.category.Profinite.basic from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"

This reverts commit f3695eb2.

@@ -383,30 +383,35 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
         ext x
         apply ULift.ext
         dsimp [LocallyConstant.ofClopen]
-        rw [comp_apply, ContinuousMap.coe_mk, comp_apply, ContinuousMap.coe_mk,
+        -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+        erw [comp_apply, ContinuousMap.coe_mk, comp_apply, ContinuousMap.coe_mk,
           Function.comp_apply, if_neg]
         refine' mt (fun α => hVU α) _
         simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
       apply_fun fun e => (e y).down at H
       dsimp [LocallyConstant.ofClopen] at H
-      rw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
+      -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+      erw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
       exact top_ne_bot H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget Profinite).epi_of_epi_map
 #align Profinite.epi_iff_surjective Profinite.epi_iff_surjective
 
 instance {X Y : Profinite} (f : X ⟶ Y) [Epi f] : @Epi CompHaus _ _ _ f := by
-  rwa [CompHaus.epi_iff_surjective, ← epi_iff_surjective]
+  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+  erw [CompHaus.epi_iff_surjective, ← epi_iff_surjective]; assumption
 
 instance {X Y : Profinite} (f : X ⟶ Y) [@Epi CompHaus _ _ _ f] : Epi f := by
-  rwa [epi_iff_surjective, ← CompHaus.epi_iff_surjective]
+  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+  erw [epi_iff_surjective, ← CompHaus.epi_iff_surjective]; assumption
 
 theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f := by
   constructor
   · intro h
     haveI : Limits.PreservesLimits profiniteToCompHaus := inferInstance
     haveI : Mono (profiniteToCompHaus.map f) := inferInstance
-    rw [← CompHaus.mono_iff_injective]
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [← CompHaus.mono_iff_injective]
     assumption
   · rw [← CategoryTheory.mono_iff_injective]
     apply (forget Profinite).mono_of_mono_map

This reverts commit 26eb2b0a.

@@ -383,35 +383,30 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
         ext x
         apply ULift.ext
         dsimp [LocallyConstant.ofClopen]
-        -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-        erw [comp_apply, ContinuousMap.coe_mk, comp_apply, ContinuousMap.coe_mk,
+        rw [comp_apply, ContinuousMap.coe_mk, comp_apply, ContinuousMap.coe_mk,
           Function.comp_apply, if_neg]
         refine' mt (fun α => hVU α) _
         simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
       apply_fun fun e => (e y).down at H
       dsimp [LocallyConstant.ofClopen] at H
-      -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-      erw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
+      rw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
       exact top_ne_bot H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget Profinite).epi_of_epi_map
 #align Profinite.epi_iff_surjective Profinite.epi_iff_surjective
 
 instance {X Y : Profinite} (f : X ⟶ Y) [Epi f] : @Epi CompHaus _ _ _ f := by
-  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-  erw [CompHaus.epi_iff_surjective, ← epi_iff_surjective]; assumption
+  rwa [CompHaus.epi_iff_surjective, ← epi_iff_surjective]
 
 instance {X Y : Profinite} (f : X ⟶ Y) [@Epi CompHaus _ _ _ f] : Epi f := by
-  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-  erw [epi_iff_surjective, ← CompHaus.epi_iff_surjective]; assumption
+  rwa [epi_iff_surjective, ← CompHaus.epi_iff_surjective]
 
 theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f := by
   constructor
   · intro h
     haveI : Limits.PreservesLimits profiniteToCompHaus := inferInstance
     haveI : Mono (profiniteToCompHaus.map f) := inferInstance
-    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-    erw [← CompHaus.mono_iff_injective]
+    rw [← CompHaus.mono_iff_injective]
     assumption
   · rw [← CategoryTheory.mono_iff_injective]
     apply (forget Profinite).mono_of_mono_map

This includes all the changes from #7606.

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

@@ -383,30 +383,35 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
         ext x
         apply ULift.ext
         dsimp [LocallyConstant.ofClopen]
-        rw [comp_apply, ContinuousMap.coe_mk, comp_apply, ContinuousMap.coe_mk,
+        -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+        erw [comp_apply, ContinuousMap.coe_mk, comp_apply, ContinuousMap.coe_mk,
           Function.comp_apply, if_neg]
         refine' mt (fun α => hVU α) _
         simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
       apply_fun fun e => (e y).down at H
       dsimp [LocallyConstant.ofClopen] at H
-      rw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
+      -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+      erw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
       exact top_ne_bot H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget Profinite).epi_of_epi_map
 #align Profinite.epi_iff_surjective Profinite.epi_iff_surjective
 
 instance {X Y : Profinite} (f : X ⟶ Y) [Epi f] : @Epi CompHaus _ _ _ f := by
-  rwa [CompHaus.epi_iff_surjective, ← epi_iff_surjective]
+  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+  erw [CompHaus.epi_iff_surjective, ← epi_iff_surjective]; assumption
 
 instance {X Y : Profinite} (f : X ⟶ Y) [@Epi CompHaus _ _ _ f] : Epi f := by
-  rwa [epi_iff_surjective, ← CompHaus.epi_iff_surjective]
+  -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+  erw [epi_iff_surjective, ← CompHaus.epi_iff_surjective]; assumption
 
 theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f := by
   constructor
   · intro h
     haveI : Limits.PreservesLimits profiniteToCompHaus := inferInstance
     haveI : Mono (profiniteToCompHaus.map f) := inferInstance
-    rw [← CompHaus.mono_iff_injective]
+    -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [← CompHaus.mono_iff_injective]
     assumption
   · rw [← CategoryTheory.mono_iff_injective]
     apply (forget Profinite).mono_of_mono_map

Split up the 2000-line Topology/SubsetProperties.lean into several smaller files. Not only is it too huge, but the name is very unhelpful, since actually about 90% of the file is about compactness; I've moved this material into various files inside a new subdirectory Topology/Compactness/.

@@ -5,7 +5,6 @@ Authors: Kevin Buzzard, Calle Sönne
 -/
 import Mathlib.Topology.Category.CompHaus.Basic
 import Mathlib.Topology.Connected
-import Mathlib.Topology.SubsetProperties
 import Mathlib.Topology.LocallyConstant.Basic
 import Mathlib.CategoryTheory.Adjunction.Reflective
 import Mathlib.CategoryTheory.Monad.Limits

@@ -282,8 +282,8 @@ def toProfiniteAdjToCompHaus : CompHaus.toProfinite ⊣ profiniteToCompHaus :=
 #align Profinite.to_Profinite_adj_to_CompHaus Profinite.toProfiniteAdjToCompHaus
 
 /-- The category of profinite sets is reflective in the category of compact Hausdorff spaces -/
-instance toCompHaus.reflective : Reflective profiniteToCompHaus
-    where toIsRightAdjoint := ⟨CompHaus.toProfinite, Profinite.toProfiniteAdjToCompHaus⟩
+instance toCompHaus.reflective : Reflective profiniteToCompHaus where
+  toIsRightAdjoint := ⟨CompHaus.toProfinite, Profinite.toProfiniteAdjToCompHaus⟩
 #align Profinite.to_CompHaus.reflective Profinite.toCompHaus.reflective
 
 noncomputable instance toCompHaus.createsLimits : CreatesLimits profiniteToCompHaus :=

... also moves around some stuff and given an epi f in Stonean, Profinite or CompHaus, provides instances [Epi f] in both the other categories.

@@ -396,6 +396,12 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
     apply (forget Profinite).epi_of_epi_map
 #align Profinite.epi_iff_surjective Profinite.epi_iff_surjective
 
+instance {X Y : Profinite} (f : X ⟶ Y) [Epi f] : @Epi CompHaus _ _ _ f := by
+  rwa [CompHaus.epi_iff_surjective, ← epi_iff_surjective]
+
+instance {X Y : Profinite} (f : X ⟶ Y) [@Epi CompHaus _ _ _ f] : Epi f := by
+  rwa [epi_iff_surjective, ← CompHaus.epi_iff_surjective]
+
 theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f := by
   constructor
   · intro h

Changes Profinite.homeoOfIso and Profinite.isoOfHomeo to go through CompHaus and adds Stonean.homeoOfIso, Stonean.isoOfHomeo and Stonean.isoEquivHomeo

@@ -336,41 +336,27 @@ instance forget_reflectsIsomorphisms : ReflectsIsomorphisms (forget Profinite) :
 #align Profinite.forget_reflects_isomorphisms Profinite.forget_reflectsIsomorphisms
 
 /-- Construct an isomorphism from a homeomorphism. -/
-@[simps hom inv]
-def isoOfHomeo (f : X ≃ₜ Y) : X ≅ Y where
-  hom := ⟨f, f.continuous⟩
-  inv := ⟨f.symm, f.symm.continuous⟩
-  hom_inv_id := by
-    ext x
-    exact f.symm_apply_apply x
-  inv_hom_id := by
-    ext x
-    exact f.apply_symm_apply x
+@[simps! hom inv]
+noncomputable
+def isoOfHomeo (f : X ≃ₜ Y) : X ≅ Y :=
+  @asIso _ _ _ _ ⟨f, f.continuous⟩ (@isIso_of_reflects_iso _ _ _ _ _ _ _ profiniteToCompHaus
+    (IsIso.of_iso (CompHaus.isoOfHomeo f)) _)
 #align Profinite.iso_of_homeo Profinite.isoOfHomeo
 
 /-- Construct a homeomorphism from an isomorphism. -/
-@[simps]
-def homeoOfIso (f : X ≅ Y) : X ≃ₜ Y where
-  toFun := f.hom
-  invFun := f.inv
-  left_inv x := by simp
-  right_inv x := by simp
-  continuous_toFun := f.hom.continuous
-  continuous_invFun := f.inv.continuous
+@[simps!]
+def homeoOfIso (f : X ≅ Y) : X ≃ₜ Y := CompHaus.homeoOfIso (profiniteToCompHaus.mapIso f)
 #align Profinite.homeo_of_iso Profinite.homeoOfIso
 
 /-- The equivalence between isomorphisms in `Profinite` and homeomorphisms
 of topological spaces. -/
-@[simps]
+@[simps!]
+noncomputable
 def isoEquivHomeo : (X ≅ Y) ≃ (X ≃ₜ Y) where
   toFun := homeoOfIso
   invFun := isoOfHomeo
-  left_inv f := by
-    ext
-    rfl
-  right_inv f := by
-    ext
-    rfl
+  left_inv f := by ext; rfl
+  right_inv f := by ext; rfl
 #align Profinite.iso_equiv_homeo Profinite.isoEquivHomeo
 
 theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f := by

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

This has nice performance benefits.

@@ -62,7 +62,7 @@ namespace Profinite
 /-- Construct a term of `Profinite` from a type endowed with the structure of a
 compact, Hausdorff and totally disconnected topological space.
 -/
-def of (X : Type _) [TopologicalSpace X] [CompactSpace X] [T2Space X]
+def of (X : Type*) [TopologicalSpace X] [CompactSpace X] [T2Space X]
     [TotallyDisconnectedSpace X] : Profinite :=
   ⟨⟨⟨X, inferInstance⟩⟩⟩
 #align Profinite.of Profinite.of
@@ -82,7 +82,7 @@ instance hasForget₂ : HasForget₂ Profinite TopCat :=
   InducedCategory.hasForget₂ _
 #align Profinite.has_forget₂ Profinite.hasForget₂
 
-instance : CoeSort Profinite (Type _) :=
+instance : CoeSort Profinite (Type*) :=
   ⟨fun X => X.toCompHaus⟩
 
 -- Porting note: This lemma was not needed in mathlib3
@@ -120,7 +120,7 @@ instance {X : Profinite} : T2Space ((forget Profinite).obj X) := by
 
 -- Porting note: removed, as it is a syntactic tautology.
 -- @[simp]
--- theorem coe_toCompHaus {X : Profinite} : (X.toCompHaus : Type _) = (X : Type _) :=
+-- theorem coe_toCompHaus {X : Profinite} : (X.toCompHaus : Type*) = (X : Type*) :=
 --   rfl
 -- #align Profinite.coe_to_CompHaus Profinite.coe_toCompHaus
 

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

@@ -247,7 +247,7 @@ end DiscreteTopology
 end Profinite
 
 namespace Profinite
--- set_option pp.universes true
+
 -- TODO the following construction of limits could be generalised
 -- to allow diagrams in lower universes.
 /-- An explicit limit cone for a functor `F : J ⥤ Profinite`, defined in terms of

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2020 Kevin Buzzard. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Kevin Buzzard, Calle Sönne
-
-! This file was ported from Lean 3 source module topology.category.Profinite.basic
-! leanprover-community/mathlib commit bcfa726826abd57587355b4b5b7e78ad6527b7e4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.Category.CompHaus.Basic
 import Mathlib.Topology.Connected
@@ -16,6 +11,8 @@ import Mathlib.CategoryTheory.Adjunction.Reflective
 import Mathlib.CategoryTheory.Monad.Limits
 import Mathlib.CategoryTheory.FintypeCat
 
+#align_import topology.category.Profinite.basic from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
+
 /-!
 # The category of Profinite Types
 

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -405,7 +405,7 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
           Function.comp_apply, if_neg]
         refine' mt (fun α => hVU α) _
         simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
-      apply_fun fun e => (e y).down  at H
+      apply_fun fun e => (e y).down at H
       dsimp [LocallyConstant.ofClopen] at H
       rw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
       exact top_ne_bot H

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

@@ -418,9 +418,7 @@ theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Func
   · intro h
     haveI : Limits.PreservesLimits profiniteToCompHaus := inferInstance
     haveI : Mono (profiniteToCompHaus.map f) := inferInstance
-    -- Porting note: now need `erw`?
-    -- https://github.com/leanprover-community/mathlib4/issues/5164
-    erw [← CompHaus.mono_iff_injective]
+    rw [← CompHaus.mono_iff_injective]
     assumption
   · rw [← CategoryTheory.mono_iff_injective]
     apply (forget Profinite).mono_of_mono_map

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

@@ -419,6 +419,7 @@ theorem mono_iff_injective {X Y : Profinite.{u}} (f : X ⟶ Y) : Mono f ↔ Func
     haveI : Limits.PreservesLimits profiniteToCompHaus := inferInstance
     haveI : Mono (profiniteToCompHaus.map f) := inferInstance
     -- Porting note: now need `erw`?
+    -- https://github.com/leanprover-community/mathlib4/issues/5164
     erw [← CompHaus.mono_iff_injective]
     assumption
   · rw [← CategoryTheory.mono_iff_injective]

@@ -401,13 +401,13 @@ theorem epi_iff_surjective {X Y : Profinite.{u}} (f : X ⟶ Y) : Epi f ↔ Funct
         ext x
         apply ULift.ext
         dsimp [LocallyConstant.ofClopen]
-        simp only [FunctorToTypes.map_comp_apply, forget_ContinuousMap_mk, Function.comp_apply]
-        rw [if_neg]
+        rw [comp_apply, ContinuousMap.coe_mk, comp_apply, ContinuousMap.coe_mk,
+          Function.comp_apply, if_neg]
         refine' mt (fun α => hVU α) _
         simp only [Set.mem_range_self, not_true, not_false_iff, Set.mem_compl_iff]
       apply_fun fun e => (e y).down  at H
       dsimp [LocallyConstant.ofClopen] at H
-      rw [if_pos hyV] at H
+      rw [ContinuousMap.coe_mk, ContinuousMap.coe_mk, Function.comp_apply, if_pos hyV] at H
       exact top_ne_bot H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget Profinite).epi_of_epi_map

These are all doc fixes

@@ -284,7 +284,7 @@ def toProfiniteAdjToCompHaus : CompHaus.toProfinite ⊣ profiniteToCompHaus :=
   Adjunction.adjunctionOfEquivLeft _ _
 #align Profinite.to_Profinite_adj_to_CompHaus Profinite.toProfiniteAdjToCompHaus
 
-/-- The category of profinite sets is reflective in the category of compact hausdroff spaces -/
+/-- The category of profinite sets is reflective in the category of compact Hausdorff spaces -/
 instance toCompHaus.reflective : Reflective profiniteToCompHaus
     where toIsRightAdjoint := ⟨CompHaus.toProfinite, Profinite.toProfiniteAdjToCompHaus⟩
 #align Profinite.to_CompHaus.reflective Profinite.toCompHaus.reflective

Mostly this is installing the Opposite.rec' induction principle as the default @[eliminator], but also many other fixes and removing unnecessary steps from proofs.

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

@@ -302,11 +302,11 @@ noncomputable instance toTopCat.createsLimits : CreatesLimits Profinite.toTopCat
 #align Profinite.to_Top.creates_limits Profinite.toTopCat.createsLimits
 
 instance hasLimits : Limits.HasLimits Profinite :=
-  has_limits_of_has_limits_creates_limits Profinite.toTopCat
+  hasLimits_of_hasLimits_createsLimits Profinite.toTopCat
 #align Profinite.has_limits Profinite.hasLimits
 
 instance hasColimits : Limits.HasColimits Profinite :=
-  has_colimits_of_reflective profiniteToCompHaus
+  hasColimits_of_reflective profiniteToCompHaus
 #align Profinite.has_colimits Profinite.hasColimits
 
 noncomputable instance forgetPreservesLimits : Limits.PreservesLimits (forget Profinite) := by

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