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

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

@@ -137,12 +137,13 @@ end CompHaus
 @[simps (config := { rhsMd := semireducible })]
 def compHausToTop : CompHaus.{u} ⥤ TopCat.{u} :=
   inducedFunctor _
-deriving Full, Faithful
+deriving CategoryTheory.Functor.Full, CategoryTheory.Functor.Faithful
 #align CompHaus_to_Top compHausToTop
 -/
 
 #print CompHaus.forget_reflectsIsomorphisms /-
-instance CompHaus.forget_reflectsIsomorphisms : ReflectsIsomorphisms (forget CompHaus.{u}) :=
+instance CompHaus.forget_reflectsIsomorphisms :
+    CategoryTheory.Functor.ReflectsIsomorphisms (forget CompHaus.{u}) :=
   ⟨by intro A B f hf <;> exact CompHaus.isIso_of_bijective _ ((is_iso_iff_bijective f).mp hf)⟩
 #align CompHaus.forget_reflects_isomorphisms CompHaus.forget_reflectsIsomorphisms
 -/

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

@@ -7,7 +7,7 @@ import CategoryTheory.Adjunction.Reflective
 import Topology.StoneCech
 import CategoryTheory.Monad.Limits
 import Topology.UrysohnsLemma
-import Topology.Category.Top.Limits.Basic
+import Topology.Category.TopCat.Limits.Basic
 
 #align_import topology.category.CompHaus.basic from "leanprover-community/mathlib"@"f2b757fc5c341d88741b9c4630b1e8ba973c5726"
 

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

@@ -298,9 +298,9 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
       ext x; dsimp
       simp only [comp_apply, ContinuousMap.coe_mk, Subtype.coe_mk, hφ0 (Set.mem_range_self x),
         Pi.zero_apply]
-    apply_fun fun e => (e y).down at H 
-    dsimp at H 
-    simp only [Subtype.mk_eq_mk, hφ1 (Set.mem_singleton y), Pi.one_apply] at H 
+    apply_fun fun e => (e y).down at H
+    dsimp at H
+    simp only [Subtype.mk_eq_mk, hφ1 (Set.mem_singleton y), Pi.one_apply] at H
     exact zero_ne_one H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget CompHaus).epi_of_epi_map
@@ -315,8 +315,8 @@ theorem mono_iff_injective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Mono f ↔ Funct
     let g₁ : of PUnit ⟶ X := ⟨fun _ => x₁, continuous_const⟩
     let g₂ : of PUnit ⟶ X := ⟨fun _ => x₂, continuous_const⟩
     have : g₁ ≫ f = g₂ ≫ f := by ext; exact h
-    rw [cancel_mono] at this 
-    apply_fun fun e => e PUnit.unit at this 
+    rw [cancel_mono] at this
+    apply_fun fun e => e PUnit.unit at this
     exact this
   · rw [← CategoryTheory.mono_iff_injective]
     apply (forget CompHaus).mono_of_mono_map

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

@@ -285,7 +285,7 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
     have hCD : Disjoint C D := by rw [Set.disjoint_singleton_right]; rintro ⟨y', hy'⟩;
       exact hy y' hy'
     haveI : NormalSpace ↥Y.to_Top := T4Space.of_compactSpace_t2Space
-    obtain ⟨φ, hφ0, hφ1, hφ01⟩ := exists_continuous_zero_one_of_closed hC hD hCD
+    obtain ⟨φ, hφ0, hφ1, hφ01⟩ := exists_continuous_zero_one_of_isClosed hC hD hCD
     haveI : CompactSpace (ULift.{u} <| Set.Icc (0 : ℝ) 1) := homeomorph.ulift.symm.compact_space
     haveI : T2Space (ULift.{u} <| Set.Icc (0 : ℝ) 1) := homeomorph.ulift.symm.t2_space
     let Z := of (ULift.{u} <| Set.Icc (0 : ℝ) 1)

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

@@ -3,11 +3,11 @@ Copyright (c) 2020 Adam Topaz. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Adam Topaz, Bhavik Mehta
 -/
-import Mathbin.CategoryTheory.Adjunction.Reflective
-import Mathbin.Topology.StoneCech
-import Mathbin.CategoryTheory.Monad.Limits
-import Mathbin.Topology.UrysohnsLemma
-import Mathbin.Topology.Category.Top.Limits.Basic
+import CategoryTheory.Adjunction.Reflective
+import Topology.StoneCech
+import CategoryTheory.Monad.Limits
+import Topology.UrysohnsLemma
+import Topology.Category.Top.Limits.Basic
 
 #align_import topology.category.CompHaus.basic from "leanprover-community/mathlib"@"f2b757fc5c341d88741b9c4630b1e8ba973c5726"
 

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

@@ -284,7 +284,7 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
     have hD : IsClosed D := isClosed_singleton
     have hCD : Disjoint C D := by rw [Set.disjoint_singleton_right]; rintro ⟨y', hy'⟩;
       exact hy y' hy'
-    haveI : NormalSpace ↥Y.to_Top := normalOfCompactT2
+    haveI : NormalSpace ↥Y.to_Top := T4Space.of_compactSpace_t2Space
     obtain ⟨φ, hφ0, hφ1, hφ01⟩ := exists_continuous_zero_one_of_closed hC hD hCD
     haveI : CompactSpace (ULift.{u} <| Set.Icc (0 : ℝ) 1) := homeomorph.ulift.symm.compact_space
     haveI : T2Space (ULift.{u} <| Set.Icc (0 : ℝ) 1) := homeomorph.ulift.symm.t2_space

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

@@ -2,11 +2,6 @@
 Copyright (c) 2020 Adam Topaz. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Adam Topaz, Bhavik Mehta
-
-! This file was ported from Lean 3 source module topology.category.CompHaus.basic
-! leanprover-community/mathlib commit f2b757fc5c341d88741b9c4630b1e8ba973c5726
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Adjunction.Reflective
 import Mathbin.Topology.StoneCech
@@ -14,6 +9,8 @@ import Mathbin.CategoryTheory.Monad.Limits
 import Mathbin.Topology.UrysohnsLemma
 import Mathbin.Topology.Category.Top.Limits.Basic
 
+#align_import topology.category.CompHaus.basic from "leanprover-community/mathlib"@"f2b757fc5c341d88741b9c4630b1e8ba973c5726"
+
 /-!
 # The category of Compact Hausdorff Spaces
 

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

@@ -99,11 +99,14 @@ theorem coe_of : (CompHaus.of X : Type _) = X :=
 #align CompHaus.coe_of CompHaus.coe_of
 -/
 
+#print CompHaus.isClosedMap /-
 /-- Any continuous function on compact Hausdorff spaces is a closed map. -/
 theorem isClosedMap {X Y : CompHaus.{u}} (f : X ⟶ Y) : IsClosedMap f := fun C hC =>
   (hC.IsCompact.image f.Continuous).IsClosed
 #align CompHaus.is_closed_map CompHaus.isClosedMap
+-/
 
+#print CompHaus.isIso_of_bijective /-
 /-- Any continuous bijection of compact Hausdorff spaces is an isomorphism. -/
 theorem isIso_of_bijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Function.Bijective f) :
     IsIso f := by
@@ -119,13 +122,16 @@ theorem isIso_of_bijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Function.Bi
   · ext x
     apply E.apply_symm_apply
 #align CompHaus.is_iso_of_bijective CompHaus.isIso_of_bijective
+-/
 
+#print CompHaus.isoOfBijective /-
 /-- Any continuous bijection of compact Hausdorff spaces induces an isomorphism. -/
 noncomputable def isoOfBijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Function.Bijective f) :
     X ≅ Y :=
   letI := is_iso_of_bijective _ bij
   as_iso f
 #align CompHaus.iso_of_bijective CompHaus.isoOfBijective
+-/
 
 end CompHaus
 
@@ -154,6 +160,7 @@ def stoneCechObj (X : TopCat) : CompHaus :=
 #align StoneCech_obj stoneCechObj
 -/
 
+#print stoneCechEquivalence /-
 /-- (Implementation) The bijection of homsets to establish the reflective adjunction of compact
 Hausdorff spaces in topological spaces.
 -/
@@ -178,6 +185,7 @@ noncomputable def stoneCechEquivalence (X : TopCat.{u}) (Y : CompHaus.{u}) :
     ext
     exact congr_fun (stoneCechExtend_extends hf) _
 #align stone_cech_equivalence stoneCechEquivalence
+-/
 
 #print topToCompHaus /-
 /-- The Stone-Cech compactification functor from topological spaces to compact Hausdorff spaces,
@@ -188,9 +196,11 @@ noncomputable def topToCompHaus : TopCat.{u} ⥤ CompHaus.{u} :=
 #align Top_to_CompHaus topToCompHaus
 -/
 
+#print topToCompHaus_obj /-
 theorem topToCompHaus_obj (X : TopCat) : ↥(topToCompHaus.obj X) = StoneCech X :=
   rfl
 #align Top_to_CompHaus_obj topToCompHaus_obj
+-/
 
 #print compHausToTop.reflective /-
 /-- The category of compact Hausdorff spaces is reflective in the category of topological spaces.
@@ -265,6 +275,7 @@ def limitConeIsLimit {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u
 #align CompHaus.limit_cone_is_limit CompHaus.limitConeIsLimit
 -/
 
+#print CompHaus.epi_iff_surjective /-
 theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f :=
   by
   constructor
@@ -297,7 +308,9 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget CompHaus).epi_of_epi_map
 #align CompHaus.epi_iff_surjective CompHaus.epi_iff_surjective
+-/
 
+#print CompHaus.mono_iff_injective /-
 theorem mono_iff_injective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f :=
   by
   constructor
@@ -311,6 +324,7 @@ theorem mono_iff_injective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Mono f ↔ Funct
   · rw [← CategoryTheory.mono_iff_injective]
     apply (forget CompHaus).mono_of_mono_map
 #align CompHaus.mono_iff_injective CompHaus.mono_iff_injective
+-/
 
 end CompHaus
 

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

@@ -208,13 +208,13 @@ noncomputable instance compHausToTop.createsLimits : CreatesLimits compHausToTop
 
 #print CompHaus.hasLimits /-
 instance CompHaus.hasLimits : Limits.HasLimits CompHaus :=
-  has_limits_of_has_limits_creates_limits compHausToTop
+  hasLimits_of_hasLimits_createsLimits compHausToTop
 #align CompHaus.has_limits CompHaus.hasLimits
 -/
 
 #print CompHaus.hasColimits /-
 instance CompHaus.hasColimits : Limits.HasColimits CompHaus :=
-  has_colimits_of_reflective compHausToTop
+  hasColimits_of_reflective compHausToTop
 #align CompHaus.has_colimits CompHaus.hasColimits
 -/
 
@@ -230,12 +230,12 @@ def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Li
     { toTop := (TopCat.limitCone (F ⋙ compHausToTop)).pt
       IsCompact :=
         by
-        show CompactSpace ↥{ u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }
+        show CompactSpace ↥{u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j}
         rw [← isCompact_iff_compactSpace]
         apply IsClosed.isCompact
         have :
-          { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
-            ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } :=
+          {u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j} =
+            ⋂ (i : J) (j : J) (f : i ⟶ j), {u | F.map f (u i) = u j} :=
           by ext1; simp only [Set.mem_iInter, Set.mem_setOf_eq]
         rw [this]
         apply isClosed_iInter; intro i
@@ -245,7 +245,7 @@ def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Li
         · exact (ContinuousMap.continuous (F.map f)).comp (continuous_apply i)
         · exact continuous_apply j
       is_hausdorff :=
-        show T2Space ↥{ u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j } from
+        show T2Space ↥{u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j} from
           inferInstance }
   π :=
     { app := fun j => (TopCat.limitCone (F ⋙ compHausToTop)).π.app j
@@ -290,7 +290,7 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
       ext x; dsimp
       simp only [comp_apply, ContinuousMap.coe_mk, Subtype.coe_mk, hφ0 (Set.mem_range_self x),
         Pi.zero_apply]
-    apply_fun fun e => (e y).down  at H 
+    apply_fun fun e => (e y).down at H 
     dsimp at H 
     simp only [Subtype.mk_eq_mk, hφ1 (Set.mem_singleton y), Pi.one_apply] at H 
     exact zero_ne_one H
@@ -306,7 +306,7 @@ theorem mono_iff_injective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Mono f ↔ Funct
     let g₂ : of PUnit ⟶ X := ⟨fun _ => x₂, continuous_const⟩
     have : g₁ ≫ f = g₂ ≫ f := by ext; exact h
     rw [cancel_mono] at this 
-    apply_fun fun e => e PUnit.unit  at this 
+    apply_fun fun e => e PUnit.unit at this 
     exact this
   · rw [← CategoryTheory.mono_iff_injective]
     apply (forget CompHaus).mono_of_mono_map

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

@@ -133,7 +133,8 @@ end CompHaus
 /-- The fully faithful embedding of `CompHaus` in `Top`. -/
 @[simps (config := { rhsMd := semireducible })]
 def compHausToTop : CompHaus.{u} ⥤ TopCat.{u} :=
-  inducedFunctor _ deriving Full, Faithful
+  inducedFunctor _
+deriving Full, Faithful
 #align CompHaus_to_Top compHausToTop
 -/
 
@@ -289,9 +290,9 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
       ext x; dsimp
       simp only [comp_apply, ContinuousMap.coe_mk, Subtype.coe_mk, hφ0 (Set.mem_range_self x),
         Pi.zero_apply]
-    apply_fun fun e => (e y).down  at H
-    dsimp at H
-    simp only [Subtype.mk_eq_mk, hφ1 (Set.mem_singleton y), Pi.one_apply] at H
+    apply_fun fun e => (e y).down  at H 
+    dsimp at H 
+    simp only [Subtype.mk_eq_mk, hφ1 (Set.mem_singleton y), Pi.one_apply] at H 
     exact zero_ne_one H
   · rw [← CategoryTheory.epi_iff_surjective]
     apply (forget CompHaus).epi_of_epi_map
@@ -304,8 +305,8 @@ theorem mono_iff_injective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Mono f ↔ Funct
     let g₁ : of PUnit ⟶ X := ⟨fun _ => x₁, continuous_const⟩
     let g₂ : of PUnit ⟶ X := ⟨fun _ => x₂, continuous_const⟩
     have : g₁ ≫ f = g₂ ≫ f := by ext; exact h
-    rw [cancel_mono] at this
-    apply_fun fun e => e PUnit.unit  at this
+    rw [cancel_mono] at this 
+    apply_fun fun e => e PUnit.unit  at this 
     exact this
   · rw [← CategoryTheory.mono_iff_injective]
     apply (forget CompHaus).mono_of_mono_map

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

@@ -99,23 +99,11 @@ theorem coe_of : (CompHaus.of X : Type _) = X :=
 #align CompHaus.coe_of CompHaus.coe_of
 -/
 
-/- warning: CompHaus.is_closed_map -> CompHaus.isClosedMap is a dubious translation:
-lean 3 declaration is
-  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 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} 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} Y)) (TopCat.topologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (TopCat.topologicalSpace.{u1} (CompHaus.toTop.{u1} Y)) (coeFn.{succ u1, succ u1} (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 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{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} 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} 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} Y))) f)
-but is expected to have type
-  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), IsClosedMap.{u1, 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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X) (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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) Y) (CompHaus.instTopologicalSpaceObjCompHausToQuiverToCategoryStructCategoryTypeTypesToPrefunctorForgetConcreteCategory.{u1} X) (CompHaus.instTopologicalSpaceObjCompHausToQuiverToCategoryStructCategoryTypeTypesToPrefunctorForgetConcreteCategory.{u1} Y) (Prefunctor.map.{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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X Y f)
-Case conversion may be inaccurate. Consider using '#align CompHaus.is_closed_map CompHaus.isClosedMapₓ'. -/
 /-- Any continuous function on compact Hausdorff spaces is a closed map. -/
 theorem isClosedMap {X Y : CompHaus.{u}} (f : X ⟶ Y) : IsClosedMap f := fun C hC =>
   (hC.IsCompact.image f.Continuous).IsClosed
 #align CompHaus.is_closed_map CompHaus.isClosedMap
 
-/- warning: CompHaus.is_iso_of_bijective -> CompHaus.isIso_of_bijective is a dubious translation:
-lean 3 declaration is
-  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 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} 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} Y)) (coeFn.{succ u1, succ u1} (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 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{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} 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} 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} Y))) f)) -> (CategoryTheory.IsIso.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y f)
-but is expected to have type
-  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), (Function.Bijective.{succ u1, succ 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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X) (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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) Y) (Prefunctor.map.{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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X Y f)) -> (CategoryTheory.IsIso.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y f)
-Case conversion may be inaccurate. Consider using '#align CompHaus.is_iso_of_bijective CompHaus.isIso_of_bijectiveₓ'. -/
 /-- Any continuous bijection of compact Hausdorff spaces is an isomorphism. -/
 theorem isIso_of_bijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Function.Bijective f) :
     IsIso f := by
@@ -132,12 +120,6 @@ theorem isIso_of_bijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Function.Bi
     apply E.apply_symm_apply
 #align CompHaus.is_iso_of_bijective CompHaus.isIso_of_bijective
 
-/- warning: CompHaus.iso_of_bijective -> CompHaus.isoOfBijective is a dubious translation:
-lean 3 declaration is
-  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 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} 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} Y)) (coeFn.{succ u1, succ u1} (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 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{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} 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} 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} Y))) f)) -> (CategoryTheory.Iso.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y)
-but is expected to have type
-  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), (Function.Bijective.{succ u1, succ 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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X) (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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) Y) (Prefunctor.map.{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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X Y f)) -> (CategoryTheory.Iso.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y)
-Case conversion may be inaccurate. Consider using '#align CompHaus.iso_of_bijective CompHaus.isoOfBijectiveₓ'. -/
 /-- Any continuous bijection of compact Hausdorff spaces induces an isomorphism. -/
 noncomputable def isoOfBijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Function.Bijective f) :
     X ≅ Y :=
@@ -171,12 +153,6 @@ def stoneCechObj (X : TopCat) : CompHaus :=
 #align StoneCech_obj stoneCechObj
 -/
 
-/- warning: stone_cech_equivalence -> stoneCechEquivalence is a dubious translation:
-lean 3 declaration is
-  forall (X : TopCat.{u1}) (Y : CompHaus.{u1}), Equiv.{succ u1, succ u1} (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})) (stoneCechObj.{u1} X) Y) (Quiver.Hom.{succ u1, succ u1} TopCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} TopCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} TopCat.{u1} TopCat.largeCategory.{u1})) X (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} TopCat.{u1} TopCat.largeCategory.{u1} compHausToTop.{u1} Y))
-but is expected to have type
-  forall (X : TopCat.{u1}) (Y : CompHaus.{u1}), Equiv.{succ u1, succ u1} (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})) (stoneCechObj.{u1} X) Y) (Quiver.Hom.{succ u1, succ u1} TopCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} TopCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} TopCat.{u1} instTopCatLargeCategory.{u1})) X (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})) TopCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} TopCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} TopCat.{u1} instTopCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} TopCat.{u1} instTopCatLargeCategory.{u1} compHausToTop.{u1}) Y))
-Case conversion may be inaccurate. Consider using '#align stone_cech_equivalence stoneCechEquivalenceₓ'. -/
 /-- (Implementation) The bijection of homsets to establish the reflective adjunction of compact
 Hausdorff spaces in topological spaces.
 -/
@@ -211,12 +187,6 @@ noncomputable def topToCompHaus : TopCat.{u} ⥤ CompHaus.{u} :=
 #align Top_to_CompHaus topToCompHaus
 -/
 
-/- warning: Top_to_CompHaus_obj -> topToCompHaus_obj is a dubious translation:
-lean 3 declaration is
-  forall (X : TopCat.{u1}), Eq.{succ (succ u1)} Type.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CompHaus.{u1} Type.{u1} CompHaus.hasCoeToSort.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} TopCat.{u1} TopCat.largeCategory.{u1} CompHaus.{u1} CompHaus.category.{u1} topToCompHaus.{u1} X)) (StoneCech.{u1} (coeSort.{succ (succ u1), succ (succ u1)} TopCat.{u1} Type.{u1} TopCat.hasCoeToSort.{u1} X) (TopCat.topologicalSpace.{u1} X))
-but is expected to have type
-  forall (X : TopCat.{u1}), Eq.{succ (succ u1)} Type.{u1} (CategoryTheory.Bundled.α.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} TopCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} TopCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} TopCat.{u1} instTopCatLargeCategory.{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} TopCat.{u1} instTopCatLargeCategory.{u1} CompHaus.{u1} CompHaus.category.{u1} topToCompHaus.{u1}) X))) (StoneCech.{u1} (CategoryTheory.Bundled.α.{u1, u1} TopologicalSpace.{u1} X) (TopCat.topologicalSpace_coe.{u1} X))
-Case conversion may be inaccurate. Consider using '#align Top_to_CompHaus_obj topToCompHaus_objₓ'. -/
 theorem topToCompHaus_obj (X : TopCat) : ↥(topToCompHaus.obj X) = StoneCech X :=
   rfl
 #align Top_to_CompHaus_obj topToCompHaus_obj
@@ -294,12 +264,6 @@ def limitConeIsLimit {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u
 #align CompHaus.limit_cone_is_limit CompHaus.limitConeIsLimit
 -/
 
-/- warning: CompHaus.epi_iff_surjective -> CompHaus.epi_iff_surjective is a dubious translation:
-lean 3 declaration is
-  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), Iff (CategoryTheory.Epi.{u1, succ u1} CompHaus.{u1} CompHaus.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} 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} Y)) (coeFn.{succ u1, succ u1} (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 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{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} 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} 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} Y))) f))
-but is expected to have type
-  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), Iff (CategoryTheory.Epi.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y f) (Function.Surjective.{succ u1, succ 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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X) (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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) Y) (Prefunctor.map.{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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X Y f))
-Case conversion may be inaccurate. Consider using '#align CompHaus.epi_iff_surjective CompHaus.epi_iff_surjectiveₓ'. -/
 theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f :=
   by
   constructor
@@ -333,12 +297,6 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
     apply (forget CompHaus).epi_of_epi_map
 #align CompHaus.epi_iff_surjective CompHaus.epi_iff_surjective
 
-/- warning: CompHaus.mono_iff_injective -> CompHaus.mono_iff_injective is a dubious translation:
-lean 3 declaration is
-  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), Iff (CategoryTheory.Mono.{u1, succ u1} CompHaus.{u1} CompHaus.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} 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} Y)) (coeFn.{succ u1, succ u1} (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 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{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} 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} 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} Y))) f))
-but is expected to have type
-  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), Iff (CategoryTheory.Mono.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y f) (Function.Injective.{succ u1, succ 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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X) (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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) Y) (Prefunctor.map.{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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X Y f))
-Case conversion may be inaccurate. Consider using '#align CompHaus.mono_iff_injective CompHaus.mono_iff_injectiveₓ'. -/
 theorem mono_iff_injective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f :=
   by
   constructor

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

@@ -265,16 +265,11 @@ def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Li
         have :
           { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
             ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } :=
-          by
-          ext1
-          simp only [Set.mem_iInter, Set.mem_setOf_eq]
+          by ext1; simp only [Set.mem_iInter, Set.mem_setOf_eq]
         rw [this]
-        apply isClosed_iInter
-        intro i
-        apply isClosed_iInter
-        intro j
-        apply isClosed_iInter
-        intro f
+        apply isClosed_iInter; intro i
+        apply isClosed_iInter; intro j
+        apply isClosed_iInter; intro f
         apply isClosed_eq
         · exact (ContinuousMap.continuous (F.map f)).comp (continuous_apply i)
         · exact continuous_apply j
@@ -284,10 +279,8 @@ def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Li
   π :=
     { app := fun j => (TopCat.limitCone (F ⋙ compHausToTop)).π.app j
       naturality' := by
-        intro _ _ _
-        ext ⟨x, hx⟩
-        simp only [comp_apply, functor.const_obj_map, id_apply]
-        exact (hx f).symm }
+        intro _ _ _; ext ⟨x, hx⟩
+        simp only [comp_apply, functor.const_obj_map, id_apply]; exact (hx f).symm }
 #align CompHaus.limit_cone CompHaus.limitCone
 -/
 
@@ -316,9 +309,7 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
     have hC : IsClosed C := (isCompact_range f.continuous).IsClosed
     let D := {y}
     have hD : IsClosed D := isClosed_singleton
-    have hCD : Disjoint C D := by
-      rw [Set.disjoint_singleton_right]
-      rintro ⟨y', hy'⟩
+    have hCD : Disjoint C D := by rw [Set.disjoint_singleton_right]; rintro ⟨y', hy'⟩;
       exact hy y' hy'
     haveI : NormalSpace ↥Y.to_Top := normalOfCompactT2
     obtain ⟨φ, hφ0, hφ1, hφ01⟩ := exists_continuous_zero_one_of_closed hC hD hCD
@@ -331,8 +322,7 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
     let h : Y ⟶ Z := ⟨fun _ => ⟨⟨0, set.left_mem_Icc.mpr zero_le_one⟩⟩, continuous_const⟩
     have H : h = g := by
       rw [← cancel_epi f]
-      ext x
-      dsimp
+      ext x; dsimp
       simp only [comp_apply, ContinuousMap.coe_mk, Subtype.coe_mk, hφ0 (Set.mem_range_self x),
         Pi.zero_apply]
     apply_fun fun e => (e y).down  at H
@@ -355,9 +345,7 @@ theorem mono_iff_injective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Mono f ↔ Funct
   · intro hf x₁ x₂ h
     let g₁ : of PUnit ⟶ X := ⟨fun _ => x₁, continuous_const⟩
     let g₂ : of PUnit ⟶ X := ⟨fun _ => x₂, continuous_const⟩
-    have : g₁ ≫ f = g₂ ≫ f := by
-      ext
-      exact h
+    have : g₁ ≫ f = g₂ ≫ f := by ext; exact h
     rw [cancel_mono] at this
     apply_fun fun e => e PUnit.unit  at this
     exact this

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

@@ -267,13 +267,13 @@ def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Li
             ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } :=
           by
           ext1
-          simp only [Set.mem_interᵢ, Set.mem_setOf_eq]
+          simp only [Set.mem_iInter, Set.mem_setOf_eq]
         rw [this]
-        apply isClosed_interᵢ
+        apply isClosed_iInter
         intro i
-        apply isClosed_interᵢ
+        apply isClosed_iInter
         intro j
-        apply isClosed_interᵢ
+        apply isClosed_iInter
         intro f
         apply isClosed_eq
         · exact (ContinuousMap.continuous (F.map f)).comp (continuous_apply i)

mathlib commit https://github.com/leanprover-community/mathlib/commit/86d04064ca33ee3d3405fbfc497d494fd2dd4796

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Adam Topaz, Bhavik Mehta
 
 ! This file was ported from Lean 3 source module topology.category.CompHaus.basic
-! leanprover-community/mathlib commit 178a32653e369dce2da68dc6b2694e385d484ef1
+! leanprover-community/mathlib commit f2b757fc5c341d88741b9c4630b1e8ba973c5726
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -17,6 +17,9 @@ import Mathbin.Topology.Category.Top.Limits.Basic
 /-!
 # The category of Compact Hausdorff Spaces
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We construct the category of compact Hausdorff spaces.
 The type of compact Hausdorff spaces is denoted `CompHaus`, and it is endowed with a category
 instance making it a full subcategory of `Top`.

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

@@ -36,12 +36,14 @@ universe v u
 
 open CategoryTheory
 
+#print CompHaus /-
 /-- The type of Compact Hausdorff topological spaces. -/
 structure CompHaus where
   toTop : TopCat
   [IsCompact : CompactSpace to_Top]
   [is_hausdorff : T2Space to_Top]
 #align CompHaus CompHaus
+-/
 
 namespace CompHaus
 
@@ -57,13 +59,17 @@ instance {X : CompHaus} : CompactSpace X :=
 instance {X : CompHaus} : T2Space X :=
   X.is_hausdorff
 
+#print CompHaus.category /-
 instance category : Category CompHaus :=
   InducedCategory.category toTop
 #align CompHaus.category CompHaus.category
+-/
 
+#print CompHaus.concreteCategory /-
 instance concreteCategory : ConcreteCategory CompHaus :=
   InducedCategory.concreteCategory _
 #align CompHaus.concrete_category CompHaus.concreteCategory
+-/
 
 @[simp]
 theorem coe_toTop {X : CompHaus} : (X.toTop : Type _) = X :=
@@ -72,6 +78,7 @@ theorem coe_toTop {X : CompHaus} : (X.toTop : Type _) = X :=
 
 variable (X : Type _) [TopologicalSpace X] [CompactSpace X] [T2Space X]
 
+#print CompHaus.of /-
 /-- A constructor for objects of the category `CompHaus`,
 taking a type, and bundling the compact Hausdorff topology
 found by typeclass inference. -/
@@ -80,17 +87,32 @@ def of : CompHaus where
   IsCompact := ‹_›
   is_hausdorff := ‹_›
 #align CompHaus.of CompHaus.of
+-/
 
+#print CompHaus.coe_of /-
 @[simp]
 theorem coe_of : (CompHaus.of X : Type _) = X :=
   rfl
 #align CompHaus.coe_of CompHaus.coe_of
+-/
 
+/- warning: CompHaus.is_closed_map -> CompHaus.isClosedMap is a dubious translation:
+lean 3 declaration is
+  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 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} 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} Y)) (TopCat.topologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (TopCat.topologicalSpace.{u1} (CompHaus.toTop.{u1} Y)) (coeFn.{succ u1, succ u1} (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 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{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} 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} 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} Y))) f)
+but is expected to have type
+  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), IsClosedMap.{u1, 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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X) (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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) Y) (CompHaus.instTopologicalSpaceObjCompHausToQuiverToCategoryStructCategoryTypeTypesToPrefunctorForgetConcreteCategory.{u1} X) (CompHaus.instTopologicalSpaceObjCompHausToQuiverToCategoryStructCategoryTypeTypesToPrefunctorForgetConcreteCategory.{u1} Y) (Prefunctor.map.{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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X Y f)
+Case conversion may be inaccurate. Consider using '#align CompHaus.is_closed_map CompHaus.isClosedMapₓ'. -/
 /-- Any continuous function on compact Hausdorff spaces is a closed map. -/
 theorem isClosedMap {X Y : CompHaus.{u}} (f : X ⟶ Y) : IsClosedMap f := fun C hC =>
   (hC.IsCompact.image f.Continuous).IsClosed
 #align CompHaus.is_closed_map CompHaus.isClosedMap
 
+/- warning: CompHaus.is_iso_of_bijective -> CompHaus.isIso_of_bijective is a dubious translation:
+lean 3 declaration is
+  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 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} 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} Y)) (coeFn.{succ u1, succ u1} (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 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{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} 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} 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} Y))) f)) -> (CategoryTheory.IsIso.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y f)
+but is expected to have type
+  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), (Function.Bijective.{succ u1, succ 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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X) (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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) Y) (Prefunctor.map.{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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X Y f)) -> (CategoryTheory.IsIso.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y f)
+Case conversion may be inaccurate. Consider using '#align CompHaus.is_iso_of_bijective CompHaus.isIso_of_bijectiveₓ'. -/
 /-- Any continuous bijection of compact Hausdorff spaces is an isomorphism. -/
 theorem isIso_of_bijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Function.Bijective f) :
     IsIso f := by
@@ -107,6 +129,12 @@ theorem isIso_of_bijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Function.Bi
     apply E.apply_symm_apply
 #align CompHaus.is_iso_of_bijective CompHaus.isIso_of_bijective
 
+/- warning: CompHaus.iso_of_bijective -> CompHaus.isoOfBijective is a dubious translation:
+lean 3 declaration is
+  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 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} 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} Y)) (coeFn.{succ u1, succ u1} (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 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{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} 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} 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} Y))) f)) -> (CategoryTheory.Iso.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y)
+but is expected to have type
+  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), (Function.Bijective.{succ u1, succ 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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X) (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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) Y) (Prefunctor.map.{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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X Y f)) -> (CategoryTheory.Iso.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y)
+Case conversion may be inaccurate. Consider using '#align CompHaus.iso_of_bijective CompHaus.isoOfBijectiveₓ'. -/
 /-- Any continuous bijection of compact Hausdorff spaces induces an isomorphism. -/
 noncomputable def isoOfBijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Function.Bijective f) :
     X ≅ Y :=
@@ -116,16 +144,21 @@ noncomputable def isoOfBijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Funct
 
 end CompHaus
 
+#print compHausToTop /-
 /-- The fully faithful embedding of `CompHaus` in `Top`. -/
 @[simps (config := { rhsMd := semireducible })]
 def compHausToTop : CompHaus.{u} ⥤ TopCat.{u} :=
   inducedFunctor _ deriving Full, Faithful
 #align CompHaus_to_Top compHausToTop
+-/
 
+#print CompHaus.forget_reflectsIsomorphisms /-
 instance CompHaus.forget_reflectsIsomorphisms : ReflectsIsomorphisms (forget CompHaus.{u}) :=
   ⟨by intro A B f hf <;> exact CompHaus.isIso_of_bijective _ ((is_iso_iff_bijective f).mp hf)⟩
 #align CompHaus.forget_reflects_isomorphisms CompHaus.forget_reflectsIsomorphisms
+-/
 
+#print stoneCechObj /-
 /-- (Implementation) The object part of the compactification functor from topological spaces to
 compact Hausdorff spaces.
 -/
@@ -133,7 +166,14 @@ compact Hausdorff spaces.
 def stoneCechObj (X : TopCat) : CompHaus :=
   CompHaus.of (StoneCech X)
 #align StoneCech_obj stoneCechObj
+-/
 
+/- warning: stone_cech_equivalence -> stoneCechEquivalence is a dubious translation:
+lean 3 declaration is
+  forall (X : TopCat.{u1}) (Y : CompHaus.{u1}), Equiv.{succ u1, succ u1} (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})) (stoneCechObj.{u1} X) Y) (Quiver.Hom.{succ u1, succ u1} TopCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} TopCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} TopCat.{u1} TopCat.largeCategory.{u1})) X (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} TopCat.{u1} TopCat.largeCategory.{u1} compHausToTop.{u1} Y))
+but is expected to have type
+  forall (X : TopCat.{u1}) (Y : CompHaus.{u1}), Equiv.{succ u1, succ u1} (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})) (stoneCechObj.{u1} X) Y) (Quiver.Hom.{succ u1, succ u1} TopCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} TopCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} TopCat.{u1} instTopCatLargeCategory.{u1})) X (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})) TopCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} TopCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} TopCat.{u1} instTopCatLargeCategory.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} TopCat.{u1} instTopCatLargeCategory.{u1} compHausToTop.{u1}) Y))
+Case conversion may be inaccurate. Consider using '#align stone_cech_equivalence stoneCechEquivalenceₓ'. -/
 /-- (Implementation) The bijection of homsets to establish the reflective adjunction of compact
 Hausdorff spaces in topological spaces.
 -/
@@ -159,38 +199,55 @@ noncomputable def stoneCechEquivalence (X : TopCat.{u}) (Y : CompHaus.{u}) :
     exact congr_fun (stoneCechExtend_extends hf) _
 #align stone_cech_equivalence stoneCechEquivalence
 
+#print topToCompHaus /-
 /-- The Stone-Cech compactification functor from topological spaces to compact Hausdorff spaces,
 left adjoint to the inclusion functor.
 -/
 noncomputable def topToCompHaus : TopCat.{u} ⥤ CompHaus.{u} :=
   Adjunction.leftAdjointOfEquiv stoneCechEquivalence.{u} fun _ _ _ _ _ => rfl
 #align Top_to_CompHaus topToCompHaus
+-/
 
+/- warning: Top_to_CompHaus_obj -> topToCompHaus_obj is a dubious translation:
+lean 3 declaration is
+  forall (X : TopCat.{u1}), Eq.{succ (succ u1)} Type.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CompHaus.{u1} Type.{u1} CompHaus.hasCoeToSort.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} TopCat.{u1} TopCat.largeCategory.{u1} CompHaus.{u1} CompHaus.category.{u1} topToCompHaus.{u1} X)) (StoneCech.{u1} (coeSort.{succ (succ u1), succ (succ u1)} TopCat.{u1} Type.{u1} TopCat.hasCoeToSort.{u1} X) (TopCat.topologicalSpace.{u1} X))
+but is expected to have type
+  forall (X : TopCat.{u1}), Eq.{succ (succ u1)} Type.{u1} (CategoryTheory.Bundled.α.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} TopCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} TopCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} TopCat.{u1} instTopCatLargeCategory.{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} TopCat.{u1} instTopCatLargeCategory.{u1} CompHaus.{u1} CompHaus.category.{u1} topToCompHaus.{u1}) X))) (StoneCech.{u1} (CategoryTheory.Bundled.α.{u1, u1} TopologicalSpace.{u1} X) (TopCat.topologicalSpace_coe.{u1} X))
+Case conversion may be inaccurate. Consider using '#align Top_to_CompHaus_obj topToCompHaus_objₓ'. -/
 theorem topToCompHaus_obj (X : TopCat) : ↥(topToCompHaus.obj X) = StoneCech X :=
   rfl
 #align Top_to_CompHaus_obj topToCompHaus_obj
 
+#print compHausToTop.reflective /-
 /-- The category of compact Hausdorff spaces is reflective in the category of topological spaces.
 -/
 noncomputable instance compHausToTop.reflective : Reflective compHausToTop
     where toIsRightAdjoint := ⟨topToCompHaus, Adjunction.adjunctionOfEquivLeft _ _⟩
 #align CompHaus_to_Top.reflective compHausToTop.reflective
+-/
 
+#print compHausToTop.createsLimits /-
 noncomputable instance compHausToTop.createsLimits : CreatesLimits compHausToTop :=
   monadicCreatesLimits _
 #align CompHaus_to_Top.creates_limits compHausToTop.createsLimits
+-/
 
+#print CompHaus.hasLimits /-
 instance CompHaus.hasLimits : Limits.HasLimits CompHaus :=
   has_limits_of_has_limits_creates_limits compHausToTop
 #align CompHaus.has_limits CompHaus.hasLimits
+-/
 
+#print CompHaus.hasColimits /-
 instance CompHaus.hasColimits : Limits.HasColimits CompHaus :=
   has_colimits_of_reflective compHausToTop
 #align CompHaus.has_colimits CompHaus.hasColimits
+-/
 
 namespace CompHaus
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:107:6: warning: expanding binder group (i j) -/
+#print CompHaus.limitCone /-
 /-- An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
 `Top.limit_cone`. -/
 def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F
@@ -229,7 +286,9 @@ def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Li
         simp only [comp_apply, functor.const_obj_map, id_apply]
         exact (hx f).symm }
 #align CompHaus.limit_cone CompHaus.limitCone
+-/
 
+#print CompHaus.limitConeIsLimit /-
 /-- The limit cone `CompHaus.limit_cone F` is indeed a limit cone. -/
 def limitConeIsLimit {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) :
     Limits.IsLimit (limitCone F)
@@ -237,7 +296,14 @@ def limitConeIsLimit {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u
   lift S := (TopCat.limitConeIsLimit (F ⋙ compHausToTop)).lift (compHausToTop.mapCone S)
   uniq S m h := (TopCat.limitConeIsLimit _).uniq (compHausToTop.mapCone S) _ h
 #align CompHaus.limit_cone_is_limit CompHaus.limitConeIsLimit
+-/
 
+/- warning: CompHaus.epi_iff_surjective -> CompHaus.epi_iff_surjective is a dubious translation:
+lean 3 declaration is
+  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), Iff (CategoryTheory.Epi.{u1, succ u1} CompHaus.{u1} CompHaus.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} 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} Y)) (coeFn.{succ u1, succ u1} (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 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{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} 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} 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} Y))) f))
+but is expected to have type
+  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), Iff (CategoryTheory.Epi.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y f) (Function.Surjective.{succ u1, succ 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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X) (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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) Y) (Prefunctor.map.{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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X Y f))
+Case conversion may be inaccurate. Consider using '#align CompHaus.epi_iff_surjective CompHaus.epi_iff_surjectiveₓ'. -/
 theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f :=
   by
   constructor
@@ -274,6 +340,12 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
     apply (forget CompHaus).epi_of_epi_map
 #align CompHaus.epi_iff_surjective CompHaus.epi_iff_surjective
 
+/- warning: CompHaus.mono_iff_injective -> CompHaus.mono_iff_injective is a dubious translation:
+lean 3 declaration is
+  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), Iff (CategoryTheory.Mono.{u1, succ u1} CompHaus.{u1} CompHaus.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} 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} Y)) (coeFn.{succ u1, succ u1} (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 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{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} 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} 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} 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} Y)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} X)) (CategoryTheory.Bundled.str.{u1, u1} TopologicalSpace.{u1} (CompHaus.toTop.{u1} Y))) f))
+but is expected to have type
+  forall {X : CompHaus.{u1}} {Y : CompHaus.{u1}} (f : 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 Y), Iff (CategoryTheory.Mono.{u1, succ u1} CompHaus.{u1} CompHaus.category.{u1} X Y f) (Function.Injective.{succ u1, succ 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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X) (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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) Y) (Prefunctor.map.{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})) 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} CompHaus.{u1} CompHaus.category.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} CompHaus.{u1} CompHaus.category.{u1} CompHaus.concreteCategory.{u1})) X Y f))
+Case conversion may be inaccurate. Consider using '#align CompHaus.mono_iff_injective CompHaus.mono_iff_injectiveₓ'. -/
 theorem mono_iff_injective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f :=
   by
   constructor

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Adam Topaz, Bhavik Mehta
 
 ! This file was ported from Lean 3 source module topology.category.CompHaus.basic
-! leanprover-community/mathlib commit bcfa726826abd57587355b4b5b7e78ad6527b7e4
+! leanprover-community/mathlib commit 178a32653e369dce2da68dc6b2694e385d484ef1
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -12,7 +12,7 @@ import Mathbin.CategoryTheory.Adjunction.Reflective
 import Mathbin.Topology.StoneCech
 import Mathbin.CategoryTheory.Monad.Limits
 import Mathbin.Topology.UrysohnsLemma
-import Mathbin.Topology.Category.Top.Limits
+import Mathbin.Topology.Category.Top.Limits.Basic
 
 /-!
 # The category of Compact Hausdorff Spaces

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

@@ -195,8 +195,8 @@ namespace CompHaus
 `Top.limit_cone`. -/
 def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Limits.Cone F
     where
-  x :=
-    { toTop := (TopCat.limitCone (F ⋙ compHausToTop)).x
+  pt :=
+    { toTop := (TopCat.limitCone (F ⋙ compHausToTop)).pt
       IsCompact :=
         by
         show CompactSpace ↥{ u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), (F.map f) (u i) = u j }

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

@@ -181,11 +181,11 @@ noncomputable instance compHausToTop.createsLimits : CreatesLimits compHausToTop
 #align CompHaus_to_Top.creates_limits compHausToTop.createsLimits
 
 instance CompHaus.hasLimits : Limits.HasLimits CompHaus :=
-  hasLimitsOfHasLimitsCreatesLimits compHausToTop
+  has_limits_of_has_limits_creates_limits compHausToTop
 #align CompHaus.has_limits CompHaus.hasLimits
 
 instance CompHaus.hasColimits : Limits.HasColimits CompHaus :=
-  hasColimitsOfReflective compHausToTop
+  has_colimits_of_reflective compHausToTop
 #align CompHaus.has_colimits CompHaus.hasColimits
 
 namespace CompHaus
@@ -235,7 +235,7 @@ def limitConeIsLimit {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u
     Limits.IsLimit (limitCone F)
     where
   lift S := (TopCat.limitConeIsLimit (F ⋙ compHausToTop)).lift (compHausToTop.mapCone S)
-  uniq' S m h := (TopCat.limitConeIsLimit _).uniq (compHausToTop.mapCone S) _ h
+  uniq S m h := (TopCat.limitConeIsLimit _).uniq (compHausToTop.mapCone S) _ h
 #align CompHaus.limit_cone_is_limit CompHaus.limitConeIsLimit
 
 theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Function.Surjective f :=

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

Moves definition of and lemmas related to Set.Subsingleton and Set.Nontrivial to a new file, so that Basic can be shorter.

@@ -8,7 +8,7 @@ import Mathlib.Topology.StoneCech
 import Mathlib.CategoryTheory.Monad.Limits
 import Mathlib.Topology.UrysohnsLemma
 import Mathlib.Topology.Category.TopCat.Limits.Basic
-import Mathlib.Data.Set.Basic
+import Mathlib.Data.Set.Subsingleton
 
 #align_import topology.category.CompHaus.basic from "leanprover-community/mathlib"@"178a32653e369dce2da68dc6b2694e385d484ef1"
 

@@ -390,3 +390,15 @@ set_option linter.uppercaseLean3 false in
 #align CompHaus.mono_iff_injective CompHaus.mono_iff_injective
 
 end CompHaus
+
+/--
+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 CompHausMax.{w, w'} := CompHaus.{max w w'}

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

@@ -185,11 +185,11 @@ def compHausToTop : CompHaus.{u} ⥤ TopCat.{u} :=
 set_option linter.uppercaseLean3 false in
 #align CompHaus_to_Top compHausToTop
 
-instance : Full compHausToTop :=
-  show Full <| inducedFunctor _ from inferInstance
+instance : compHausToTop.Full  :=
+  show (inducedFunctor _).Full from inferInstance
 
-instance : Faithful compHausToTop :=
-  show Faithful <| inducedFunctor _ from inferInstance
+instance : compHausToTop.Faithful :=
+  show (inducedFunctor _).Faithful from inferInstance
 
 -- Porting note (#10754): Adding instance
 instance (X : CompHaus) : CompactSpace (compHausToTop.obj X) :=
@@ -199,7 +199,7 @@ instance (X : CompHaus) : CompactSpace (compHausToTop.obj X) :=
 instance (X : CompHaus) : T2Space (compHausToTop.obj X) :=
   show T2Space X.toTop from inferInstance
 
-instance CompHaus.forget_reflectsIsomorphisms : ReflectsIsomorphisms (forget CompHaus.{u}) :=
+instance CompHaus.forget_reflectsIsomorphisms : (forget CompHaus.{u}).ReflectsIsomorphisms :=
   ⟨by intro A B f hf; exact CompHaus.isIso_of_bijective _ ((isIso_iff_bijective f).mp hf)⟩
 set_option linter.uppercaseLean3 false in
 #align CompHaus.forget_reflects_isomorphisms CompHaus.forget_reflectsIsomorphisms

Purely automatic replacement. If this is in any way controversial; I'm happy to just close this PR.

@@ -39,9 +39,9 @@ structure CompHaus where
   /-- The underlying topological space of an object of `CompHaus`. -/
   toTop : TopCat
   -- Porting note: Renamed field.
-  /-- The underlying topological space is compact.-/
+  /-- The underlying topological space is compact. -/
   [is_compact : CompactSpace toTop]
-  /-- The underlying topological space is T2.-/
+  /-- The underlying topological space is T2. -/
   [is_hausdorff : T2Space toTop]
 set_option linter.uppercaseLean3 false in
 #align CompHaus CompHaus

Classifies by adding issue number #10754 to porting notes claiming anything semantically equivalent to:

• "added instance"
• "new instance"
• "adding instance"
• "had to add this instance manually"

@@ -97,15 +97,15 @@ theorem coe_of : (CompHaus.of X : Type _) = X :=
 set_option linter.uppercaseLean3 false in
 #align CompHaus.coe_of CompHaus.coe_of
 
--- Porting note: Adding instance
+-- Porting note (#10754): Adding instance
 instance (X : CompHaus.{u}) : TopologicalSpace ((forget CompHaus).obj X) :=
   show TopologicalSpace X.toTop from inferInstance
 
--- Porting note: Adding instance
+-- Porting note (#10754): Adding instance
 instance (X : CompHaus.{u}) : CompactSpace ((forget CompHaus).obj X) :=
   show CompactSpace X.toTop from inferInstance
 
--- Porting note: Adding instance
+-- Porting note (#10754): Adding instance
 instance (X : CompHaus.{u}) : T2Space ((forget CompHaus).obj X) :=
   show T2Space X.toTop from inferInstance
 
@@ -191,11 +191,11 @@ instance : Full compHausToTop :=
 instance : Faithful compHausToTop :=
   show Faithful <| inducedFunctor _ from inferInstance
 
--- Porting note: Adding instance
+-- Porting note (#10754): Adding instance
 instance (X : CompHaus) : CompactSpace (compHausToTop.obj X) :=
   show CompactSpace X.toTop from inferInstance
 
--- Porting note: Adding instance
+-- Porting note (#10754): Adding instance
 instance (X : CompHaus) : T2Space (compHausToTop.obj X) :=
   show T2Space X.toTop from inferInstance
 

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

@@ -364,7 +364,7 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
       change 0 = φ (f x)
       simp only [hφ0 (Set.mem_range_self x), Pi.zero_apply]
     apply_fun fun e => (e y).down.1 at H
-    dsimp at H
+    dsimp [Z] at H
     change 0 = φ y at H
     simp only [hφ1 (Set.mem_singleton y), Pi.one_apply] at H
     exact zero_ne_one H

• Remove Data.Set.Basic from scripts/noshake.json.
• Remove an exception that was used by examples only, move these examples to a new test file.
• Drop an exception for Order.Filter.Basic dependency on Control.Traversable.Instances, as the relevant parts were moved to Order.Filter.ListTraverse.
• Run lake exe shake --fix.

@@ -8,6 +8,7 @@ import Mathlib.Topology.StoneCech
 import Mathlib.CategoryTheory.Monad.Limits
 import Mathlib.Topology.UrysohnsLemma
 import Mathlib.Topology.Category.TopCat.Limits.Basic
+import Mathlib.Data.Set.Basic
 
 #align_import topology.category.CompHaus.basic from "leanprover-community/mathlib"@"178a32653e369dce2da68dc6b2694e385d484ef1"
 

Three particular examples which caught my eye; not exhaustive.

@@ -340,7 +340,7 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
       rw [Set.disjoint_singleton_right]
       rintro ⟨y', hy'⟩
       exact hy y' hy'
-    obtain ⟨φ, hφ0, hφ1, hφ01⟩ := exists_continuous_zero_one_of_closed hC hD hCD
+    obtain ⟨φ, hφ0, hφ1, hφ01⟩ := exists_continuous_zero_one_of_isClosed hC hD hCD
     haveI : CompactSpace (ULift.{u} <| Set.Icc (0 : ℝ) 1) := Homeomorph.ulift.symm.compactSpace
     haveI : T2Space (ULift.{u} <| Set.Icc (0 : ℝ) 1) := Homeomorph.ulift.symm.t2Space
     let Z := of (ULift.{u} <| Set.Icc (0 : ℝ) 1)

@@ -256,8 +256,8 @@ set_option linter.uppercaseLean3 false in
 
 /-- The category of compact Hausdorff spaces is reflective in the category of topological spaces.
 -/
-noncomputable instance compHausToTop.reflective : Reflective compHausToTop
-    where toIsRightAdjoint := ⟨topToCompHaus, Adjunction.adjunctionOfEquivLeft _ _⟩
+noncomputable instance compHausToTop.reflective : Reflective compHausToTop where
+  toIsRightAdjoint := ⟨topToCompHaus, Adjunction.adjunctionOfEquivLeft _ _⟩
 set_option linter.uppercaseLean3 false in
 #align CompHaus_to_Top.reflective compHausToTop.reflective
 

• Rename NormalSpace to T4Space.
• Add NormalSpace, a version without the T1Space assumption.
• Adjust some theorems.
• Supersedes thus closes #6892.
• Add some instance cycles, see #2030

@@ -340,8 +340,6 @@ theorem epi_iff_surjective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Epi f ↔ Functi
       rw [Set.disjoint_singleton_right]
       rintro ⟨y', hy'⟩
       exact hy y' hy'
-    --haveI : NormalSpace Y.toTop := normalOfCompactT2
-    haveI : NormalSpace ((forget CompHaus).obj Y) := normalOfCompactT2
     obtain ⟨φ, hφ0, hφ1, hφ01⟩ := exists_continuous_zero_one_of_closed hC hD hCD
     haveI : CompactSpace (ULift.{u} <| Set.Icc (0 : ℝ) 1) := Homeomorph.ulift.symm.compactSpace
     haveI : T2Space (ULift.{u} <| Set.Icc (0 : ℝ) 1) := Homeomorph.ulift.symm.t2Space

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

This has nice performance benefits.

@@ -50,7 +50,7 @@ namespace CompHaus
 instance : Inhabited CompHaus :=
   ⟨{ toTop := { α := PEmpty } }⟩
 
-instance : CoeSort CompHaus (Type _) :=
+instance : CoeSort CompHaus (Type*) :=
   ⟨fun X => X.toTop⟩
 
 instance {X : CompHaus} : CompactSpace X :=
@@ -72,13 +72,13 @@ set_option linter.uppercaseLean3 false in
 /-
 -- Porting note: This is now a syntactic tautology.
 @[simp]
-theorem coe_toTop {X : CompHaus} : (X.toTop : Type _) = X :=
+theorem coe_toTop {X : CompHaus} : (X.toTop : Type*) = X :=
   rfl
 set_option linter.uppercaseLean3 false in
 #align CompHaus.coe_to_Top CompHaus.coe_toTop
 -/
 
-variable (X : Type _) [TopologicalSpace X] [CompactSpace X] [T2Space X]
+variable (X : Type*) [TopologicalSpace X] [CompactSpace X] [T2Space X]
 
 /-- A constructor for objects of the category `CompHaus`,
 taking a type, and bundling the compact Hausdorff topology

Co-authored by:

• Riccardo Brasca [riccardo.brasca@gmail.com](mailto:riccardo.brasca@gmail.com) @riccardobrasca
• Filippo A. E. Nuccio [filippo.nuccio@univ-st-etienne.fr](mailto:filippo.nuccio@univ-st-etienne.fr) @faenuccio

We add some more API for the compatibility of explicit and abstract limits in CompHaus This work was done during the 2023 Copenhagen masterclass on formalisation of condensed mathematics. Numerous participants contributed.

@@ -139,6 +139,41 @@ noncomputable def isoOfBijective {X Y : CompHaus.{u}} (f : X ⟶ Y) (bij : Funct
 set_option linter.uppercaseLean3 false in
 #align CompHaus.iso_of_bijective CompHaus.isoOfBijective
 
+/-- Construct an isomorphism from a homeomorphism. -/
+@[simps hom inv]
+def isoOfHomeo {X Y : CompHaus.{u}} (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
+
+/-- Construct a homeomorphism from an isomorphism. -/
+@[simps]
+def homeoOfIso {X Y : CompHaus.{u}} (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
+
+/-- The equivalence between isomorphisms in `CompHaus` and homeomorphisms
+of topological spaces. -/
+@[simps]
+def isoEquivHomeo {X Y : CompHaus.{u}} : (X ≅ Y) ≃ (X ≃ₜ Y) where
+  toFun := homeoOfIso
+  invFun := isoOfHomeo
+  left_inv f := by
+    ext
+    rfl
+  right_inv f := by
+    ext
+    rfl
+
 end CompHaus
 
 /-- The fully faithful embedding of `CompHaus` in `TopCat`. -/

• 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 Adam Topaz. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Adam Topaz, Bhavik Mehta
-
-! This file was ported from Lean 3 source module topology.category.CompHaus.basic
-! leanprover-community/mathlib commit 178a32653e369dce2da68dc6b2694e385d484ef1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Adjunction.Reflective
 import Mathlib.Topology.StoneCech
@@ -14,6 +9,8 @@ import Mathlib.CategoryTheory.Monad.Limits
 import Mathlib.Topology.UrysohnsLemma
 import Mathlib.Topology.Category.TopCat.Limits.Basic
 
+#align_import topology.category.CompHaus.basic from "leanprover-community/mathlib"@"178a32653e369dce2da68dc6b2694e385d484ef1"
+
 /-!
 # The category of Compact Hausdorff Spaces
 

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

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

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

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

@@ -167,7 +167,7 @@ instance (X : CompHaus) : T2Space (compHausToTop.obj X) :=
   show T2Space X.toTop from inferInstance
 
 instance CompHaus.forget_reflectsIsomorphisms : ReflectsIsomorphisms (forget CompHaus.{u}) :=
-  ⟨by intro A B f hf ; exact CompHaus.isIso_of_bijective _ ((isIso_iff_bijective f).mp hf)⟩
+  ⟨by intro A B f hf; exact CompHaus.isIso_of_bijective _ ((isIso_iff_bijective f).mp hf)⟩
 set_option linter.uppercaseLean3 false in
 #align CompHaus.forget_reflects_isomorphisms CompHaus.forget_reflectsIsomorphisms
 

Changes are of the form

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

@@ -351,7 +351,7 @@ theorem mono_iff_injective {X Y : CompHaus.{u}} (f : X ⟶ Y) : Mono f ↔ Funct
       ext
       exact h
     rw [cancel_mono] at this
-    apply_fun fun e => e PUnit.unit  at this
+    apply_fun fun e => e PUnit.unit at this
     exact this
   · rw [← CategoryTheory.mono_iff_injective]
     apply (forget CompHaus).mono_of_mono_map

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -101,15 +101,15 @@ set_option linter.uppercaseLean3 false in
 
 -- Porting note: Adding instance
 instance (X : CompHaus.{u}) : TopologicalSpace ((forget CompHaus).obj X) :=
-show TopologicalSpace X.toTop from inferInstance
+  show TopologicalSpace X.toTop from inferInstance
 
 -- Porting note: Adding instance
 instance (X : CompHaus.{u}) : CompactSpace ((forget CompHaus).obj X) :=
-show CompactSpace X.toTop from inferInstance
+  show CompactSpace X.toTop from inferInstance
 
 -- Porting note: Adding instance
 instance (X : CompHaus.{u}) : T2Space ((forget CompHaus).obj X) :=
-show T2Space X.toTop from inferInstance
+  show T2Space X.toTop from inferInstance
 
 /-- Any continuous function on compact Hausdorff spaces is a closed map. -/
 theorem isClosedMap {X Y : CompHaus.{u}} (f : X ⟶ Y) : IsClosedMap f := fun _ hC =>
@@ -153,18 +153,18 @@ set_option linter.uppercaseLean3 false in
 #align CompHaus_to_Top compHausToTop
 
 instance : Full compHausToTop :=
-show Full <| inducedFunctor _ from inferInstance
+  show Full <| inducedFunctor _ from inferInstance
 
 instance : Faithful compHausToTop :=
-show Faithful <| inducedFunctor _ from inferInstance
+  show Faithful <| inducedFunctor _ from inferInstance
 
 -- Porting note: Adding instance
 instance (X : CompHaus) : CompactSpace (compHausToTop.obj X) :=
-show CompactSpace X.toTop from inferInstance
+  show CompactSpace X.toTop from inferInstance
 
 -- Porting note: Adding instance
 instance (X : CompHaus) : T2Space (compHausToTop.obj X) :=
-show T2Space X.toTop from inferInstance
+  show T2Space X.toTop from inferInstance
 
 instance CompHaus.forget_reflectsIsomorphisms : ReflectsIsomorphisms (forget CompHaus.{u}) :=
   ⟨by intro A B f hf ; exact CompHaus.isIso_of_bijective _ ((isIso_iff_bijective f).mp hf)⟩

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>

@@ -235,12 +235,12 @@ set_option linter.uppercaseLean3 false in
 #align CompHaus_to_Top.creates_limits compHausToTop.createsLimits
 
 instance CompHaus.hasLimits : Limits.HasLimits CompHaus :=
-  has_limits_of_has_limits_creates_limits compHausToTop
+  hasLimits_of_hasLimits_createsLimits compHausToTop
 set_option linter.uppercaseLean3 false in
 #align CompHaus.has_limits CompHaus.hasLimits
 
 instance CompHaus.hasColimits : Limits.HasColimits CompHaus :=
-  has_colimits_of_reflective compHausToTop
+  hasColimits_of_reflective compHausToTop
 set_option linter.uppercaseLean3 false in
 #align CompHaus.has_colimits CompHaus.hasColimits
 

@@ -12,7 +12,7 @@ import Mathlib.CategoryTheory.Adjunction.Reflective
 import Mathlib.Topology.StoneCech
 import Mathlib.CategoryTheory.Monad.Limits
 import Mathlib.Topology.UrysohnsLemma
-import Mathlib.Topology.Category.Top.Limits.Basic
+import Mathlib.Topology.Category.TopCat.Limits.Basic
 
 /-!
 # The category of Compact Hausdorff Spaces

As discussed on Zulip

Renames

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

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

@@ -261,13 +261,13 @@ def limitCone {J : Type v} [SmallCategory J] (F : J ⥤ CompHaus.{max v u}) : Li
           { u : ∀ j, F.obj j | ∀ {i j : J} (f : i ⟶ j), F.map f (u i) = u j } =
             ⋂ (i : J) (j : J) (f : i ⟶ j), { u | F.map f (u i) = u j } := by
           ext1
-          simp only [Set.mem_interᵢ, Set.mem_setOf_eq]
+          simp only [Set.mem_iInter, Set.mem_setOf_eq]
         rw [this]
-        apply isClosed_interᵢ
+        apply isClosed_iInter
         intro i
-        apply isClosed_interᵢ
+        apply isClosed_iInter
         intro j
-        apply isClosed_interᵢ
+        apply isClosed_iInter
         intro f
         apply isClosed_eq
         · exact (ContinuousMap.continuous (F.map f)).comp (continuous_apply i)

Relatively straightforward port.

Co-authored-by: Scott Morrison <scott@tqft.net>