category_theory.equivalence ⟷ Mathlib.CategoryTheory.Equivalence

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

@@ -851,21 +851,21 @@ instance (priority := 100) faithfulOfEquivalence (F : C ⥤ D)
 #align category_theory.equivalence.faithful_of_equivalence CategoryTheory.Equivalence.faithfulOfEquivalence
 -/
 
-#print CategoryTheory.Equivalence.fullOfEquivalence /-
+#print CategoryTheory.Equivalence.full_of_equivalence /-
 -- see Note [lower instance priority]
 /-- An equivalence is full.
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-instance (priority := 100) fullOfEquivalence (F : C ⥤ D) [CategoryTheory.Functor.IsEquivalence F] :
-    CategoryTheory.Functor.Full F
+instance (priority := 100) full_of_equivalence (F : C ⥤ D)
+    [CategoryTheory.Functor.IsEquivalence F] : CategoryTheory.Functor.Full F
     where
   preimage X Y f := F.asEquivalence.Unit.app X ≫ F.inv.map f ≫ F.asEquivalence.unitInv.app Y
   witness' X Y f :=
     F.inv.map_injective <| by
       simpa only [is_equivalence.inv_fun_map, assoc, iso.inv_hom_id_app_assoc,
         iso.inv_hom_id_app] using comp_id _
-#align category_theory.equivalence.full_of_equivalence CategoryTheory.Equivalence.fullOfEquivalence
+#align category_theory.equivalence.full_of_equivalence CategoryTheory.Equivalence.full_of_equivalence
 -/
 
 @[simps]

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

@@ -551,9 +551,9 @@ end
 
 end Equivalence
 
-#print CategoryTheory.IsEquivalence /-
+#print CategoryTheory.Functor.IsEquivalence /-
 /-- A functor that is part of a (half) adjoint equivalence -/
-class IsEquivalence (F : C ⥤ D) where mk' ::
+class CategoryTheory.Functor.IsEquivalence (F : C ⥤ D) where mk' ::
   inverse : D ⥤ C
   unitIso : 𝟭 C ≅ F ⋙ inverse
   counitIso : inverse ⋙ F ≅ 𝟭 D
@@ -562,33 +562,36 @@ class IsEquivalence (F : C ⥤ D) where mk' ::
       F.map ((unit_iso.Hom : 𝟭 C ⟶ F ⋙ inverse).app X) ≫ counit_iso.Hom.app (F.obj X) =
         𝟙 (F.obj X) := by
     obviously
-#align category_theory.is_equivalence CategoryTheory.IsEquivalence
+#align category_theory.is_equivalence CategoryTheory.Functor.IsEquivalence
 -/
 
 attribute [simp, reassoc] is_equivalence.functor_unit_iso_comp
 
 namespace IsEquivalence
 
-#print CategoryTheory.IsEquivalence.ofEquivalence /-
-instance ofEquivalence (F : C ≌ D) : IsEquivalence F.Functor :=
+#print CategoryTheory.Functor.IsEquivalence.ofEquivalence /-
+instance CategoryTheory.Functor.IsEquivalence.ofEquivalence (F : C ≌ D) :
+    CategoryTheory.Functor.IsEquivalence F.Functor :=
   { F with }
-#align category_theory.is_equivalence.of_equivalence CategoryTheory.IsEquivalence.ofEquivalence
+#align category_theory.is_equivalence.of_equivalence CategoryTheory.Functor.IsEquivalence.ofEquivalence
 -/
 
-#print CategoryTheory.IsEquivalence.ofEquivalenceInverse /-
-instance ofEquivalenceInverse (F : C ≌ D) : IsEquivalence F.inverse :=
-  IsEquivalence.ofEquivalence F.symm
-#align category_theory.is_equivalence.of_equivalence_inverse CategoryTheory.IsEquivalence.ofEquivalenceInverse
+#print CategoryTheory.Functor.IsEquivalence.ofEquivalenceInverse /-
+instance CategoryTheory.Functor.IsEquivalence.ofEquivalenceInverse (F : C ≌ D) :
+    CategoryTheory.Functor.IsEquivalence F.inverse :=
+  CategoryTheory.Functor.IsEquivalence.ofEquivalence F.symm
+#align category_theory.is_equivalence.of_equivalence_inverse CategoryTheory.Functor.IsEquivalence.ofEquivalenceInverse
 -/
 
 open Equivalence
 
-#print CategoryTheory.IsEquivalence.mk /-
+#print CategoryTheory.Functor.IsEquivalence.mk /-
 /-- To see that a functor is an equivalence, it suffices to provide an inverse functor `G` such that
     `F ⋙ G` and `G ⋙ F` are naturally isomorphic to identity functors. -/
-protected def mk {F : C ⥤ D} (G : D ⥤ C) (η : 𝟭 C ≅ F ⋙ G) (ε : G ⋙ F ≅ 𝟭 D) : IsEquivalence F :=
+protected def CategoryTheory.Functor.IsEquivalence.mk {F : C ⥤ D} (G : D ⥤ C) (η : 𝟭 C ≅ F ⋙ G)
+    (ε : G ⋙ F ≅ 𝟭 D) : CategoryTheory.Functor.IsEquivalence F :=
   ⟨G, adjointifyη η ε, ε, adjointify_η_ε η ε⟩
-#align category_theory.is_equivalence.mk CategoryTheory.IsEquivalence.mk
+#align category_theory.is_equivalence.mk CategoryTheory.Functor.IsEquivalence.mk
 -/
 
 end IsEquivalence
@@ -597,64 +600,68 @@ namespace Functor
 
 #print CategoryTheory.Functor.asEquivalence /-
 /-- Interpret a functor that is an equivalence as an equivalence. -/
-def asEquivalence (F : C ⥤ D) [IsEquivalence F] : C ≌ D :=
-  ⟨F, IsEquivalence.inverse F, IsEquivalence.unitIso, IsEquivalence.counitIso,
-    IsEquivalence.functor_unitIso_comp⟩
+def asEquivalence (F : C ⥤ D) [CategoryTheory.Functor.IsEquivalence F] : C ≌ D :=
+  ⟨F, CategoryTheory.Functor.IsEquivalence.inverse F, CategoryTheory.Functor.IsEquivalence.unitIso,
+    CategoryTheory.Functor.IsEquivalence.counitIso,
+    CategoryTheory.Functor.IsEquivalence.functor_unitIso_comp⟩
 #align category_theory.functor.as_equivalence CategoryTheory.Functor.asEquivalence
 -/
 
 #print CategoryTheory.Functor.isEquivalenceRefl /-
-instance isEquivalenceRefl : IsEquivalence (𝟭 C) :=
-  IsEquivalence.ofEquivalence Equivalence.refl
+instance isEquivalenceRefl : CategoryTheory.Functor.IsEquivalence (𝟭 C) :=
+  CategoryTheory.Functor.IsEquivalence.ofEquivalence Equivalence.refl
 #align category_theory.functor.is_equivalence_refl CategoryTheory.Functor.isEquivalenceRefl
 -/
 
 #print CategoryTheory.Functor.inv /-
 /-- The inverse functor of a functor that is an equivalence. -/
-def inv (F : C ⥤ D) [IsEquivalence F] : D ⥤ C :=
-  IsEquivalence.inverse F
+def inv (F : C ⥤ D) [CategoryTheory.Functor.IsEquivalence F] : D ⥤ C :=
+  CategoryTheory.Functor.IsEquivalence.inverse F
 #align category_theory.functor.inv CategoryTheory.Functor.inv
 -/
 
 #print CategoryTheory.Functor.isEquivalenceInv /-
-instance isEquivalenceInv (F : C ⥤ D) [IsEquivalence F] : IsEquivalence F.inv :=
-  IsEquivalence.ofEquivalence F.asEquivalence.symm
+instance isEquivalenceInv (F : C ⥤ D) [CategoryTheory.Functor.IsEquivalence F] :
+    CategoryTheory.Functor.IsEquivalence F.inv :=
+  CategoryTheory.Functor.IsEquivalence.ofEquivalence F.asEquivalence.symm
 #align category_theory.functor.is_equivalence_inv CategoryTheory.Functor.isEquivalenceInv
 -/
 
 #print CategoryTheory.Functor.asEquivalence_functor /-
 @[simp]
-theorem asEquivalence_functor (F : C ⥤ D) [IsEquivalence F] : F.asEquivalence.Functor = F :=
+theorem asEquivalence_functor (F : C ⥤ D) [CategoryTheory.Functor.IsEquivalence F] :
+    F.asEquivalence.Functor = F :=
   rfl
 #align category_theory.functor.as_equivalence_functor CategoryTheory.Functor.asEquivalence_functor
 -/
 
 #print CategoryTheory.Functor.asEquivalence_inverse /-
 @[simp]
-theorem asEquivalence_inverse (F : C ⥤ D) [IsEquivalence F] : F.asEquivalence.inverse = inv F :=
+theorem asEquivalence_inverse (F : C ⥤ D) [CategoryTheory.Functor.IsEquivalence F] :
+    F.asEquivalence.inverse = inv F :=
   rfl
 #align category_theory.functor.as_equivalence_inverse CategoryTheory.Functor.asEquivalence_inverse
 -/
 
 #print CategoryTheory.Functor.asEquivalence_unit /-
 @[simp]
-theorem asEquivalence_unit {F : C ⥤ D} [h : IsEquivalence F] :
-    F.asEquivalence.unitIso = @IsEquivalence.unitIso _ _ h :=
+theorem asEquivalence_unit {F : C ⥤ D} [h : CategoryTheory.Functor.IsEquivalence F] :
+    F.asEquivalence.unitIso = @CategoryTheory.Functor.IsEquivalence.unitIso _ _ h :=
   rfl
 #align category_theory.functor.as_equivalence_unit CategoryTheory.Functor.asEquivalence_unit
 -/
 
 #print CategoryTheory.Functor.asEquivalence_counit /-
 @[simp]
-theorem asEquivalence_counit {F : C ⥤ D} [IsEquivalence F] :
-    F.asEquivalence.counitIso = IsEquivalence.counitIso :=
+theorem asEquivalence_counit {F : C ⥤ D} [CategoryTheory.Functor.IsEquivalence F] :
+    F.asEquivalence.counitIso = CategoryTheory.Functor.IsEquivalence.counitIso :=
   rfl
 #align category_theory.functor.as_equivalence_counit CategoryTheory.Functor.asEquivalence_counit
 -/
 
 #print CategoryTheory.Functor.inv_inv /-
 @[simp]
-theorem inv_inv (F : C ⥤ D) [IsEquivalence F] : inv (inv F) = F :=
+theorem inv_inv (F : C ⥤ D) [CategoryTheory.Functor.IsEquivalence F] : inv (inv F) = F :=
   rfl
 #align category_theory.functor.inv_inv CategoryTheory.Functor.inv_inv
 -/
@@ -662,9 +669,10 @@ theorem inv_inv (F : C ⥤ D) [IsEquivalence F] : inv (inv F) = F :=
 variable {E : Type u₃} [Category.{v₃} E]
 
 #print CategoryTheory.Functor.isEquivalenceTrans /-
-instance isEquivalenceTrans (F : C ⥤ D) (G : D ⥤ E) [IsEquivalence F] [IsEquivalence G] :
-    IsEquivalence (F ⋙ G) :=
-  IsEquivalence.ofEquivalence (Equivalence.trans (asEquivalence F) (asEquivalence G))
+instance isEquivalenceTrans (F : C ⥤ D) (G : D ⥤ E) [CategoryTheory.Functor.IsEquivalence F]
+    [CategoryTheory.Functor.IsEquivalence G] : CategoryTheory.Functor.IsEquivalence (F ⋙ G) :=
+  CategoryTheory.Functor.IsEquivalence.ofEquivalence
+    (Equivalence.trans (asEquivalence F) (asEquivalence G))
 #align category_theory.functor.is_equivalence_trans CategoryTheory.Functor.isEquivalenceTrans
 -/
 
@@ -702,31 +710,34 @@ end Equivalence
 
 namespace IsEquivalence
 
-#print CategoryTheory.IsEquivalence.fun_inv_map /-
+#print CategoryTheory.Functor.IsEquivalence.fun_inv_map /-
 @[simp]
-theorem fun_inv_map (F : C ⥤ D) [IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
+theorem CategoryTheory.Functor.IsEquivalence.fun_inv_map (F : C ⥤ D)
+    [CategoryTheory.Functor.IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
     F.map (F.inv.map f) = F.asEquivalence.counit.app X ≫ f ≫ F.asEquivalence.counitInv.app Y :=
   by
   erw [nat_iso.naturality_2]
   rfl
-#align category_theory.is_equivalence.fun_inv_map CategoryTheory.IsEquivalence.fun_inv_map
+#align category_theory.is_equivalence.fun_inv_map CategoryTheory.Functor.IsEquivalence.fun_inv_map
 -/
 
-#print CategoryTheory.IsEquivalence.inv_fun_map /-
+#print CategoryTheory.Functor.IsEquivalence.inv_fun_map /-
 @[simp]
-theorem inv_fun_map (F : C ⥤ D) [IsEquivalence F] (X Y : C) (f : X ⟶ Y) :
+theorem CategoryTheory.Functor.IsEquivalence.inv_fun_map (F : C ⥤ D)
+    [CategoryTheory.Functor.IsEquivalence F] (X Y : C) (f : X ⟶ Y) :
     F.inv.map (F.map f) = F.asEquivalence.unitInv.app X ≫ f ≫ F.asEquivalence.Unit.app Y :=
   by
   erw [nat_iso.naturality_1]
   rfl
-#align category_theory.is_equivalence.inv_fun_map CategoryTheory.IsEquivalence.inv_fun_map
+#align category_theory.is_equivalence.inv_fun_map CategoryTheory.Functor.IsEquivalence.inv_fun_map
 -/
 
-#print CategoryTheory.IsEquivalence.ofIso /-
+#print CategoryTheory.Functor.IsEquivalence.ofIso /-
 /-- When a functor `F` is an equivalence of categories, and `G` is isomorphic to `F`, then
 `G` is also an equivalence of categories. -/
 @[simps]
-def ofIso {F G : C ⥤ D} (e : F ≅ G) (hF : IsEquivalence F) : IsEquivalence G
+def CategoryTheory.Functor.IsEquivalence.ofIso {F G : C ⥤ D} (e : F ≅ G)
+    (hF : CategoryTheory.Functor.IsEquivalence F) : CategoryTheory.Functor.IsEquivalence G
     where
   inverse := hF.inverse
   unitIso := hF.unitIso ≪≫ NatIso.hcomp e (Iso.refl hF.inverse)
@@ -741,64 +752,73 @@ def ofIso {F G : C ⥤ D} (e : F ≅ G) (hF : IsEquivalence F) : IsEquivalence G
     erw [hF.counit_iso.hom.naturality]
     slice_lhs 1 2 => rw [functor_unit_iso_comp]
     simp only [functor.id_map, id_comp]
-#align category_theory.is_equivalence.of_iso CategoryTheory.IsEquivalence.ofIso
+#align category_theory.is_equivalence.of_iso CategoryTheory.Functor.IsEquivalence.ofIso
 -/
 
-#print CategoryTheory.IsEquivalence.ofIso_trans /-
+#print CategoryTheory.Functor.IsEquivalence.ofIso_trans /-
 /-- Compatibility of `of_iso` with the composition of isomorphisms of functors -/
-theorem ofIso_trans {F G H : C ⥤ D} (e : F ≅ G) (e' : G ≅ H) (hF : IsEquivalence F) :
-    ofIso e' (ofIso e hF) = ofIso (e ≪≫ e') hF :=
+theorem CategoryTheory.Functor.IsEquivalence.ofIso_trans {F G H : C ⥤ D} (e : F ≅ G) (e' : G ≅ H)
+    (hF : CategoryTheory.Functor.IsEquivalence F) :
+    CategoryTheory.Functor.IsEquivalence.ofIso e'
+        (CategoryTheory.Functor.IsEquivalence.ofIso e hF) =
+      CategoryTheory.Functor.IsEquivalence.ofIso (e ≪≫ e') hF :=
   by
   dsimp [of_iso]
   congr 1 <;> ext X <;> dsimp [nat_iso.hcomp]
   · simp only [id_comp, assoc, functor.map_comp]
   · simp only [Functor.map_id, comp_id, id_comp, assoc]
-#align category_theory.is_equivalence.of_iso_trans CategoryTheory.IsEquivalence.ofIso_trans
+#align category_theory.is_equivalence.of_iso_trans CategoryTheory.Functor.IsEquivalence.ofIso_trans
 -/
 
-#print CategoryTheory.IsEquivalence.ofIso_refl /-
+#print CategoryTheory.Functor.IsEquivalence.ofIso_refl /-
 /-- Compatibility of `of_iso` with identity isomorphisms of functors -/
-theorem ofIso_refl (F : C ⥤ D) (hF : IsEquivalence F) : ofIso (Iso.refl F) hF = hF :=
+theorem CategoryTheory.Functor.IsEquivalence.ofIso_refl (F : C ⥤ D)
+    (hF : CategoryTheory.Functor.IsEquivalence F) :
+    CategoryTheory.Functor.IsEquivalence.ofIso (Iso.refl F) hF = hF :=
   by
   rcases hF with ⟨Finv, Funit, Fcounit, Fcomp⟩
   dsimp [of_iso]
   congr 1 <;> ext X <;> dsimp [nat_iso.hcomp]
   · simp only [comp_id, map_id]
   · simp only [id_comp, map_id]
-#align category_theory.is_equivalence.of_iso_refl CategoryTheory.IsEquivalence.ofIso_refl
+#align category_theory.is_equivalence.of_iso_refl CategoryTheory.Functor.IsEquivalence.ofIso_refl
 -/
 
-#print CategoryTheory.IsEquivalence.equivOfIso /-
+#print CategoryTheory.Functor.IsEquivalence.equivOfIso /-
 /-- When `F` and `G` are two isomorphic functors, then `F` is an equivalence iff `G` is. -/
 @[simps]
-def equivOfIso {F G : C ⥤ D} (e : F ≅ G) : IsEquivalence F ≃ IsEquivalence G
+def CategoryTheory.Functor.IsEquivalence.equivOfIso {F G : C ⥤ D} (e : F ≅ G) :
+    CategoryTheory.Functor.IsEquivalence F ≃ CategoryTheory.Functor.IsEquivalence G
     where
-  toFun := ofIso e
-  invFun := ofIso e.symm
+  toFun := CategoryTheory.Functor.IsEquivalence.ofIso e
+  invFun := CategoryTheory.Functor.IsEquivalence.ofIso e.symm
   left_inv hF := by rw [of_iso_trans, iso.self_symm_id, of_iso_refl]
   right_inv hF := by rw [of_iso_trans, iso.symm_self_id, of_iso_refl]
-#align category_theory.is_equivalence.equiv_of_iso CategoryTheory.IsEquivalence.equivOfIso
+#align category_theory.is_equivalence.equiv_of_iso CategoryTheory.Functor.IsEquivalence.equivOfIso
 -/
 
-#print CategoryTheory.IsEquivalence.cancelCompRight /-
+#print CategoryTheory.Functor.IsEquivalence.cancelCompRight /-
 /-- If `G` and `F ⋙ G` are equivalence of categories, then `F` is also an equivalence. -/
 @[simp]
-def cancelCompRight {E : Type _} [Category E] (F : C ⥤ D) (G : D ⥤ E) (hG : IsEquivalence G)
-    (hGF : IsEquivalence (F ⋙ G)) : IsEquivalence F :=
-  ofIso (Functor.associator F G G.inv ≪≫ NatIso.hcomp (Iso.refl F) hG.unitIso.symm ≪≫ rightUnitor F)
+def CategoryTheory.Functor.IsEquivalence.cancelCompRight {E : Type _} [Category E] (F : C ⥤ D)
+    (G : D ⥤ E) (hG : CategoryTheory.Functor.IsEquivalence G)
+    (hGF : CategoryTheory.Functor.IsEquivalence (F ⋙ G)) : CategoryTheory.Functor.IsEquivalence F :=
+  CategoryTheory.Functor.IsEquivalence.ofIso
+    (Functor.associator F G G.inv ≪≫ NatIso.hcomp (Iso.refl F) hG.unitIso.symm ≪≫ rightUnitor F)
     (Functor.isEquivalenceTrans (F ⋙ G) G.inv)
-#align category_theory.is_equivalence.cancel_comp_right CategoryTheory.IsEquivalence.cancelCompRight
+#align category_theory.is_equivalence.cancel_comp_right CategoryTheory.Functor.IsEquivalence.cancelCompRight
 -/
 
-#print CategoryTheory.IsEquivalence.cancelCompLeft /-
+#print CategoryTheory.Functor.IsEquivalence.cancelCompLeft /-
 /-- If `F` and `F ⋙ G` are equivalence of categories, then `G` is also an equivalence. -/
 @[simp]
-def cancelCompLeft {E : Type _} [Category E] (F : C ⥤ D) (G : D ⥤ E) (hF : IsEquivalence F)
-    (hGF : IsEquivalence (F ⋙ G)) : IsEquivalence G :=
-  ofIso
+def CategoryTheory.Functor.IsEquivalence.cancelCompLeft {E : Type _} [Category E] (F : C ⥤ D)
+    (G : D ⥤ E) (hF : CategoryTheory.Functor.IsEquivalence F)
+    (hGF : CategoryTheory.Functor.IsEquivalence (F ⋙ G)) : CategoryTheory.Functor.IsEquivalence G :=
+  CategoryTheory.Functor.IsEquivalence.ofIso
     ((Functor.associator F.inv F G).symm ≪≫ NatIso.hcomp hF.counitIso (Iso.refl G) ≪≫ leftUnitor G)
     (Functor.isEquivalenceTrans F.inv (F ⋙ G))
-#align category_theory.is_equivalence.cancel_comp_left CategoryTheory.IsEquivalence.cancelCompLeft
+#align category_theory.is_equivalence.cancel_comp_left CategoryTheory.Functor.IsEquivalence.cancelCompLeft
 -/
 
 end IsEquivalence
@@ -810,7 +830,8 @@ namespace Equivalence
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-theorem essSurj_of_equivalence (F : C ⥤ D) [IsEquivalence F] : EssSurj F :=
+theorem essSurj_of_equivalence (F : C ⥤ D) [CategoryTheory.Functor.IsEquivalence F] :
+    CategoryTheory.Functor.EssSurj F :=
   ⟨fun Y => ⟨F.inv.obj Y, ⟨F.asEquivalence.counitIso.app Y⟩⟩⟩
 #align category_theory.equivalence.ess_surj_of_equivalence CategoryTheory.Equivalence.essSurj_of_equivalence
 -/
@@ -821,7 +842,8 @@ theorem essSurj_of_equivalence (F : C ⥤ D) [IsEquivalence F] : EssSurj F :=
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-instance (priority := 100) faithfulOfEquivalence (F : C ⥤ D) [IsEquivalence F] : Faithful F
+instance (priority := 100) faithfulOfEquivalence (F : C ⥤ D)
+    [CategoryTheory.Functor.IsEquivalence F] : CategoryTheory.Functor.Faithful F
     where map_injective' X Y f g w :=
     by
     have p := congr_arg (@CategoryTheory.Functor.map _ _ _ _ F.inv _ _) w
@@ -835,7 +857,8 @@ instance (priority := 100) faithfulOfEquivalence (F : C ⥤ D) [IsEquivalence F]
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-instance (priority := 100) fullOfEquivalence (F : C ⥤ D) [IsEquivalence F] : Full F
+instance (priority := 100) fullOfEquivalence (F : C ⥤ D) [CategoryTheory.Functor.IsEquivalence F] :
+    CategoryTheory.Functor.Full F
     where
   preimage X Y f := F.asEquivalence.Unit.app X ≫ F.inv.map f ≫ F.asEquivalence.unitInv.app Y
   witness' X Y f :=
@@ -846,25 +869,27 @@ instance (priority := 100) fullOfEquivalence (F : C ⥤ D) [IsEquivalence F] : F
 -/
 
 @[simps]
-private noncomputable def equivalence_inverse (F : C ⥤ D) [Full F] [Faithful F] [EssSurj F] : D ⥤ C
+private noncomputable def equivalence_inverse (F : C ⥤ D) [CategoryTheory.Functor.Full F]
+    [CategoryTheory.Functor.Faithful F] [CategoryTheory.Functor.EssSurj F] : D ⥤ C
     where
   obj X := F.objPreimage X
   map X Y f := F.preimage ((F.objObjPreimageIso X).Hom ≫ f ≫ (F.objObjPreimageIso Y).inv)
   map_id' X := by apply F.map_injective; tidy
   map_comp' X Y Z f g := by apply F.map_injective <;> simp
 
-#print CategoryTheory.Equivalence.ofFullyFaithfullyEssSurj /-
+#print CategoryTheory.Functor.IsEquivalence.ofFullyFaithfullyEssSurj /-
 /-- A functor which is full, faithful, and essentially surjective is an equivalence.
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-noncomputable def ofFullyFaithfullyEssSurj (F : C ⥤ D) [Full F] [Faithful F] [EssSurj F] :
-    IsEquivalence F :=
-  IsEquivalence.mk (equivalenceInverse F)
+noncomputable def CategoryTheory.Functor.IsEquivalence.ofFullyFaithfullyEssSurj (F : C ⥤ D)
+    [CategoryTheory.Functor.Full F] [CategoryTheory.Functor.Faithful F]
+    [CategoryTheory.Functor.EssSurj F] : CategoryTheory.Functor.IsEquivalence F :=
+  CategoryTheory.Functor.IsEquivalence.mk (equivalenceInverse F)
     (NatIso.ofComponents (fun X => (F.preimageIso <| F.objObjPreimageIso <| F.obj X).symm)
       fun X Y f => by apply F.map_injective; obviously)
     (NatIso.ofComponents F.objObjPreimageIso (by tidy))
-#align category_theory.equivalence.of_fully_faithfully_ess_surj CategoryTheory.Equivalence.ofFullyFaithfullyEssSurj
+#align category_theory.equivalence.of_fully_faithfully_ess_surj CategoryTheory.Functor.IsEquivalence.ofFullyFaithfullyEssSurj
 -/
 
 #print CategoryTheory.Equivalence.functor_map_inj_iff /-
@@ -884,22 +909,22 @@ theorem inverse_map_inj_iff (e : C ≌ D) {X Y : D} (f g : X ⟶ Y) :
 -/
 
 #print CategoryTheory.Equivalence.essSurjInducedFunctor /-
-instance essSurjInducedFunctor {C' : Type _} (e : C' ≃ D) : EssSurj (inducedFunctor e)
-    where mem_essImage Y := ⟨e.symm Y, by simp⟩
+instance essSurjInducedFunctor {C' : Type _} (e : C' ≃ D) :
+    CategoryTheory.Functor.EssSurj (inducedFunctor e) where mem_essImage Y := ⟨e.symm Y, by simp⟩
 #align category_theory.equivalence.ess_surj_induced_functor CategoryTheory.Equivalence.essSurjInducedFunctor
 -/
 
 #print CategoryTheory.Equivalence.inducedFunctorOfEquiv /-
 noncomputable instance inducedFunctorOfEquiv {C' : Type _} (e : C' ≃ D) :
-    IsEquivalence (inducedFunctor e) :=
-  Equivalence.ofFullyFaithfullyEssSurj _
+    CategoryTheory.Functor.IsEquivalence (inducedFunctor e) :=
+  CategoryTheory.Functor.IsEquivalence.ofFullyFaithfullyEssSurj _
 #align category_theory.equivalence.induced_functor_of_equiv CategoryTheory.Equivalence.inducedFunctorOfEquiv
 -/
 
 #print CategoryTheory.Equivalence.fullyFaithfulToEssImage /-
-noncomputable instance fullyFaithfulToEssImage (F : C ⥤ D) [Full F] [Faithful F] :
-    IsEquivalence F.toEssImage :=
-  ofFullyFaithfullyEssSurj F.toEssImage
+noncomputable instance fullyFaithfulToEssImage (F : C ⥤ D) [CategoryTheory.Functor.Full F]
+    [CategoryTheory.Functor.Faithful F] : CategoryTheory.Functor.IsEquivalence F.toEssImage :=
+  CategoryTheory.Functor.IsEquivalence.ofFullyFaithfullyEssSurj F.toEssImage
 #align category_theory.equivalence.fully_faithful_to_ess_image CategoryTheory.Equivalence.fullyFaithfulToEssImage
 -/
 

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

@@ -294,11 +294,11 @@ theorem adjointify_η_ε (X : C) :
     F.map ((adjointifyη η ε).Hom.app X) ≫ ε.Hom.app (F.obj X) = 𝟙 (F.obj X) :=
   by
   dsimp [adjointify_η]; simp
-  have := ε.hom.naturality (F.map (η.inv.app X)); dsimp at this ; rw [this]; clear this
+  have := ε.hom.naturality (F.map (η.inv.app X)); dsimp at this; rw [this]; clear this
   rw [← assoc _ _ (F.map _)]
-  have := ε.hom.naturality (ε.inv.app <| F.obj X); dsimp at this ; rw [this]; clear this
-  have := (ε.app <| F.obj X).hom_inv_id; dsimp at this ; rw [this]; clear this
-  rw [id_comp]; have := (F.map_iso <| η.app X).hom_inv_id; dsimp at this ; rw [this]
+  have := ε.hom.naturality (ε.inv.app <| F.obj X); dsimp at this; rw [this]; clear this
+  have := (ε.app <| F.obj X).hom_inv_id; dsimp at this; rw [this]; clear this
+  rw [id_comp]; have := (F.map_iso <| η.app X).hom_inv_id; dsimp at this; rw [this]
 #align category_theory.equivalence.adjointify_η_ε CategoryTheory.Equivalence.adjointify_η_ε
 -/
 

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

@@ -3,11 +3,11 @@ Copyright (c) 2017 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Tim Baumann, Stephen Morgan, Scott Morrison, Floris van Doorn
 -/
-import Mathbin.CategoryTheory.Functor.FullyFaithful
-import Mathbin.CategoryTheory.FullSubcategory
-import Mathbin.CategoryTheory.Whiskering
-import Mathbin.CategoryTheory.EssentialImage
-import Mathbin.Tactic.Slice
+import CategoryTheory.Functor.FullyFaithful
+import CategoryTheory.FullSubcategory
+import CategoryTheory.Whiskering
+import CategoryTheory.EssentialImage
+import Tactic.Slice
 
 #align_import category_theory.equivalence from "leanprover-community/mathlib"@"34ee86e6a59d911a8e4f89b68793ee7577ae79c7"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/442a83d738cb208d3600056c489be16900ba701d

@@ -96,8 +96,6 @@ structure Equivalence (C : Type u₁) [Category.{v₁} C] (D : Type u₂) [Categ
 #align category_theory.equivalence CategoryTheory.Equivalence
 -/
 
-restate_axiom equivalence.functor_unit_iso_comp'
-
 infixr:10 " ≌ " => Equivalence
 
 variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
@@ -567,8 +565,6 @@ class IsEquivalence (F : C ⥤ D) where mk' ::
 #align category_theory.is_equivalence CategoryTheory.IsEquivalence
 -/
 
-restate_axiom is_equivalence.functor_unit_iso_comp'
-
 attribute [simp, reassoc] is_equivalence.functor_unit_iso_comp
 
 namespace IsEquivalence

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

@@ -2,11 +2,6 @@
 Copyright (c) 2017 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Tim Baumann, Stephen Morgan, Scott Morrison, Floris van Doorn
-
-! This file was ported from Lean 3 source module category_theory.equivalence
-! leanprover-community/mathlib commit 34ee86e6a59d911a8e4f89b68793ee7577ae79c7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Functor.FullyFaithful
 import Mathbin.CategoryTheory.FullSubcategory
@@ -14,6 +9,8 @@ import Mathbin.CategoryTheory.Whiskering
 import Mathbin.CategoryTheory.EssentialImage
 import Mathbin.Tactic.Slice
 
+#align_import category_theory.equivalence from "leanprover-community/mathlib"@"34ee86e6a59d911a8e4f89b68793ee7577ae79c7"
+
 /-!
 # Equivalence of categories
 

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

@@ -71,6 +71,7 @@ open CategoryTheory.Functor NatIso Category
 -- declare the `v`'s first; see `category_theory.category` for an explanation
 universe v₁ v₂ v₃ u₁ u₂ u₃
 
+#print CategoryTheory.Equivalence /-
 /-- We define an equivalence as a (half)-adjoint equivalence, a pair of functors with
   a unit and counit which are natural isomorphisms and the triangle law `Fη ≫ εF = 1`, or in other
   words the composite `F ⟶ FGF ⟶ F` is the identity.
@@ -96,36 +97,45 @@ structure Equivalence (C : Type u₁) [Category.{v₁} C] (D : Type u₂) [Categ
         𝟙 (Functor.obj X) := by
     obviously
 #align category_theory.equivalence CategoryTheory.Equivalence
+-/
 
 restate_axiom equivalence.functor_unit_iso_comp'
 
--- mathport name: «expr ≌ »
 infixr:10 " ≌ " => Equivalence
 
 variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
 
 namespace Equivalence
 
+#print CategoryTheory.Equivalence.unit /-
 /-- The unit of an equivalence of categories. -/
 abbrev unit (e : C ≌ D) : 𝟭 C ⟶ e.Functor ⋙ e.inverse :=
   e.unitIso.Hom
 #align category_theory.equivalence.unit CategoryTheory.Equivalence.unit
+-/
 
+#print CategoryTheory.Equivalence.counit /-
 /-- The counit of an equivalence of categories. -/
 abbrev counit (e : C ≌ D) : e.inverse ⋙ e.Functor ⟶ 𝟭 D :=
   e.counitIso.Hom
 #align category_theory.equivalence.counit CategoryTheory.Equivalence.counit
+-/
 
+#print CategoryTheory.Equivalence.unitInv /-
 /-- The inverse of the unit of an equivalence of categories. -/
 abbrev unitInv (e : C ≌ D) : e.Functor ⋙ e.inverse ⟶ 𝟭 C :=
   e.unitIso.inv
 #align category_theory.equivalence.unit_inv CategoryTheory.Equivalence.unitInv
+-/
 
+#print CategoryTheory.Equivalence.counitInv /-
 /-- The inverse of the counit of an equivalence of categories. -/
 abbrev counitInv (e : C ≌ D) : 𝟭 D ⟶ e.inverse ⋙ e.Functor :=
   e.counitIso.inv
 #align category_theory.equivalence.counit_inv CategoryTheory.Equivalence.counitInv
+-/
 
+#print CategoryTheory.Equivalence.Equivalence_mk'_unit /-
 /- While these abbreviations are convenient, they also cause some trouble,
 preventing structure projections from unfolding. -/
 @[simp]
@@ -133,31 +143,41 @@ theorem Equivalence_mk'_unit (functor inverse unit_iso counit_iso f) :
     (⟨Functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).Unit = unit_iso.Hom :=
   rfl
 #align category_theory.equivalence.equivalence_mk'_unit CategoryTheory.Equivalence.Equivalence_mk'_unit
+-/
 
+#print CategoryTheory.Equivalence.Equivalence_mk'_counit /-
 @[simp]
 theorem Equivalence_mk'_counit (functor inverse unit_iso counit_iso f) :
     (⟨Functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).counit = counit_iso.Hom :=
   rfl
 #align category_theory.equivalence.equivalence_mk'_counit CategoryTheory.Equivalence.Equivalence_mk'_counit
+-/
 
+#print CategoryTheory.Equivalence.Equivalence_mk'_unitInv /-
 @[simp]
 theorem Equivalence_mk'_unitInv (functor inverse unit_iso counit_iso f) :
     (⟨Functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).unitInv = unit_iso.inv :=
   rfl
 #align category_theory.equivalence.equivalence_mk'_unit_inv CategoryTheory.Equivalence.Equivalence_mk'_unitInv
+-/
 
+#print CategoryTheory.Equivalence.Equivalence_mk'_counitInv /-
 @[simp]
 theorem Equivalence_mk'_counitInv (functor inverse unit_iso counit_iso f) :
     (⟨Functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).counitInv = counit_iso.inv :=
   rfl
 #align category_theory.equivalence.equivalence_mk'_counit_inv CategoryTheory.Equivalence.Equivalence_mk'_counitInv
+-/
 
+#print CategoryTheory.Equivalence.functor_unit_comp /-
 @[simp]
 theorem functor_unit_comp (e : C ≌ D) (X : C) :
     e.Functor.map (e.Unit.app X) ≫ e.counit.app (e.Functor.obj X) = 𝟙 (e.Functor.obj X) :=
   e.functor_unitIso_comp X
 #align category_theory.equivalence.functor_unit_comp CategoryTheory.Equivalence.functor_unit_comp
+-/
 
+#print CategoryTheory.Equivalence.counitInv_functor_comp /-
 @[simp]
 theorem counitInv_functor_comp (e : C ≌ D) (X : C) :
     e.counitInv.app (e.Functor.obj X) ≫ e.Functor.map (e.unitInv.app X) = 𝟙 (e.Functor.obj X) :=
@@ -166,17 +186,23 @@ theorem counitInv_functor_comp (e : C ≌ D) (X : C) :
       (iso.refl _)]
   exact e.functor_unit_comp X
 #align category_theory.equivalence.counit_inv_functor_comp CategoryTheory.Equivalence.counitInv_functor_comp
+-/
 
+#print CategoryTheory.Equivalence.counitInv_app_functor /-
 theorem counitInv_app_functor (e : C ≌ D) (X : C) :
     e.counitInv.app (e.Functor.obj X) = e.Functor.map (e.Unit.app X) := by symm;
   erw [← iso.comp_hom_eq_id (e.counit_iso.app _), functor_unit_comp]; rfl
 #align category_theory.equivalence.counit_inv_app_functor CategoryTheory.Equivalence.counitInv_app_functor
+-/
 
+#print CategoryTheory.Equivalence.counit_app_functor /-
 theorem counit_app_functor (e : C ≌ D) (X : C) :
     e.counit.app (e.Functor.obj X) = e.Functor.map (e.unitInv.app X) := by
   erw [← iso.hom_comp_eq_id (e.functor.map_iso (e.unit_iso.app X)), functor_unit_comp]; rfl
 #align category_theory.equivalence.counit_app_functor CategoryTheory.Equivalence.counit_app_functor
+-/
 
+#print CategoryTheory.Equivalence.unit_inverse_comp /-
 /-- The other triangle equality. The proof follows the following proof in Globular:
   http://globular.science/1905.001 -/
 @[simp]
@@ -204,7 +230,9 @@ theorem unit_inverse_comp (e : C ≌ D) (Y : D) :
       map_id]
   erw [id_comp, (e.unit_iso.app _).hom_inv_id]; rfl
 #align category_theory.equivalence.unit_inverse_comp CategoryTheory.Equivalence.unit_inverse_comp
+-/
 
+#print CategoryTheory.Equivalence.inverse_counitInv_comp /-
 @[simp]
 theorem inverse_counitInv_comp (e : C ≌ D) (Y : D) :
     e.inverse.map (e.counitInv.app Y) ≫ e.unitInv.app (e.inverse.obj Y) = 𝟙 (e.inverse.obj Y) :=
@@ -213,28 +241,37 @@ theorem inverse_counitInv_comp (e : C ≌ D) (Y : D) :
       (iso.refl _)]
   exact e.unit_inverse_comp Y
 #align category_theory.equivalence.inverse_counit_inv_comp CategoryTheory.Equivalence.inverse_counitInv_comp
+-/
 
+#print CategoryTheory.Equivalence.unit_app_inverse /-
 theorem unit_app_inverse (e : C ≌ D) (Y : D) :
     e.Unit.app (e.inverse.obj Y) = e.inverse.map (e.counitInv.app Y) := by
   erw [← iso.comp_hom_eq_id (e.inverse.map_iso (e.counit_iso.app Y)), unit_inverse_comp]; rfl
 #align category_theory.equivalence.unit_app_inverse CategoryTheory.Equivalence.unit_app_inverse
+-/
 
+#print CategoryTheory.Equivalence.unitInv_app_inverse /-
 theorem unitInv_app_inverse (e : C ≌ D) (Y : D) :
     e.unitInv.app (e.inverse.obj Y) = e.inverse.map (e.counit.app Y) := by symm;
   erw [← iso.hom_comp_eq_id (e.unit_iso.app _), unit_inverse_comp]; rfl
 #align category_theory.equivalence.unit_inv_app_inverse CategoryTheory.Equivalence.unitInv_app_inverse
+-/
 
+#print CategoryTheory.Equivalence.fun_inv_map /-
 @[simp]
 theorem fun_inv_map (e : C ≌ D) (X Y : D) (f : X ⟶ Y) :
     e.Functor.map (e.inverse.map f) = e.counit.app X ≫ f ≫ e.counitInv.app Y :=
   (NatIso.naturality_2 e.counitIso f).symm
 #align category_theory.equivalence.fun_inv_map CategoryTheory.Equivalence.fun_inv_map
+-/
 
+#print CategoryTheory.Equivalence.inv_fun_map /-
 @[simp]
 theorem inv_fun_map (e : C ≌ D) (X Y : C) (f : X ⟶ Y) :
     e.inverse.map (e.Functor.map f) = e.unitInv.app X ≫ f ≫ e.Unit.app Y :=
   (NatIso.naturality_1 e.unitIso f).symm
 #align category_theory.equivalence.inv_fun_map CategoryTheory.Equivalence.inv_fun_map
+-/
 
 section
 
@@ -257,6 +294,7 @@ def adjointifyη : 𝟭 C ≅ F ⋙ G :=
 #align category_theory.equivalence.adjointify_η CategoryTheory.Equivalence.adjointifyη
 -/
 
+#print CategoryTheory.Equivalence.adjointify_η_ε /-
 theorem adjointify_η_ε (X : C) :
     F.map ((adjointifyη η ε).Hom.app X) ≫ ε.Hom.app (F.obj X) = 𝟙 (F.obj X) :=
   by
@@ -267,33 +305,41 @@ theorem adjointify_η_ε (X : C) :
   have := (ε.app <| F.obj X).hom_inv_id; dsimp at this ; rw [this]; clear this
   rw [id_comp]; have := (F.map_iso <| η.app X).hom_inv_id; dsimp at this ; rw [this]
 #align category_theory.equivalence.adjointify_η_ε CategoryTheory.Equivalence.adjointify_η_ε
+-/
 
 end
 
+#print CategoryTheory.Equivalence.mk /-
 /-- Every equivalence of categories consisting of functors `F` and `G` such that `F ⋙ G` and
     `G ⋙ F` are naturally isomorphic to identity functors can be transformed into a half-adjoint
     equivalence without changing `F` or `G`. -/
 protected def mk (F : C ⥤ D) (G : D ⥤ C) (η : 𝟭 C ≅ F ⋙ G) (ε : G ⋙ F ≅ 𝟭 D) : C ≌ D :=
   ⟨F, G, adjointifyη η ε, ε, adjointify_η_ε η ε⟩
 #align category_theory.equivalence.mk CategoryTheory.Equivalence.mk
+-/
 
+#print CategoryTheory.Equivalence.refl /-
 /-- Equivalence of categories is reflexive. -/
 @[refl, simps]
 def refl : C ≌ C :=
   ⟨𝟭 C, 𝟭 C, Iso.refl _, Iso.refl _, fun X => Category.id_comp _⟩
 #align category_theory.equivalence.refl CategoryTheory.Equivalence.refl
+-/
 
 instance : Inhabited (C ≌ C) :=
   ⟨refl⟩
 
+#print CategoryTheory.Equivalence.symm /-
 /-- Equivalence of categories is symmetric. -/
 @[symm, simps]
 def symm (e : C ≌ D) : D ≌ C :=
   ⟨e.inverse, e.Functor, e.counitIso.symm, e.unitIso.symm, e.inverse_counitInv_comp⟩
 #align category_theory.equivalence.symm CategoryTheory.Equivalence.symm
+-/
 
 variable {E : Type u₃} [Category.{v₃} E]
 
+#print CategoryTheory.Equivalence.trans /-
 /-- Equivalence of categories is transitive. -/
 @[trans, simps]
 def trans (e : C ≌ D) (f : D ≌ E) : C ≌ E
@@ -315,39 +361,53 @@ def trans (e : C ≌ D) (f : D ≌ E) : C ≌ E
       iso.inv_hom_id_app_assoc, assoc, iso.inv_hom_id_app, counit_app_functor, ← functor.map_comp]
     erw [comp_id, iso.hom_inv_id_app, Functor.map_id]
 #align category_theory.equivalence.trans CategoryTheory.Equivalence.trans
+-/
 
+#print CategoryTheory.Equivalence.funInvIdAssoc /-
 /-- Composing a functor with both functors of an equivalence yields a naturally isomorphic
 functor. -/
 def funInvIdAssoc (e : C ≌ D) (F : C ⥤ E) : e.Functor ⋙ e.inverse ⋙ F ≅ F :=
   (Functor.associator _ _ _).symm ≪≫ isoWhiskerRight e.unitIso.symm F ≪≫ F.leftUnitor
 #align category_theory.equivalence.fun_inv_id_assoc CategoryTheory.Equivalence.funInvIdAssoc
+-/
 
+#print CategoryTheory.Equivalence.funInvIdAssoc_hom_app /-
 @[simp]
 theorem funInvIdAssoc_hom_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
     (funInvIdAssoc e F).Hom.app X = F.map (e.unitInv.app X) := by dsimp [fun_inv_id_assoc]; tidy
 #align category_theory.equivalence.fun_inv_id_assoc_hom_app CategoryTheory.Equivalence.funInvIdAssoc_hom_app
+-/
 
+#print CategoryTheory.Equivalence.funInvIdAssoc_inv_app /-
 @[simp]
 theorem funInvIdAssoc_inv_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
     (funInvIdAssoc e F).inv.app X = F.map (e.Unit.app X) := by dsimp [fun_inv_id_assoc]; tidy
 #align category_theory.equivalence.fun_inv_id_assoc_inv_app CategoryTheory.Equivalence.funInvIdAssoc_inv_app
+-/
 
+#print CategoryTheory.Equivalence.invFunIdAssoc /-
 /-- Composing a functor with both functors of an equivalence yields a naturally isomorphic
 functor. -/
 def invFunIdAssoc (e : C ≌ D) (F : D ⥤ E) : e.inverse ⋙ e.Functor ⋙ F ≅ F :=
   (Functor.associator _ _ _).symm ≪≫ isoWhiskerRight e.counitIso F ≪≫ F.leftUnitor
 #align category_theory.equivalence.inv_fun_id_assoc CategoryTheory.Equivalence.invFunIdAssoc
+-/
 
+#print CategoryTheory.Equivalence.invFunIdAssoc_hom_app /-
 @[simp]
 theorem invFunIdAssoc_hom_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
     (invFunIdAssoc e F).Hom.app X = F.map (e.counit.app X) := by dsimp [inv_fun_id_assoc]; tidy
 #align category_theory.equivalence.inv_fun_id_assoc_hom_app CategoryTheory.Equivalence.invFunIdAssoc_hom_app
+-/
 
+#print CategoryTheory.Equivalence.invFunIdAssoc_inv_app /-
 @[simp]
 theorem invFunIdAssoc_inv_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
     (invFunIdAssoc e F).inv.app X = F.map (e.counitInv.app X) := by dsimp [inv_fun_id_assoc]; tidy
 #align category_theory.equivalence.inv_fun_id_assoc_inv_app CategoryTheory.Equivalence.invFunIdAssoc_inv_app
+-/
 
+#print CategoryTheory.Equivalence.congrLeft /-
 /-- If `C` is equivalent to `D`, then `C ⥤ E` is equivalent to `D ⥤ E`. -/
 @[simps Functor inverse unitIso counitIso]
 def congrLeft (e : C ≌ D) : C ⥤ E ≌ D ⥤ E :=
@@ -355,7 +415,9 @@ def congrLeft (e : C ≌ D) : C ⥤ E ≌ D ⥤ E :=
     (NatIso.ofComponents (fun F => (e.funInvIdAssoc F).symm) (by tidy))
     (NatIso.ofComponents (fun F => e.invFunIdAssoc F) (by tidy))
 #align category_theory.equivalence.congr_left CategoryTheory.Equivalence.congrLeft
+-/
 
+#print CategoryTheory.Equivalence.congrRight /-
 /-- If `C` is equivalent to `D`, then `E ⥤ C` is equivalent to `E ⥤ D`. -/
 @[simps Functor inverse unitIso counitIso]
 def congrRight (e : C ≌ D) : E ⥤ C ≌ E ⥤ D :=
@@ -367,11 +429,13 @@ def congrRight (e : C ≌ D) : E ⥤ C ≌ E ⥤ D :=
       (fun F => Functor.associator _ _ _ ≪≫ isoWhiskerLeft F e.counitIso ≪≫ F.rightUnitor)
       (by tidy))
 #align category_theory.equivalence.congr_right CategoryTheory.Equivalence.congrRight
+-/
 
 section CancellationLemmas
 
 variable (e : C ≌ D)
 
+#print CategoryTheory.Equivalence.cancel_unit_right /-
 /- We need special forms of `cancel_nat_iso_hom_right(_assoc)` and
 `cancel_nat_iso_inv_right(_assoc)` for units and counits, because neither `simp` or `rw` will apply
 those lemmas in this setting without providing `e.unit_iso` (or similar) as an explicit argument.
@@ -381,52 +445,68 @@ We also provide the lemmas for length four compositions, since they're occasiona
 theorem cancel_unit_right {X Y : C} (f f' : X ⟶ Y) :
     f ≫ e.Unit.app Y = f' ≫ e.Unit.app Y ↔ f = f' := by simp only [cancel_mono]
 #align category_theory.equivalence.cancel_unit_right CategoryTheory.Equivalence.cancel_unit_right
+-/
 
+#print CategoryTheory.Equivalence.cancel_unitInv_right /-
 @[simp]
 theorem cancel_unitInv_right {X Y : C} (f f' : X ⟶ e.inverse.obj (e.Functor.obj Y)) :
     f ≫ e.unitInv.app Y = f' ≫ e.unitInv.app Y ↔ f = f' := by simp only [cancel_mono]
 #align category_theory.equivalence.cancel_unit_inv_right CategoryTheory.Equivalence.cancel_unitInv_right
+-/
 
+#print CategoryTheory.Equivalence.cancel_counit_right /-
 @[simp]
 theorem cancel_counit_right {X Y : D} (f f' : X ⟶ e.Functor.obj (e.inverse.obj Y)) :
     f ≫ e.counit.app Y = f' ≫ e.counit.app Y ↔ f = f' := by simp only [cancel_mono]
 #align category_theory.equivalence.cancel_counit_right CategoryTheory.Equivalence.cancel_counit_right
+-/
 
+#print CategoryTheory.Equivalence.cancel_counitInv_right /-
 @[simp]
 theorem cancel_counitInv_right {X Y : D} (f f' : X ⟶ Y) :
     f ≫ e.counitInv.app Y = f' ≫ e.counitInv.app Y ↔ f = f' := by simp only [cancel_mono]
 #align category_theory.equivalence.cancel_counit_inv_right CategoryTheory.Equivalence.cancel_counitInv_right
+-/
 
+#print CategoryTheory.Equivalence.cancel_unit_right_assoc /-
 @[simp]
 theorem cancel_unit_right_assoc {W X X' Y : C} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X') (g' : X' ⟶ Y) :
     f ≫ g ≫ e.Unit.app Y = f' ≫ g' ≫ e.Unit.app Y ↔ f ≫ g = f' ≫ g' := by
   simp only [← category.assoc, cancel_mono]
 #align category_theory.equivalence.cancel_unit_right_assoc CategoryTheory.Equivalence.cancel_unit_right_assoc
+-/
 
+#print CategoryTheory.Equivalence.cancel_counitInv_right_assoc /-
 @[simp]
 theorem cancel_counitInv_right_assoc {W X X' Y : D} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X')
     (g' : X' ⟶ Y) : f ≫ g ≫ e.counitInv.app Y = f' ≫ g' ≫ e.counitInv.app Y ↔ f ≫ g = f' ≫ g' := by
   simp only [← category.assoc, cancel_mono]
 #align category_theory.equivalence.cancel_counit_inv_right_assoc CategoryTheory.Equivalence.cancel_counitInv_right_assoc
+-/
 
+#print CategoryTheory.Equivalence.cancel_unit_right_assoc' /-
 @[simp]
 theorem cancel_unit_right_assoc' {W X X' Y Y' Z : C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z)
     (f' : W ⟶ X') (g' : X' ⟶ Y') (h' : Y' ⟶ Z) :
     f ≫ g ≫ h ≫ e.Unit.app Z = f' ≫ g' ≫ h' ≫ e.Unit.app Z ↔ f ≫ g ≫ h = f' ≫ g' ≫ h' := by
   simp only [← category.assoc, cancel_mono]
 #align category_theory.equivalence.cancel_unit_right_assoc' CategoryTheory.Equivalence.cancel_unit_right_assoc'
+-/
 
+#print CategoryTheory.Equivalence.cancel_counitInv_right_assoc' /-
 @[simp]
 theorem cancel_counitInv_right_assoc' {W X X' Y Y' Z : D} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z)
     (f' : W ⟶ X') (g' : X' ⟶ Y') (h' : Y' ⟶ Z) :
     f ≫ g ≫ h ≫ e.counitInv.app Z = f' ≫ g' ≫ h' ≫ e.counitInv.app Z ↔ f ≫ g ≫ h = f' ≫ g' ≫ h' :=
   by simp only [← category.assoc, cancel_mono]
 #align category_theory.equivalence.cancel_counit_inv_right_assoc' CategoryTheory.Equivalence.cancel_counitInv_right_assoc'
+-/
 
 end CancellationLemmas
 
 section
 
+#print CategoryTheory.Equivalence.powNat /-
 -- There's of course a monoid structure on `C ≌ C`,
 -- but let's not encourage using it.
 -- The power structure is nevertheless useful.
@@ -436,30 +516,39 @@ def powNat (e : C ≌ C) : ℕ → (C ≌ C)
   | 1 => e
   | n + 2 => e.trans (pow_nat (n + 1))
 #align category_theory.equivalence.pow_nat CategoryTheory.Equivalence.powNat
+-/
 
+#print CategoryTheory.Equivalence.pow /-
 /-- Powers of an auto-equivalence.  Use `(^)` instead. -/
 def pow (e : C ≌ C) : ℤ → (C ≌ C)
   | Int.ofNat n => e.powNat n
   | Int.negSucc n => e.symm.powNat (n + 1)
 #align category_theory.equivalence.pow CategoryTheory.Equivalence.pow
+-/
 
 instance : Pow (C ≌ C) ℤ :=
   ⟨pow⟩
 
+#print CategoryTheory.Equivalence.pow_zero /-
 @[simp]
 theorem pow_zero (e : C ≌ C) : e ^ (0 : ℤ) = Equivalence.refl :=
   rfl
 #align category_theory.equivalence.pow_zero CategoryTheory.Equivalence.pow_zero
+-/
 
+#print CategoryTheory.Equivalence.pow_one /-
 @[simp]
 theorem pow_one (e : C ≌ C) : e ^ (1 : ℤ) = e :=
   rfl
 #align category_theory.equivalence.pow_one CategoryTheory.Equivalence.pow_one
+-/
 
+#print CategoryTheory.Equivalence.pow_neg_one /-
 @[simp]
 theorem pow_neg_one (e : C ≌ C) : e ^ (-1 : ℤ) = e.symm :=
   rfl
 #align category_theory.equivalence.pow_neg_one CategoryTheory.Equivalence.pow_neg_one
+-/
 
 -- TODO as necessary, add the natural isomorphisms `(e^a).trans e^b ≅ e^(a+b)`.
 -- At this point, we haven't even defined the category of equivalences.
@@ -487,13 +576,17 @@ attribute [simp, reassoc] is_equivalence.functor_unit_iso_comp
 
 namespace IsEquivalence
 
+#print CategoryTheory.IsEquivalence.ofEquivalence /-
 instance ofEquivalence (F : C ≌ D) : IsEquivalence F.Functor :=
   { F with }
 #align category_theory.is_equivalence.of_equivalence CategoryTheory.IsEquivalence.ofEquivalence
+-/
 
+#print CategoryTheory.IsEquivalence.ofEquivalenceInverse /-
 instance ofEquivalenceInverse (F : C ≌ D) : IsEquivalence F.inverse :=
   IsEquivalence.ofEquivalence F.symm
 #align category_theory.is_equivalence.of_equivalence_inverse CategoryTheory.IsEquivalence.ofEquivalenceInverse
+-/
 
 open Equivalence
 
@@ -509,11 +602,13 @@ end IsEquivalence
 
 namespace Functor
 
+#print CategoryTheory.Functor.asEquivalence /-
 /-- Interpret a functor that is an equivalence as an equivalence. -/
 def asEquivalence (F : C ⥤ D) [IsEquivalence F] : C ≌ D :=
   ⟨F, IsEquivalence.inverse F, IsEquivalence.unitIso, IsEquivalence.counitIso,
     IsEquivalence.functor_unitIso_comp⟩
 #align category_theory.functor.as_equivalence CategoryTheory.Functor.asEquivalence
+-/
 
 #print CategoryTheory.Functor.isEquivalenceRefl /-
 instance isEquivalenceRefl : IsEquivalence (𝟭 C) :=
@@ -584,28 +679,37 @@ end Functor
 
 namespace Equivalence
 
+#print CategoryTheory.Equivalence.functor_inv /-
 @[simp]
 theorem functor_inv (E : C ≌ D) : E.Functor.inv = E.inverse :=
   rfl
 #align category_theory.equivalence.functor_inv CategoryTheory.Equivalence.functor_inv
+-/
 
+#print CategoryTheory.Equivalence.inverse_inv /-
 @[simp]
 theorem inverse_inv (E : C ≌ D) : E.inverse.inv = E.Functor :=
   rfl
 #align category_theory.equivalence.inverse_inv CategoryTheory.Equivalence.inverse_inv
+-/
 
+#print CategoryTheory.Equivalence.functor_asEquivalence /-
 @[simp]
 theorem functor_asEquivalence (E : C ≌ D) : E.Functor.asEquivalence = E := by cases E; congr
 #align category_theory.equivalence.functor_as_equivalence CategoryTheory.Equivalence.functor_asEquivalence
+-/
 
+#print CategoryTheory.Equivalence.inverse_asEquivalence /-
 @[simp]
 theorem inverse_asEquivalence (E : C ≌ D) : E.inverse.asEquivalence = E.symm := by cases E; congr
 #align category_theory.equivalence.inverse_as_equivalence CategoryTheory.Equivalence.inverse_asEquivalence
+-/
 
 end Equivalence
 
 namespace IsEquivalence
 
+#print CategoryTheory.IsEquivalence.fun_inv_map /-
 @[simp]
 theorem fun_inv_map (F : C ⥤ D) [IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
     F.map (F.inv.map f) = F.asEquivalence.counit.app X ≫ f ≫ F.asEquivalence.counitInv.app Y :=
@@ -613,7 +717,9 @@ theorem fun_inv_map (F : C ⥤ D) [IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
   erw [nat_iso.naturality_2]
   rfl
 #align category_theory.is_equivalence.fun_inv_map CategoryTheory.IsEquivalence.fun_inv_map
+-/
 
+#print CategoryTheory.IsEquivalence.inv_fun_map /-
 @[simp]
 theorem inv_fun_map (F : C ⥤ D) [IsEquivalence F] (X Y : C) (f : X ⟶ Y) :
     F.inv.map (F.map f) = F.asEquivalence.unitInv.app X ≫ f ≫ F.asEquivalence.Unit.app Y :=
@@ -621,6 +727,7 @@ theorem inv_fun_map (F : C ⥤ D) [IsEquivalence F] (X Y : C) (f : X ⟶ Y) :
   erw [nat_iso.naturality_1]
   rfl
 #align category_theory.is_equivalence.inv_fun_map CategoryTheory.IsEquivalence.inv_fun_map
+-/
 
 #print CategoryTheory.IsEquivalence.ofIso /-
 /-- When a functor `F` is an equivalence of categories, and `G` is isomorphic to `F`, then
@@ -767,17 +874,21 @@ noncomputable def ofFullyFaithfullyEssSurj (F : C ⥤ D) [Full F] [Faithful F] [
 #align category_theory.equivalence.of_fully_faithfully_ess_surj CategoryTheory.Equivalence.ofFullyFaithfullyEssSurj
 -/
 
+#print CategoryTheory.Equivalence.functor_map_inj_iff /-
 @[simp]
 theorem functor_map_inj_iff (e : C ≌ D) {X Y : C} (f g : X ⟶ Y) :
     e.Functor.map f = e.Functor.map g ↔ f = g :=
   ⟨fun h => e.Functor.map_injective h, fun h => h ▸ rfl⟩
 #align category_theory.equivalence.functor_map_inj_iff CategoryTheory.Equivalence.functor_map_inj_iff
+-/
 
+#print CategoryTheory.Equivalence.inverse_map_inj_iff /-
 @[simp]
 theorem inverse_map_inj_iff (e : C ≌ D) {X Y : D} (f g : X ⟶ Y) :
     e.inverse.map f = e.inverse.map g ↔ f = g :=
   functor_map_inj_iff e.symm f g
 #align category_theory.equivalence.inverse_map_inj_iff CategoryTheory.Equivalence.inverse_map_inj_iff
+-/
 
 #print CategoryTheory.Equivalence.essSurjInducedFunctor /-
 instance essSurjInducedFunctor {C' : Type _} (e : C' ≃ D) : EssSurj (inducedFunctor e)

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

@@ -254,7 +254,6 @@ def adjointifyη : 𝟭 C ≅ F ⋙ G :=
     _ ≅ (F ⋙ G) ⋙ F ⋙ G := (associator F G (F ⋙ G)).symm
     _ ≅ 𝟭 C ⋙ F ⋙ G := (isoWhiskerRight η.symm (F ⋙ G))
     _ ≅ F ⋙ G := leftUnitor (F ⋙ G)
-    
 #align category_theory.equivalence.adjointify_η CategoryTheory.Equivalence.adjointifyη
 -/
 

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

@@ -262,11 +262,11 @@ theorem adjointify_η_ε (X : C) :
     F.map ((adjointifyη η ε).Hom.app X) ≫ ε.Hom.app (F.obj X) = 𝟙 (F.obj X) :=
   by
   dsimp [adjointify_η]; simp
-  have := ε.hom.naturality (F.map (η.inv.app X)); dsimp at this; rw [this]; clear this
+  have := ε.hom.naturality (F.map (η.inv.app X)); dsimp at this ; rw [this]; clear this
   rw [← assoc _ _ (F.map _)]
-  have := ε.hom.naturality (ε.inv.app <| F.obj X); dsimp at this; rw [this]; clear this
-  have := (ε.app <| F.obj X).hom_inv_id; dsimp at this; rw [this]; clear this
-  rw [id_comp]; have := (F.map_iso <| η.app X).hom_inv_id; dsimp at this; rw [this]
+  have := ε.hom.naturality (ε.inv.app <| F.obj X); dsimp at this ; rw [this]; clear this
+  have := (ε.app <| F.obj X).hom_inv_id; dsimp at this ; rw [this]; clear this
+  rw [id_comp]; have := (F.map_iso <| η.app X).hom_inv_id; dsimp at this ; rw [this]
 #align category_theory.equivalence.adjointify_η_ε CategoryTheory.Equivalence.adjointify_η_ε
 
 end

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

@@ -71,12 +71,6 @@ open CategoryTheory.Functor NatIso Category
 -- declare the `v`'s first; see `category_theory.category` for an explanation
 universe v₁ v₂ v₃ u₁ u₂ u₃
 
-/- warning: category_theory.equivalence -> CategoryTheory.Equivalence is a dubious translation:
-lean 3 declaration is
-  forall (C : Type.{u3}) [_inst_1 : CategoryTheory.Category.{u1, u3} C] (D : Type.{u4}) [_inst_2 : CategoryTheory.Category.{u2, u4} D], Sort.{max (succ u3) (succ u4) (succ u1) (succ u2)}
-but is expected to have type
-  forall (C : Type.{u3}) (_inst_1 : Type.{u4}) [D : CategoryTheory.Category.{u1, u3} C] [_inst_2 : CategoryTheory.Category.{u2, u4} _inst_1], Sort.{max (max (max (succ u3) (succ u4)) (succ u1)) (succ u2)}
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence CategoryTheory.Equivalenceₓ'. -/
 /-- We define an equivalence as a (half)-adjoint equivalence, a pair of functors with
   a unit and counit which are natural isomorphisms and the triangle law `Fη ≫ εF = 1`, or in other
   words the composite `F ⟶ FGF ⟶ F` is the identity.
@@ -112,53 +106,26 @@ variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
 
 namespace Equivalence
 
-/- warning: category_theory.equivalence.unit -> CategoryTheory.Equivalence.unit is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2), Quiver.Hom.{succ (max u3 u1), max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.CategoryStruct.toQuiver.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Category.toCategoryStruct.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1))) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), Quiver.Hom.{max (succ u3) (succ u1), max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.CategoryStruct.toQuiver.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Category.toCategoryStruct.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1))) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.unit CategoryTheory.Equivalence.unitₓ'. -/
 /-- The unit of an equivalence of categories. -/
 abbrev unit (e : C ≌ D) : 𝟭 C ⟶ e.Functor ⋙ e.inverse :=
   e.unitIso.Hom
 #align category_theory.equivalence.unit CategoryTheory.Equivalence.unit
 
-/- warning: category_theory.equivalence.counit -> CategoryTheory.Equivalence.counit is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2), Quiver.Hom.{succ (max u4 u2), max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2))) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), Quiver.Hom.{max (succ u4) (succ u2), max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2))) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.counit CategoryTheory.Equivalence.counitₓ'. -/
 /-- The counit of an equivalence of categories. -/
 abbrev counit (e : C ≌ D) : e.inverse ⋙ e.Functor ⟶ 𝟭 D :=
   e.counitIso.Hom
 #align category_theory.equivalence.counit CategoryTheory.Equivalence.counit
 
-/- warning: category_theory.equivalence.unit_inv -> CategoryTheory.Equivalence.unitInv is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2), Quiver.Hom.{succ (max u3 u1), max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.CategoryStruct.toQuiver.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Category.toCategoryStruct.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1))) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), Quiver.Hom.{max (succ u3) (succ u1), max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.CategoryStruct.toQuiver.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Category.toCategoryStruct.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1))) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.unit_inv CategoryTheory.Equivalence.unitInvₓ'. -/
 /-- The inverse of the unit of an equivalence of categories. -/
 abbrev unitInv (e : C ≌ D) : e.Functor ⋙ e.inverse ⟶ 𝟭 C :=
   e.unitIso.inv
 #align category_theory.equivalence.unit_inv CategoryTheory.Equivalence.unitInv
 
-/- warning: category_theory.equivalence.counit_inv -> CategoryTheory.Equivalence.counitInv is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2), Quiver.Hom.{succ (max u4 u2), max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2))) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), Quiver.Hom.{max (succ u4) (succ u2), max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2))) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.counit_inv CategoryTheory.Equivalence.counitInvₓ'. -/
 /-- The inverse of the counit of an equivalence of categories. -/
 abbrev counitInv (e : C ≌ D) : 𝟭 D ⟶ e.inverse ⋙ e.Functor :=
   e.counitIso.inv
 #align category_theory.equivalence.counit_inv CategoryTheory.Equivalence.counitInv
 
-/- warning: category_theory.equivalence.equivalence_mk'_unit -> CategoryTheory.Equivalence.Equivalence_mk'_unit is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.equivalence_mk'_unit CategoryTheory.Equivalence.Equivalence_mk'_unitₓ'. -/
 /- While these abbreviations are convenient, they also cause some trouble,
 preventing structure projections from unfolding. -/
 @[simp]
@@ -167,45 +134,30 @@ theorem Equivalence_mk'_unit (functor inverse unit_iso counit_iso f) :
   rfl
 #align category_theory.equivalence.equivalence_mk'_unit CategoryTheory.Equivalence.Equivalence_mk'_unit
 
-/- warning: category_theory.equivalence.equivalence_mk'_counit -> CategoryTheory.Equivalence.Equivalence_mk'_counit is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.equivalence_mk'_counit CategoryTheory.Equivalence.Equivalence_mk'_counitₓ'. -/
 @[simp]
 theorem Equivalence_mk'_counit (functor inverse unit_iso counit_iso f) :
     (⟨Functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).counit = counit_iso.Hom :=
   rfl
 #align category_theory.equivalence.equivalence_mk'_counit CategoryTheory.Equivalence.Equivalence_mk'_counit
 
-/- warning: category_theory.equivalence.equivalence_mk'_unit_inv -> CategoryTheory.Equivalence.Equivalence_mk'_unitInv is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.equivalence_mk'_unit_inv CategoryTheory.Equivalence.Equivalence_mk'_unitInvₓ'. -/
 @[simp]
 theorem Equivalence_mk'_unitInv (functor inverse unit_iso counit_iso f) :
     (⟨Functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).unitInv = unit_iso.inv :=
   rfl
 #align category_theory.equivalence.equivalence_mk'_unit_inv CategoryTheory.Equivalence.Equivalence_mk'_unitInv
 
-/- warning: category_theory.equivalence.equivalence_mk'_counit_inv -> CategoryTheory.Equivalence.Equivalence_mk'_counitInv is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.equivalence_mk'_counit_inv CategoryTheory.Equivalence.Equivalence_mk'_counitInvₓ'. -/
 @[simp]
 theorem Equivalence_mk'_counitInv (functor inverse unit_iso counit_iso f) :
     (⟨Functor, inverse, unit_iso, counit_iso, f⟩ : C ≌ D).counitInv = counit_iso.inv :=
   rfl
 #align category_theory.equivalence.equivalence_mk'_counit_inv CategoryTheory.Equivalence.Equivalence_mk'_counitInv
 
-/- warning: category_theory.equivalence.functor_unit_comp -> CategoryTheory.Equivalence.functor_unit_comp is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.functor_unit_comp CategoryTheory.Equivalence.functor_unit_compₓ'. -/
 @[simp]
 theorem functor_unit_comp (e : C ≌ D) (X : C) :
     e.Functor.map (e.Unit.app X) ≫ e.counit.app (e.Functor.obj X) = 𝟙 (e.Functor.obj X) :=
   e.functor_unitIso_comp X
 #align category_theory.equivalence.functor_unit_comp CategoryTheory.Equivalence.functor_unit_comp
 
-/- warning: category_theory.equivalence.counit_inv_functor_comp -> CategoryTheory.Equivalence.counitInv_functor_comp is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.counit_inv_functor_comp CategoryTheory.Equivalence.counitInv_functor_compₓ'. -/
 @[simp]
 theorem counitInv_functor_comp (e : C ≌ D) (X : C) :
     e.counitInv.app (e.Functor.obj X) ≫ e.Functor.map (e.unitInv.app X) = 𝟙 (e.Functor.obj X) :=
@@ -215,31 +167,16 @@ theorem counitInv_functor_comp (e : C ≌ D) (X : C) :
   exact e.functor_unit_comp X
 #align category_theory.equivalence.counit_inv_functor_comp CategoryTheory.Equivalence.counitInv_functor_comp
 
-/- warning: category_theory.equivalence.counit_inv_app_functor -> CategoryTheory.Equivalence.counitInv_app_functor is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X))) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.counit_inv_app_functor CategoryTheory.Equivalence.counitInv_app_functorₓ'. -/
 theorem counitInv_app_functor (e : C ≌ D) (X : C) :
     e.counitInv.app (e.Functor.obj X) = e.Functor.map (e.Unit.app X) := by symm;
   erw [← iso.comp_hom_eq_id (e.counit_iso.app _), functor_unit_comp]; rfl
 #align category_theory.equivalence.counit_inv_app_functor CategoryTheory.Equivalence.counitInv_app_functor
 
-/- warning: category_theory.equivalence.counit_app_functor -> CategoryTheory.Equivalence.counit_app_functor is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) X (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X))) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.counit_app_functor CategoryTheory.Equivalence.counit_app_functorₓ'. -/
 theorem counit_app_functor (e : C ≌ D) (X : C) :
     e.counit.app (e.Functor.obj X) = e.Functor.map (e.unitInv.app X) := by
   erw [← iso.hom_comp_eq_id (e.functor.map_iso (e.unit_iso.app X)), functor_unit_comp]; rfl
 #align category_theory.equivalence.counit_app_functor CategoryTheory.Equivalence.counit_app_functor
 
-/- warning: category_theory.equivalence.unit_inverse_comp -> CategoryTheory.Equivalence.unit_inverse_comp is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.unit_inverse_comp CategoryTheory.Equivalence.unit_inverse_compₓ'. -/
 /-- The other triangle equality. The proof follows the following proof in Globular:
   http://globular.science/1905.001 -/
 @[simp]
@@ -268,9 +205,6 @@ theorem unit_inverse_comp (e : C ≌ D) (Y : D) :
   erw [id_comp, (e.unit_iso.app _).hom_inv_id]; rfl
 #align category_theory.equivalence.unit_inverse_comp CategoryTheory.Equivalence.unit_inverse_comp
 
-/- warning: category_theory.equivalence.inverse_counit_inv_comp -> CategoryTheory.Equivalence.inverse_counitInv_comp is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inverse_counit_inv_comp CategoryTheory.Equivalence.inverse_counitInv_compₓ'. -/
 @[simp]
 theorem inverse_counitInv_comp (e : C ≌ D) (Y : D) :
     e.inverse.map (e.counitInv.app Y) ≫ e.unitInv.app (e.inverse.obj Y) = 𝟙 (e.inverse.obj Y) :=
@@ -280,40 +214,22 @@ theorem inverse_counitInv_comp (e : C ≌ D) (Y : D) :
   exact e.unit_inverse_comp Y
 #align category_theory.equivalence.inverse_counit_inv_comp CategoryTheory.Equivalence.inverse_counitInv_comp
 
-/- warning: category_theory.equivalence.unit_app_inverse -> CategoryTheory.Equivalence.unit_app_inverse is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (Y : D), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.map.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (Y : D), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.unit_app_inverse CategoryTheory.Equivalence.unit_app_inverseₓ'. -/
 theorem unit_app_inverse (e : C ≌ D) (Y : D) :
     e.Unit.app (e.inverse.obj Y) = e.inverse.map (e.counitInv.app Y) := by
   erw [← iso.comp_hom_eq_id (e.inverse.map_iso (e.counit_iso.app Y)), unit_inverse_comp]; rfl
 #align category_theory.equivalence.unit_app_inverse CategoryTheory.Equivalence.unit_app_inverse
 
-/- warning: category_theory.equivalence.unit_inv_app_inverse -> CategoryTheory.Equivalence.unitInv_app_inverse is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (Y : D), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.map.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) Y (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (Y : D), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.unit_inv_app_inverse CategoryTheory.Equivalence.unitInv_app_inverseₓ'. -/
 theorem unitInv_app_inverse (e : C ≌ D) (Y : D) :
     e.unitInv.app (e.inverse.obj Y) = e.inverse.map (e.counit.app Y) := by symm;
   erw [← iso.hom_comp_eq_id (e.unit_iso.app _), unit_inverse_comp]; rfl
 #align category_theory.equivalence.unit_inv_app_inverse CategoryTheory.Equivalence.unitInv_app_inverse
 
-/- warning: category_theory.equivalence.fun_inv_map -> CategoryTheory.Equivalence.fun_inv_map is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.fun_inv_map CategoryTheory.Equivalence.fun_inv_mapₓ'. -/
 @[simp]
 theorem fun_inv_map (e : C ≌ D) (X Y : D) (f : X ⟶ Y) :
     e.Functor.map (e.inverse.map f) = e.counit.app X ≫ f ≫ e.counitInv.app Y :=
   (NatIso.naturality_2 e.counitIso f).symm
 #align category_theory.equivalence.fun_inv_map CategoryTheory.Equivalence.fun_inv_map
 
-/- warning: category_theory.equivalence.inv_fun_map -> CategoryTheory.Equivalence.inv_fun_map is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inv_fun_map CategoryTheory.Equivalence.inv_fun_mapₓ'. -/
 @[simp]
 theorem inv_fun_map (e : C ≌ D) (X Y : C) (f : X ⟶ Y) :
     e.inverse.map (e.Functor.map f) = e.unitInv.app X ≫ f ≫ e.Unit.app Y :=
@@ -342,9 +258,6 @@ def adjointifyη : 𝟭 C ≅ F ⋙ G :=
 #align category_theory.equivalence.adjointify_η CategoryTheory.Equivalence.adjointifyη
 -/
 
-/- warning: category_theory.equivalence.adjointify_η_ε -> CategoryTheory.Equivalence.adjointify_η_ε is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.adjointify_η_ε CategoryTheory.Equivalence.adjointify_η_εₓ'. -/
 theorem adjointify_η_ε (X : C) :
     F.map ((adjointifyη η ε).Hom.app X) ≫ ε.Hom.app (F.obj X) = 𝟙 (F.obj X) :=
   by
@@ -358,12 +271,6 @@ theorem adjointify_η_ε (X : C) :
 
 end
 
-/- warning: category_theory.equivalence.mk -> CategoryTheory.Equivalence.mk is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (G : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1), (CategoryTheory.Iso.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G)) -> (CategoryTheory.Iso.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 G F) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) -> (CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (G : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1), (CategoryTheory.Iso.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G)) -> (CategoryTheory.Iso.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 G F) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) -> (CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.mk CategoryTheory.Equivalence.mkₓ'. -/
 /-- Every equivalence of categories consisting of functors `F` and `G` such that `F ⋙ G` and
     `G ⋙ F` are naturally isomorphic to identity functors can be transformed into a half-adjoint
     equivalence without changing `F` or `G`. -/
@@ -371,12 +278,6 @@ protected def mk (F : C ⥤ D) (G : D ⥤ C) (η : 𝟭 C ≅ F ⋙ G) (ε : G 
   ⟨F, G, adjointifyη η ε, ε, adjointify_η_ε η ε⟩
 #align category_theory.equivalence.mk CategoryTheory.Equivalence.mk
 
-/- warning: category_theory.equivalence.refl -> CategoryTheory.Equivalence.refl is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C], CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C], CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.refl CategoryTheory.Equivalence.reflₓ'. -/
 /-- Equivalence of categories is reflexive. -/
 @[refl, simps]
 def refl : C ≌ C :=
@@ -386,12 +287,6 @@ def refl : C ≌ C :=
 instance : Inhabited (C ≌ C) :=
   ⟨refl⟩
 
-/- warning: category_theory.equivalence.symm -> CategoryTheory.Equivalence.symm is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D], (CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) -> (CategoryTheory.Equivalence.{u2, u1, u4, u3} D _inst_2 C _inst_1)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D], (CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) -> (CategoryTheory.Equivalence.{u2, u1, u4, u3} D C _inst_2 _inst_1)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.symm CategoryTheory.Equivalence.symmₓ'. -/
 /-- Equivalence of categories is symmetric. -/
 @[symm, simps]
 def symm (e : C ≌ D) : D ≌ C :=
@@ -400,12 +295,6 @@ def symm (e : C ≌ D) : D ≌ C :=
 
 variable {E : Type u₃} [Category.{v₃} E]
 
-/- warning: category_theory.equivalence.trans -> CategoryTheory.Equivalence.trans is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E], (CategoryTheory.Equivalence.{u1, u2, u4, u5} C _inst_1 D _inst_2) -> (CategoryTheory.Equivalence.{u2, u3, u5, u6} D _inst_2 E _inst_3) -> (CategoryTheory.Equivalence.{u1, u3, u4, u6} C _inst_1 E _inst_3)
-but is expected to have type
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E], (CategoryTheory.Equivalence.{u1, u2, u4, u5} C D _inst_1 _inst_2) -> (CategoryTheory.Equivalence.{u2, u3, u5, u6} D E _inst_2 _inst_3) -> (CategoryTheory.Equivalence.{u1, u3, u4, u6} C E _inst_1 _inst_3)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.trans CategoryTheory.Equivalence.transₓ'. -/
 /-- Equivalence of categories is transitive. -/
 @[trans, simps]
 def trans (e : C ≌ D) (f : D ≌ E) : C ≌ E
@@ -428,80 +317,38 @@ def trans (e : C ≌ D) (f : D ≌ E) : C ≌ E
     erw [comp_id, iso.hom_inv_id_app, Functor.map_id]
 #align category_theory.equivalence.trans CategoryTheory.Equivalence.trans
 
-/- warning: category_theory.equivalence.fun_inv_id_assoc -> CategoryTheory.Equivalence.funInvIdAssoc is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C _inst_1 D _inst_2) (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3), CategoryTheory.Iso.{max u4 u3, max u1 u3 u4 u6} (CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) F
-but is expected to have type
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C D _inst_1 _inst_2) (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3), CategoryTheory.Iso.{max u4 u3, max (max (max u6 u4) u3) u1} (CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F)) F
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.fun_inv_id_assoc CategoryTheory.Equivalence.funInvIdAssocₓ'. -/
 /-- Composing a functor with both functors of an equivalence yields a naturally isomorphic
 functor. -/
 def funInvIdAssoc (e : C ≌ D) (F : C ⥤ E) : e.Functor ⋙ e.inverse ⋙ F ≅ F :=
   (Functor.associator _ _ _).symm ≪≫ isoWhiskerRight e.unitIso.symm F ≪≫ F.leftUnitor
 #align category_theory.equivalence.fun_inv_id_assoc CategoryTheory.Equivalence.funInvIdAssoc
 
-/- warning: category_theory.equivalence.fun_inv_id_assoc_hom_app -> CategoryTheory.Equivalence.funInvIdAssoc_hom_app is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C _inst_1 D _inst_2) (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (X : C), Eq.{succ u3} (Quiver.Hom.{succ u3, u6} E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} C _inst_1 E _inst_3 (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) X) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} C _inst_1 E _inst_3 F X)) (CategoryTheory.NatTrans.app.{u1, u3, u4, u6} C _inst_1 E _inst_3 (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) F (CategoryTheory.Iso.hom.{max u4 u3, max u1 u3 u4 u6} (CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) F (CategoryTheory.Equivalence.funInvIdAssoc.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 e F)) X) (CategoryTheory.Functor.map.{u1, u3, u4, u6} C _inst_1 E _inst_3 F (CategoryTheory.Functor.obj.{u2, u1, u5, u4} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X)) X (CategoryTheory.NatTrans.app.{u1, u1, u4, u4} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u4, u5, u4} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u1, u4} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X))
-but is expected to have type
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C D _inst_1 _inst_2) (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (X : C), Eq.{succ u3} (Quiver.Hom.{succ u3, u6} E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (Prefunctor.obj.{succ u1, succ u3, u4, u6} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} C _inst_1 E _inst_3 (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F))) X) (Prefunctor.obj.{succ u1, succ u3, u4, u6} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} C _inst_1 E _inst_3 F) X)) (CategoryTheory.NatTrans.app.{u1, u3, u4, u6} C _inst_1 E _inst_3 (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F)) F (CategoryTheory.Iso.hom.{max u4 u3, max (max (max u4 u6) u1) u3} (CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F)) F (CategoryTheory.Equivalence.funInvIdAssoc.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 e F)) X) (Prefunctor.map.{succ u1, succ u3, u4, u6} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} C _inst_1 E _inst_3 F) (Prefunctor.obj.{succ u1, succ u1, u4, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u4, u4} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u4, u5, u4} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e))) X) (Prefunctor.obj.{succ u1, succ u1, u4, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u4, u4} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u4} C _inst_1)) X) (CategoryTheory.NatTrans.app.{u1, u1, u4, u4} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u4, u5, u4} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u4} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.fun_inv_id_assoc_hom_app CategoryTheory.Equivalence.funInvIdAssoc_hom_appₓ'. -/
 @[simp]
 theorem funInvIdAssoc_hom_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
     (funInvIdAssoc e F).Hom.app X = F.map (e.unitInv.app X) := by dsimp [fun_inv_id_assoc]; tidy
 #align category_theory.equivalence.fun_inv_id_assoc_hom_app CategoryTheory.Equivalence.funInvIdAssoc_hom_app
 
-/- warning: category_theory.equivalence.fun_inv_id_assoc_inv_app -> CategoryTheory.Equivalence.funInvIdAssoc_inv_app is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C _inst_1 D _inst_2) (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (X : C), Eq.{succ u3} (Quiver.Hom.{succ u3, u6} E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} C _inst_1 E _inst_3 F X) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} C _inst_1 E _inst_3 (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) X)) (CategoryTheory.NatTrans.app.{u1, u3, u4, u6} C _inst_1 E _inst_3 F (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) (CategoryTheory.Iso.inv.{max u4 u3, max u1 u3 u4 u6} (CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) F (CategoryTheory.Equivalence.funInvIdAssoc.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 e F)) X) (CategoryTheory.Functor.map.{u1, u3, u4, u6} C _inst_1 E _inst_3 F X (CategoryTheory.Functor.obj.{u2, u1, u5, u4} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X)) (CategoryTheory.NatTrans.app.{u1, u1, u4, u4} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u4} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u4, u5, u4} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X))
-but is expected to have type
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C D _inst_1 _inst_2) (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (X : C), Eq.{succ u3} (Quiver.Hom.{succ u3, u6} E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (Prefunctor.obj.{succ u1, succ u3, u4, u6} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} C _inst_1 E _inst_3 F) X) (Prefunctor.obj.{succ u1, succ u3, u4, u6} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} C _inst_1 E _inst_3 (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F))) X)) (CategoryTheory.NatTrans.app.{u1, u3, u4, u6} C _inst_1 E _inst_3 F (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F)) (CategoryTheory.Iso.inv.{max u4 u3, max (max (max u4 u6) u1) u3} (CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F)) F (CategoryTheory.Equivalence.funInvIdAssoc.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 e F)) X) (Prefunctor.map.{succ u1, succ u3, u4, u6} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u4, u6} C _inst_1 E _inst_3 F) (Prefunctor.obj.{succ u1, succ u1, u4, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u4, u4} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u4} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u4, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u4, u4} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u4, u5, u4} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e))) X) (CategoryTheory.NatTrans.app.{u1, u1, u4, u4} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u4} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u4, u5, u4} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.fun_inv_id_assoc_inv_app CategoryTheory.Equivalence.funInvIdAssoc_inv_appₓ'. -/
 @[simp]
 theorem funInvIdAssoc_inv_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
     (funInvIdAssoc e F).inv.app X = F.map (e.Unit.app X) := by dsimp [fun_inv_id_assoc]; tidy
 #align category_theory.equivalence.fun_inv_id_assoc_inv_app CategoryTheory.Equivalence.funInvIdAssoc_inv_app
 
-/- warning: category_theory.equivalence.inv_fun_id_assoc -> CategoryTheory.Equivalence.invFunIdAssoc is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C _inst_1 D _inst_2) (F : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3), CategoryTheory.Iso.{max u5 u3, max u2 u3 u5 u6} (CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.category.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) F
-but is expected to have type
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C D _inst_1 _inst_2) (F : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3), CategoryTheory.Iso.{max u5 u3, max (max (max u6 u5) u3) u2} (CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.category.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F)) F
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inv_fun_id_assoc CategoryTheory.Equivalence.invFunIdAssocₓ'. -/
 /-- Composing a functor with both functors of an equivalence yields a naturally isomorphic
 functor. -/
 def invFunIdAssoc (e : C ≌ D) (F : D ⥤ E) : e.inverse ⋙ e.Functor ⋙ F ≅ F :=
   (Functor.associator _ _ _).symm ≪≫ isoWhiskerRight e.counitIso F ≪≫ F.leftUnitor
 #align category_theory.equivalence.inv_fun_id_assoc CategoryTheory.Equivalence.invFunIdAssoc
 
-/- warning: category_theory.equivalence.inv_fun_id_assoc_hom_app -> CategoryTheory.Equivalence.invFunIdAssoc_hom_app is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C _inst_1 D _inst_2) (F : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (X : D), Eq.{succ u3} (Quiver.Hom.{succ u3, u6} E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} D _inst_2 E _inst_3 (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) X) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} D _inst_2 E _inst_3 F X)) (CategoryTheory.NatTrans.app.{u2, u3, u5, u6} D _inst_2 E _inst_3 (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) F (CategoryTheory.Iso.hom.{max u5 u3, max u2 u3 u5 u6} (CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.category.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) F (CategoryTheory.Equivalence.invFunIdAssoc.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 e F)) X) (CategoryTheory.Functor.map.{u2, u3, u5, u6} D _inst_2 E _inst_3 F (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u5, u4} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X)) X (CategoryTheory.NatTrans.app.{u2, u2, u5, u5} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u5, u4, u5} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u2, u5} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X))
-but is expected to have type
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C D _inst_1 _inst_2) (F : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (X : D), Eq.{succ u3} (Quiver.Hom.{succ u3, u6} E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (Prefunctor.obj.{succ u2, succ u3, u5, u6} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} D _inst_2 E _inst_3 (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F))) X) (Prefunctor.obj.{succ u2, succ u3, u5, u6} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} D _inst_2 E _inst_3 F) X)) (CategoryTheory.NatTrans.app.{u2, u3, u5, u6} D _inst_2 E _inst_3 (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F)) F (CategoryTheory.Iso.hom.{max u5 u3, max (max (max u5 u6) u2) u3} (CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.category.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F)) F (CategoryTheory.Equivalence.invFunIdAssoc.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 e F)) X) (Prefunctor.map.{succ u2, succ u3, u5, u6} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} D _inst_2 E _inst_3 F) (Prefunctor.obj.{succ u2, succ u2, u5, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u5, u5} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u5, u4, u5} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e))) X) (Prefunctor.obj.{succ u2, succ u2, u5, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u5, u5} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u5} D _inst_2)) X) (CategoryTheory.NatTrans.app.{u2, u2, u5, u5} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u5, u4, u5} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u5} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inv_fun_id_assoc_hom_app CategoryTheory.Equivalence.invFunIdAssoc_hom_appₓ'. -/
 @[simp]
 theorem invFunIdAssoc_hom_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
     (invFunIdAssoc e F).Hom.app X = F.map (e.counit.app X) := by dsimp [inv_fun_id_assoc]; tidy
 #align category_theory.equivalence.inv_fun_id_assoc_hom_app CategoryTheory.Equivalence.invFunIdAssoc_hom_app
 
-/- warning: category_theory.equivalence.inv_fun_id_assoc_inv_app -> CategoryTheory.Equivalence.invFunIdAssoc_inv_app is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C _inst_1 D _inst_2) (F : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (X : D), Eq.{succ u3} (Quiver.Hom.{succ u3, u6} E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} D _inst_2 E _inst_3 F X) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} D _inst_2 E _inst_3 (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) X)) (CategoryTheory.NatTrans.app.{u2, u3, u5, u6} D _inst_2 E _inst_3 F (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) (CategoryTheory.Iso.inv.{max u5 u3, max u2 u3 u5 u6} (CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.category.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) F)) F (CategoryTheory.Equivalence.invFunIdAssoc.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 e F)) X) (CategoryTheory.Functor.map.{u2, u3, u5, u6} D _inst_2 E _inst_3 F X (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u5, u4} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X)) (CategoryTheory.NatTrans.app.{u2, u2, u5, u5} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u5} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u5, u4, u5} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X))
-but is expected to have type
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E] (e : CategoryTheory.Equivalence.{u1, u2, u4, u5} C D _inst_1 _inst_2) (F : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (X : D), Eq.{succ u3} (Quiver.Hom.{succ u3, u6} E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (Prefunctor.obj.{succ u2, succ u3, u5, u6} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} D _inst_2 E _inst_3 F) X) (Prefunctor.obj.{succ u2, succ u3, u5, u6} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} D _inst_2 E _inst_3 (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F))) X)) (CategoryTheory.NatTrans.app.{u2, u3, u5, u6} D _inst_2 E _inst_3 F (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F)) (CategoryTheory.Iso.inv.{max u5 u3, max (max (max u5 u6) u2) u3} (CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.category.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.comp.{u2, u1, u3, u5, u4, u6} D _inst_2 C _inst_1 E _inst_3 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) F)) F (CategoryTheory.Equivalence.invFunIdAssoc.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 e F)) X) (Prefunctor.map.{succ u2, succ u3, u5, u6} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) E (CategoryTheory.CategoryStruct.toQuiver.{u3, u6} E (CategoryTheory.Category.toCategoryStruct.{u3, u6} E _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u5, u6} D _inst_2 E _inst_3 F) (Prefunctor.obj.{succ u2, succ u2, u5, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u5, u5} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u5} D _inst_2)) X) (Prefunctor.obj.{succ u2, succ u2, u5, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u5, u5} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u5, u4, u5} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e))) X) (CategoryTheory.NatTrans.app.{u2, u2, u5, u5} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u5} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u5, u4, u5} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u4, u5} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u4, u5} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u4, u5} C _inst_1 D _inst_2 e) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inv_fun_id_assoc_inv_app CategoryTheory.Equivalence.invFunIdAssoc_inv_appₓ'. -/
 @[simp]
 theorem invFunIdAssoc_inv_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
     (invFunIdAssoc e F).inv.app X = F.map (e.counitInv.app X) := by dsimp [inv_fun_id_assoc]; tidy
 #align category_theory.equivalence.inv_fun_id_assoc_inv_app CategoryTheory.Equivalence.invFunIdAssoc_inv_app
 
-/- warning: category_theory.equivalence.congr_left -> CategoryTheory.Equivalence.congrLeft is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E], (CategoryTheory.Equivalence.{u1, u2, u4, u5} C _inst_1 D _inst_2) -> (CategoryTheory.Equivalence.{max u4 u3, max u5 u3, max u1 u3 u4 u6, max u2 u3 u5 u6} (CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.category.{u2, u3, u5, u6} D _inst_2 E _inst_3))
-but is expected to have type
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E], (CategoryTheory.Equivalence.{u1, u2, u4, u5} C D _inst_1 _inst_2) -> (CategoryTheory.Equivalence.{max u4 u3, max u5 u3, max (max (max u6 u4) u3) u1, max (max (max u6 u5) u3) u2} (CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) (CategoryTheory.Functor.category.{u1, u3, u4, u6} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u2, u3, u5, u6} D _inst_2 E _inst_3))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.congr_left CategoryTheory.Equivalence.congrLeftₓ'. -/
 /-- If `C` is equivalent to `D`, then `C ⥤ E` is equivalent to `D ⥤ E`. -/
 @[simps Functor inverse unitIso counitIso]
 def congrLeft (e : C ≌ D) : C ⥤ E ≌ D ⥤ E :=
@@ -510,12 +357,6 @@ def congrLeft (e : C ≌ D) : C ⥤ E ≌ D ⥤ E :=
     (NatIso.ofComponents (fun F => e.invFunIdAssoc F) (by tidy))
 #align category_theory.equivalence.congr_left CategoryTheory.Equivalence.congrLeft
 
-/- warning: category_theory.equivalence.congr_right -> CategoryTheory.Equivalence.congrRight is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E], (CategoryTheory.Equivalence.{u1, u2, u4, u5} C _inst_1 D _inst_2) -> (CategoryTheory.Equivalence.{max u6 u1, max u6 u2, max u3 u1 u6 u4, max u3 u2 u6 u5} (CategoryTheory.Functor.{u3, u1, u6, u4} E _inst_3 C _inst_1) (CategoryTheory.Functor.category.{u3, u1, u6, u4} E _inst_3 C _inst_1) (CategoryTheory.Functor.{u3, u2, u6, u5} E _inst_3 D _inst_2) (CategoryTheory.Functor.category.{u3, u2, u6, u5} E _inst_3 D _inst_2))
-but is expected to have type
-  forall {C : Type.{u4}} [_inst_1 : CategoryTheory.Category.{u1, u4} C] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u2, u5} D] {E : Type.{u6}} [_inst_3 : CategoryTheory.Category.{u3, u6} E], (CategoryTheory.Equivalence.{u1, u2, u4, u5} C D _inst_1 _inst_2) -> (CategoryTheory.Equivalence.{max u6 u1, max u6 u2, max (max (max u4 u6) u1) u3, max (max (max u5 u6) u2) u3} (CategoryTheory.Functor.{u3, u1, u6, u4} E _inst_3 C _inst_1) (CategoryTheory.Functor.{u3, u2, u6, u5} E _inst_3 D _inst_2) (CategoryTheory.Functor.category.{u3, u1, u6, u4} E _inst_3 C _inst_1) (CategoryTheory.Functor.category.{u3, u2, u6, u5} E _inst_3 D _inst_2))
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.congr_right CategoryTheory.Equivalence.congrRightₓ'. -/
 /-- If `C` is equivalent to `D`, then `E ⥤ C` is equivalent to `E ⥤ D`. -/
 @[simps Functor inverse unitIso counitIso]
 def congrRight (e : C ≌ D) : E ⥤ C ≌ E ⥤ D :=
@@ -532,12 +373,6 @@ section CancellationLemmas
 
 variable (e : C ≌ D)
 
-/- warning: category_theory.equivalence.cancel_unit_right -> CategoryTheory.Equivalence.cancel_unit_right is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) {X : C} {Y : C} (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (f' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y), Iff (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) f (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) f' (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) f f')
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) {X : C} {Y : C} (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (f' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y), Iff (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) f (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) f' (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) f f')
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_unit_right CategoryTheory.Equivalence.cancel_unit_rightₓ'. -/
 /- We need special forms of `cancel_nat_iso_hom_right(_assoc)` and
 `cancel_nat_iso_inv_right(_assoc)` for units and counits, because neither `simp` or `rw` will apply
 those lemmas in this setting without providing `e.unit_iso` (or similar) as an explicit argument.
@@ -548,54 +383,33 @@ theorem cancel_unit_right {X Y : C} (f f' : X ⟶ Y) :
     f ≫ e.Unit.app Y = f' ≫ e.Unit.app Y ↔ f = f' := by simp only [cancel_mono]
 #align category_theory.equivalence.cancel_unit_right CategoryTheory.Equivalence.cancel_unit_right
 
-/- warning: category_theory.equivalence.cancel_unit_inv_right -> CategoryTheory.Equivalence.cancel_unitInv_right is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_unit_inv_right CategoryTheory.Equivalence.cancel_unitInv_rightₓ'. -/
 @[simp]
 theorem cancel_unitInv_right {X Y : C} (f f' : X ⟶ e.inverse.obj (e.Functor.obj Y)) :
     f ≫ e.unitInv.app Y = f' ≫ e.unitInv.app Y ↔ f = f' := by simp only [cancel_mono]
 #align category_theory.equivalence.cancel_unit_inv_right CategoryTheory.Equivalence.cancel_unitInv_right
 
-/- warning: category_theory.equivalence.cancel_counit_right -> CategoryTheory.Equivalence.cancel_counit_right is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_counit_right CategoryTheory.Equivalence.cancel_counit_rightₓ'. -/
 @[simp]
 theorem cancel_counit_right {X Y : D} (f f' : X ⟶ e.Functor.obj (e.inverse.obj Y)) :
     f ≫ e.counit.app Y = f' ≫ e.counit.app Y ↔ f = f' := by simp only [cancel_mono]
 #align category_theory.equivalence.cancel_counit_right CategoryTheory.Equivalence.cancel_counit_right
 
-/- warning: category_theory.equivalence.cancel_counit_inv_right -> CategoryTheory.Equivalence.cancel_counitInv_right is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) {X : D} {Y : D} (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) (f' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y), Iff (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X Y (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) f (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X Y (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) f' (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) f f')
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) {X : D} {Y : D} (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) (f' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y), Iff (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X Y (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) f (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X Y (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) f' (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) f f')
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_counit_inv_right CategoryTheory.Equivalence.cancel_counitInv_rightₓ'. -/
 @[simp]
 theorem cancel_counitInv_right {X Y : D} (f f' : X ⟶ Y) :
     f ≫ e.counitInv.app Y = f' ≫ e.counitInv.app Y ↔ f = f' := by simp only [cancel_mono]
 #align category_theory.equivalence.cancel_counit_inv_right CategoryTheory.Equivalence.cancel_counitInv_right
 
-/- warning: category_theory.equivalence.cancel_unit_right_assoc -> CategoryTheory.Equivalence.cancel_unit_right_assoc is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_unit_right_assoc CategoryTheory.Equivalence.cancel_unit_right_assocₓ'. -/
 @[simp]
 theorem cancel_unit_right_assoc {W X X' Y : C} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X') (g' : X' ⟶ Y) :
     f ≫ g ≫ e.Unit.app Y = f' ≫ g' ≫ e.Unit.app Y ↔ f ≫ g = f' ≫ g' := by
   simp only [← category.assoc, cancel_mono]
 #align category_theory.equivalence.cancel_unit_right_assoc CategoryTheory.Equivalence.cancel_unit_right_assoc
 
-/- warning: category_theory.equivalence.cancel_counit_inv_right_assoc -> CategoryTheory.Equivalence.cancel_counitInv_right_assoc is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_counit_inv_right_assoc CategoryTheory.Equivalence.cancel_counitInv_right_assocₓ'. -/
 @[simp]
 theorem cancel_counitInv_right_assoc {W X X' Y : D} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X')
     (g' : X' ⟶ Y) : f ≫ g ≫ e.counitInv.app Y = f' ≫ g' ≫ e.counitInv.app Y ↔ f ≫ g = f' ≫ g' := by
   simp only [← category.assoc, cancel_mono]
 #align category_theory.equivalence.cancel_counit_inv_right_assoc CategoryTheory.Equivalence.cancel_counitInv_right_assoc
 
-/- warning: category_theory.equivalence.cancel_unit_right_assoc' -> CategoryTheory.Equivalence.cancel_unit_right_assoc' is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_unit_right_assoc' CategoryTheory.Equivalence.cancel_unit_right_assoc'ₓ'. -/
 @[simp]
 theorem cancel_unit_right_assoc' {W X X' Y Y' Z : C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z)
     (f' : W ⟶ X') (g' : X' ⟶ Y') (h' : Y' ⟶ Z) :
@@ -603,9 +417,6 @@ theorem cancel_unit_right_assoc' {W X X' Y Y' Z : C} (f : W ⟶ X) (g : X ⟶ Y)
   simp only [← category.assoc, cancel_mono]
 #align category_theory.equivalence.cancel_unit_right_assoc' CategoryTheory.Equivalence.cancel_unit_right_assoc'
 
-/- warning: category_theory.equivalence.cancel_counit_inv_right_assoc' -> CategoryTheory.Equivalence.cancel_counitInv_right_assoc' is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_counit_inv_right_assoc' CategoryTheory.Equivalence.cancel_counitInv_right_assoc'ₓ'. -/
 @[simp]
 theorem cancel_counitInv_right_assoc' {W X X' Y Y' Z : D} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z)
     (f' : W ⟶ X') (g' : X' ⟶ Y') (h' : Y' ⟶ Z) :
@@ -617,12 +428,6 @@ end CancellationLemmas
 
 section
 
-/- warning: category_theory.equivalence.pow_nat -> CategoryTheory.Equivalence.powNat is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C], (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) -> Nat -> (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1)
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C], (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) -> Nat -> (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.pow_nat CategoryTheory.Equivalence.powNatₓ'. -/
 -- There's of course a monoid structure on `C ≌ C`,
 -- but let's not encourage using it.
 -- The power structure is nevertheless useful.
@@ -633,12 +438,6 @@ def powNat (e : C ≌ C) : ℕ → (C ≌ C)
   | n + 2 => e.trans (pow_nat (n + 1))
 #align category_theory.equivalence.pow_nat CategoryTheory.Equivalence.powNat
 
-/- warning: category_theory.equivalence.pow -> CategoryTheory.Equivalence.pow is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C], (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) -> Int -> (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1)
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C], (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) -> Int -> (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.pow CategoryTheory.Equivalence.powₓ'. -/
 /-- Powers of an auto-equivalence.  Use `(^)` instead. -/
 def pow (e : C ≌ C) : ℤ → (C ≌ C)
   | Int.ofNat n => e.powNat n
@@ -648,34 +447,16 @@ def pow (e : C ≌ C) : ℤ → (C ≌ C)
 instance : Pow (C ≌ C) ℤ :=
   ⟨pow⟩
 
-/- warning: category_theory.equivalence.pow_zero -> CategoryTheory.Equivalence.pow_zero is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] (e : CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1), Eq.{succ (max u2 u1)} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) (HPow.hPow.{max u2 u1, 0, max u2 u1} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) Int (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) (instHPow.{max u2 u1, 0} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) Int (CategoryTheory.Equivalence.Int.hasPow.{u1, u2} C _inst_1)) e (OfNat.ofNat.{0} Int 0 (OfNat.mk.{0} Int 0 (Zero.zero.{0} Int Int.hasZero)))) (CategoryTheory.Equivalence.refl.{u1, u2} C _inst_1)
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] (e : CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1), Eq.{max (succ u2) (succ u1)} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) (HPow.hPow.{max u2 u1, 0, max u2 u1} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) Int (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) (instHPow.{max u2 u1, 0} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) Int (CategoryTheory.Equivalence.instPowEquivalenceInt.{u1, u2} C _inst_1)) e (OfNat.ofNat.{0} Int 0 (instOfNatInt 0))) (CategoryTheory.Equivalence.refl.{u1, u2} C _inst_1)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.pow_zero CategoryTheory.Equivalence.pow_zeroₓ'. -/
 @[simp]
 theorem pow_zero (e : C ≌ C) : e ^ (0 : ℤ) = Equivalence.refl :=
   rfl
 #align category_theory.equivalence.pow_zero CategoryTheory.Equivalence.pow_zero
 
-/- warning: category_theory.equivalence.pow_one -> CategoryTheory.Equivalence.pow_one is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] (e : CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1), Eq.{succ (max u2 u1)} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) (HPow.hPow.{max u2 u1, 0, max u2 u1} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) Int (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) (instHPow.{max u2 u1, 0} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) Int (CategoryTheory.Equivalence.Int.hasPow.{u1, u2} C _inst_1)) e (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))) e
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] (e : CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1), Eq.{max (succ u2) (succ u1)} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) (HPow.hPow.{max u2 u1, 0, max u2 u1} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) Int (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) (instHPow.{max u2 u1, 0} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) Int (CategoryTheory.Equivalence.instPowEquivalenceInt.{u1, u2} C _inst_1)) e (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) e
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.pow_one CategoryTheory.Equivalence.pow_oneₓ'. -/
 @[simp]
 theorem pow_one (e : C ≌ C) : e ^ (1 : ℤ) = e :=
   rfl
 #align category_theory.equivalence.pow_one CategoryTheory.Equivalence.pow_one
 
-/- warning: category_theory.equivalence.pow_neg_one -> CategoryTheory.Equivalence.pow_neg_one is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] (e : CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1), Eq.{succ (max u2 u1)} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) (HPow.hPow.{max u2 u1, 0, max u2 u1} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) Int (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) (instHPow.{max u2 u1, 0} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C _inst_1 C _inst_1) Int (CategoryTheory.Equivalence.Int.hasPow.{u1, u2} C _inst_1)) e (Neg.neg.{0} Int Int.hasNeg (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) (CategoryTheory.Equivalence.symm.{u1, u1, u2, u2} C _inst_1 C _inst_1 e)
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] (e : CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1), Eq.{max (succ u2) (succ u1)} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) (HPow.hPow.{max u2 u1, 0, max u2 u1} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) Int (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) (instHPow.{max u2 u1, 0} (CategoryTheory.Equivalence.{u1, u1, u2, u2} C C _inst_1 _inst_1) Int (CategoryTheory.Equivalence.instPowEquivalenceInt.{u1, u2} C _inst_1)) e (Neg.neg.{0} Int Int.instNegInt (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) (CategoryTheory.Equivalence.symm.{u1, u1, u2, u2} C _inst_1 C _inst_1 e)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.pow_neg_one CategoryTheory.Equivalence.pow_neg_oneₓ'. -/
 @[simp]
 theorem pow_neg_one (e : C ≌ C) : e ^ (-1 : ℤ) = e.symm :=
   rfl
@@ -707,22 +488,10 @@ attribute [simp, reassoc] is_equivalence.functor_unit_iso_comp
 
 namespace IsEquivalence
 
-/- warning: category_theory.is_equivalence.of_equivalence -> CategoryTheory.IsEquivalence.ofEquivalence is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2), CategoryTheory.IsEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), CategoryTheory.IsEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 F)
-Case conversion may be inaccurate. Consider using '#align category_theory.is_equivalence.of_equivalence CategoryTheory.IsEquivalence.ofEquivalenceₓ'. -/
 instance ofEquivalence (F : C ≌ D) : IsEquivalence F.Functor :=
   { F with }
 #align category_theory.is_equivalence.of_equivalence CategoryTheory.IsEquivalence.ofEquivalence
 
-/- warning: category_theory.is_equivalence.of_equivalence_inverse -> CategoryTheory.IsEquivalence.ofEquivalenceInverse is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2), CategoryTheory.IsEquivalence.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 F)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), CategoryTheory.IsEquivalence.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 F)
-Case conversion may be inaccurate. Consider using '#align category_theory.is_equivalence.of_equivalence_inverse CategoryTheory.IsEquivalence.ofEquivalenceInverseₓ'. -/
 instance ofEquivalenceInverse (F : C ≌ D) : IsEquivalence F.inverse :=
   IsEquivalence.ofEquivalence F.symm
 #align category_theory.is_equivalence.of_equivalence_inverse CategoryTheory.IsEquivalence.ofEquivalenceInverse
@@ -741,12 +510,6 @@ end IsEquivalence
 
 namespace Functor
 
-/- warning: category_theory.functor.as_equivalence -> CategoryTheory.Functor.asEquivalence is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.IsEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F], CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.IsEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F], CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.as_equivalence CategoryTheory.Functor.asEquivalenceₓ'. -/
 /-- Interpret a functor that is an equivalence as an equivalence. -/
 def asEquivalence (F : C ⥤ D) [IsEquivalence F] : C ≌ D :=
   ⟨F, IsEquivalence.inverse F, IsEquivalence.unitIso, IsEquivalence.counitIso,
@@ -822,44 +585,20 @@ end Functor
 
 namespace Equivalence
 
-/- warning: category_theory.equivalence.functor_inv -> CategoryTheory.Equivalence.functor_inv is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (E : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2), Eq.{succ (max u2 u1 u4 u3)} (CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1) (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 E) (CategoryTheory.IsEquivalence.ofEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (E : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), Eq.{max (max (max (succ u3) (succ u4)) (succ u1)) (succ u2)} (CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1) (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 E) (CategoryTheory.IsEquivalence.ofEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 E)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.functor_inv CategoryTheory.Equivalence.functor_invₓ'. -/
 @[simp]
 theorem functor_inv (E : C ≌ D) : E.Functor.inv = E.inverse :=
   rfl
 #align category_theory.equivalence.functor_inv CategoryTheory.Equivalence.functor_inv
 
-/- warning: category_theory.equivalence.inverse_inv -> CategoryTheory.Equivalence.inverse_inv is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (E : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2), Eq.{succ (max u1 u2 u3 u4)} (CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.inv.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 E) (CategoryTheory.IsEquivalence.ofEquivalenceInverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (E : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), Eq.{max (max (max (succ u3) (succ u4)) (succ u1)) (succ u2)} (CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.inv.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 E) (CategoryTheory.IsEquivalence.ofEquivalenceInverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 E)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inverse_inv CategoryTheory.Equivalence.inverse_invₓ'. -/
 @[simp]
 theorem inverse_inv (E : C ≌ D) : E.inverse.inv = E.Functor :=
   rfl
 #align category_theory.equivalence.inverse_inv CategoryTheory.Equivalence.inverse_inv
 
-/- warning: category_theory.equivalence.functor_as_equivalence -> CategoryTheory.Equivalence.functor_asEquivalence is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (E : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2), Eq.{max (succ u3) (succ u4) (succ u1) (succ u2)} (CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 E) (CategoryTheory.IsEquivalence.ofEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)) E
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (E : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), Eq.{max (max (max (succ u3) (succ u4)) (succ u1)) (succ u2)} (CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 E) (CategoryTheory.IsEquivalence.ofEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)) E
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.functor_as_equivalence CategoryTheory.Equivalence.functor_asEquivalenceₓ'. -/
 @[simp]
 theorem functor_asEquivalence (E : C ≌ D) : E.Functor.asEquivalence = E := by cases E; congr
 #align category_theory.equivalence.functor_as_equivalence CategoryTheory.Equivalence.functor_asEquivalence
 
-/- warning: category_theory.equivalence.inverse_as_equivalence -> CategoryTheory.Equivalence.inverse_asEquivalence is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (E : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2), Eq.{max (succ u4) (succ u3) (succ u2) (succ u1)} (CategoryTheory.Equivalence.{u2, u1, u4, u3} D _inst_2 C _inst_1) (CategoryTheory.Functor.asEquivalence.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 E) (CategoryTheory.IsEquivalence.ofEquivalenceInverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)) (CategoryTheory.Equivalence.symm.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (E : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), Eq.{max (max (max (succ u3) (succ u4)) (succ u1)) (succ u2)} (CategoryTheory.Equivalence.{u2, u1, u4, u3} D C _inst_2 _inst_1) (CategoryTheory.Functor.asEquivalence.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 E) (CategoryTheory.IsEquivalence.ofEquivalenceInverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)) (CategoryTheory.Equivalence.symm.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inverse_as_equivalence CategoryTheory.Equivalence.inverse_asEquivalenceₓ'. -/
 @[simp]
 theorem inverse_asEquivalence (E : C ≌ D) : E.inverse.asEquivalence = E.symm := by cases E; congr
 #align category_theory.equivalence.inverse_as_equivalence CategoryTheory.Equivalence.inverse_asEquivalence
@@ -868,9 +607,6 @@ end Equivalence
 
 namespace IsEquivalence
 
-/- warning: category_theory.is_equivalence.fun_inv_map -> CategoryTheory.IsEquivalence.fun_inv_map is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.is_equivalence.fun_inv_map CategoryTheory.IsEquivalence.fun_inv_mapₓ'. -/
 @[simp]
 theorem fun_inv_map (F : C ⥤ D) [IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
     F.map (F.inv.map f) = F.asEquivalence.counit.app X ≫ f ≫ F.asEquivalence.counitInv.app Y :=
@@ -879,9 +615,6 @@ theorem fun_inv_map (F : C ⥤ D) [IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
   rfl
 #align category_theory.is_equivalence.fun_inv_map CategoryTheory.IsEquivalence.fun_inv_map
 
-/- warning: category_theory.is_equivalence.inv_fun_map -> CategoryTheory.IsEquivalence.inv_fun_map is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.is_equivalence.inv_fun_map CategoryTheory.IsEquivalence.inv_fun_mapₓ'. -/
 @[simp]
 theorem inv_fun_map (F : C ⥤ D) [IsEquivalence F] (X Y : C) (f : X ⟶ Y) :
     F.inv.map (F.map f) = F.asEquivalence.unitInv.app X ≫ f ≫ F.asEquivalence.Unit.app Y :=
@@ -1035,24 +768,12 @@ noncomputable def ofFullyFaithfullyEssSurj (F : C ⥤ D) [Full F] [Faithful F] [
 #align category_theory.equivalence.of_fully_faithfully_ess_surj CategoryTheory.Equivalence.ofFullyFaithfullyEssSurj
 -/
 
-/- warning: category_theory.equivalence.functor_map_inj_iff -> CategoryTheory.Equivalence.functor_map_inj_iff is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) {X : C} {Y : C} (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (g : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y), Iff (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X Y f) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X Y g)) (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) f g)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) {X : C} {Y : C} (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (g : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y), Iff (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X Y f) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X Y g)) (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) f g)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.functor_map_inj_iff CategoryTheory.Equivalence.functor_map_inj_iffₓ'. -/
 @[simp]
 theorem functor_map_inj_iff (e : C ≌ D) {X Y : C} (f g : X ⟶ Y) :
     e.Functor.map f = e.Functor.map g ↔ f = g :=
   ⟨fun h => e.Functor.map_injective h, fun h => h ▸ rfl⟩
 #align category_theory.equivalence.functor_map_inj_iff CategoryTheory.Equivalence.functor_map_inj_iff
 
-/- warning: category_theory.equivalence.inverse_map_inj_iff -> CategoryTheory.Equivalence.inverse_map_inj_iff is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) {X : D} {Y : D} (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) (g : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y), Iff (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.map.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X Y f) (CategoryTheory.Functor.map.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X Y g)) (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) f g)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) {X : D} {Y : D} (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) (g : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y), Iff (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X Y f) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X Y g)) (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) f g)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inverse_map_inj_iff CategoryTheory.Equivalence.inverse_map_inj_iffₓ'. -/
 @[simp]
 theorem inverse_map_inj_iff (e : C ≌ D) {X Y : D} (f g : X ⟶ Y) :
     e.inverse.map f = e.inverse.map g ↔ f = g :=

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

@@ -222,11 +222,8 @@ but is expected to have type
   forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X))) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.counit_inv_app_functor CategoryTheory.Equivalence.counitInv_app_functorₓ'. -/
 theorem counitInv_app_functor (e : C ≌ D) (X : C) :
-    e.counitInv.app (e.Functor.obj X) = e.Functor.map (e.Unit.app X) :=
-  by
-  symm
-  erw [← iso.comp_hom_eq_id (e.counit_iso.app _), functor_unit_comp]
-  rfl
+    e.counitInv.app (e.Functor.obj X) = e.Functor.map (e.Unit.app X) := by symm;
+  erw [← iso.comp_hom_eq_id (e.counit_iso.app _), functor_unit_comp]; rfl
 #align category_theory.equivalence.counit_inv_app_functor CategoryTheory.Equivalence.counitInv_app_functor
 
 /- warning: category_theory.equivalence.counit_app_functor -> CategoryTheory.Equivalence.counit_app_functor is a dubious translation:
@@ -236,10 +233,8 @@ but is expected to have type
   forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X))) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.counit_app_functor CategoryTheory.Equivalence.counit_app_functorₓ'. -/
 theorem counit_app_functor (e : C ≌ D) (X : C) :
-    e.counit.app (e.Functor.obj X) = e.Functor.map (e.unitInv.app X) :=
-  by
-  erw [← iso.hom_comp_eq_id (e.functor.map_iso (e.unit_iso.app X)), functor_unit_comp]
-  rfl
+    e.counit.app (e.Functor.obj X) = e.Functor.map (e.unitInv.app X) := by
+  erw [← iso.hom_comp_eq_id (e.functor.map_iso (e.unit_iso.app X)), functor_unit_comp]; rfl
 #align category_theory.equivalence.counit_app_functor CategoryTheory.Equivalence.counit_app_functor
 
 /- warning: category_theory.equivalence.unit_inverse_comp -> CategoryTheory.Equivalence.unit_inverse_comp is a dubious translation:
@@ -292,10 +287,8 @@ but is expected to have type
   forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (Y : D), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.unit_app_inverse CategoryTheory.Equivalence.unit_app_inverseₓ'. -/
 theorem unit_app_inverse (e : C ≌ D) (Y : D) :
-    e.Unit.app (e.inverse.obj Y) = e.inverse.map (e.counitInv.app Y) :=
-  by
-  erw [← iso.comp_hom_eq_id (e.inverse.map_iso (e.counit_iso.app Y)), unit_inverse_comp]
-  rfl
+    e.Unit.app (e.inverse.obj Y) = e.inverse.map (e.counitInv.app Y) := by
+  erw [← iso.comp_hom_eq_id (e.inverse.map_iso (e.counit_iso.app Y)), unit_inverse_comp]; rfl
 #align category_theory.equivalence.unit_app_inverse CategoryTheory.Equivalence.unit_app_inverse
 
 /- warning: category_theory.equivalence.unit_inv_app_inverse -> CategoryTheory.Equivalence.unitInv_app_inverse is a dubious translation:
@@ -305,11 +298,8 @@ but is expected to have type
   forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (Y : D), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.unit_inv_app_inverse CategoryTheory.Equivalence.unitInv_app_inverseₓ'. -/
 theorem unitInv_app_inverse (e : C ≌ D) (Y : D) :
-    e.unitInv.app (e.inverse.obj Y) = e.inverse.map (e.counit.app Y) :=
-  by
-  symm
-  erw [← iso.hom_comp_eq_id (e.unit_iso.app _), unit_inverse_comp]
-  rfl
+    e.unitInv.app (e.inverse.obj Y) = e.inverse.map (e.counit.app Y) := by symm;
+  erw [← iso.hom_comp_eq_id (e.unit_iso.app _), unit_inverse_comp]; rfl
 #align category_theory.equivalence.unit_inv_app_inverse CategoryTheory.Equivalence.unitInv_app_inverse
 
 /- warning: category_theory.equivalence.fun_inv_map -> CategoryTheory.Equivalence.fun_inv_map is a dubious translation:
@@ -458,10 +448,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.fun_inv_id_assoc_hom_app CategoryTheory.Equivalence.funInvIdAssoc_hom_appₓ'. -/
 @[simp]
 theorem funInvIdAssoc_hom_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
-    (funInvIdAssoc e F).Hom.app X = F.map (e.unitInv.app X) :=
-  by
-  dsimp [fun_inv_id_assoc]
-  tidy
+    (funInvIdAssoc e F).Hom.app X = F.map (e.unitInv.app X) := by dsimp [fun_inv_id_assoc]; tidy
 #align category_theory.equivalence.fun_inv_id_assoc_hom_app CategoryTheory.Equivalence.funInvIdAssoc_hom_app
 
 /- warning: category_theory.equivalence.fun_inv_id_assoc_inv_app -> CategoryTheory.Equivalence.funInvIdAssoc_inv_app is a dubious translation:
@@ -472,10 +459,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.fun_inv_id_assoc_inv_app CategoryTheory.Equivalence.funInvIdAssoc_inv_appₓ'. -/
 @[simp]
 theorem funInvIdAssoc_inv_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
-    (funInvIdAssoc e F).inv.app X = F.map (e.Unit.app X) :=
-  by
-  dsimp [fun_inv_id_assoc]
-  tidy
+    (funInvIdAssoc e F).inv.app X = F.map (e.Unit.app X) := by dsimp [fun_inv_id_assoc]; tidy
 #align category_theory.equivalence.fun_inv_id_assoc_inv_app CategoryTheory.Equivalence.funInvIdAssoc_inv_app
 
 /- warning: category_theory.equivalence.inv_fun_id_assoc -> CategoryTheory.Equivalence.invFunIdAssoc is a dubious translation:
@@ -498,10 +482,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inv_fun_id_assoc_hom_app CategoryTheory.Equivalence.invFunIdAssoc_hom_appₓ'. -/
 @[simp]
 theorem invFunIdAssoc_hom_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
-    (invFunIdAssoc e F).Hom.app X = F.map (e.counit.app X) :=
-  by
-  dsimp [inv_fun_id_assoc]
-  tidy
+    (invFunIdAssoc e F).Hom.app X = F.map (e.counit.app X) := by dsimp [inv_fun_id_assoc]; tidy
 #align category_theory.equivalence.inv_fun_id_assoc_hom_app CategoryTheory.Equivalence.invFunIdAssoc_hom_app
 
 /- warning: category_theory.equivalence.inv_fun_id_assoc_inv_app -> CategoryTheory.Equivalence.invFunIdAssoc_inv_app is a dubious translation:
@@ -512,10 +493,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inv_fun_id_assoc_inv_app CategoryTheory.Equivalence.invFunIdAssoc_inv_appₓ'. -/
 @[simp]
 theorem invFunIdAssoc_inv_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
-    (invFunIdAssoc e F).inv.app X = F.map (e.counitInv.app X) :=
-  by
-  dsimp [inv_fun_id_assoc]
-  tidy
+    (invFunIdAssoc e F).inv.app X = F.map (e.counitInv.app X) := by dsimp [inv_fun_id_assoc]; tidy
 #align category_theory.equivalence.inv_fun_id_assoc_inv_app CategoryTheory.Equivalence.invFunIdAssoc_inv_app
 
 /- warning: category_theory.equivalence.congr_left -> CategoryTheory.Equivalence.congrLeft is a dubious translation:
@@ -873,10 +851,7 @@ but is expected to have type
   forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (E : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), Eq.{max (max (max (succ u3) (succ u4)) (succ u1)) (succ u2)} (CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 E) (CategoryTheory.IsEquivalence.ofEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)) E
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.functor_as_equivalence CategoryTheory.Equivalence.functor_asEquivalenceₓ'. -/
 @[simp]
-theorem functor_asEquivalence (E : C ≌ D) : E.Functor.asEquivalence = E :=
-  by
-  cases E
-  congr
+theorem functor_asEquivalence (E : C ≌ D) : E.Functor.asEquivalence = E := by cases E; congr
 #align category_theory.equivalence.functor_as_equivalence CategoryTheory.Equivalence.functor_asEquivalence
 
 /- warning: category_theory.equivalence.inverse_as_equivalence -> CategoryTheory.Equivalence.inverse_asEquivalence is a dubious translation:
@@ -886,10 +861,7 @@ but is expected to have type
   forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (E : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2), Eq.{max (max (max (succ u3) (succ u4)) (succ u1)) (succ u2)} (CategoryTheory.Equivalence.{u2, u1, u4, u3} D C _inst_2 _inst_1) (CategoryTheory.Functor.asEquivalence.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 E) (CategoryTheory.IsEquivalence.ofEquivalenceInverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)) (CategoryTheory.Equivalence.symm.{u1, u2, u3, u4} C _inst_1 D _inst_2 E)
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inverse_as_equivalence CategoryTheory.Equivalence.inverse_asEquivalenceₓ'. -/
 @[simp]
-theorem inverse_asEquivalence (E : C ≌ D) : E.inverse.asEquivalence = E.symm :=
-  by
-  cases E
-  congr
+theorem inverse_asEquivalence (E : C ≌ D) : E.inverse.asEquivalence = E.symm := by cases E; congr
 #align category_theory.equivalence.inverse_as_equivalence CategoryTheory.Equivalence.inverse_asEquivalence
 
 end Equivalence
@@ -1058,9 +1030,7 @@ noncomputable def ofFullyFaithfullyEssSurj (F : C ⥤ D) [Full F] [Faithful F] [
     IsEquivalence F :=
   IsEquivalence.mk (equivalenceInverse F)
     (NatIso.ofComponents (fun X => (F.preimageIso <| F.objObjPreimageIso <| F.obj X).symm)
-      fun X Y f => by
-      apply F.map_injective
-      obviously)
+      fun X Y f => by apply F.map_injective; obviously)
     (NatIso.ofComponents F.objObjPreimageIso (by tidy))
 #align category_theory.equivalence.of_fully_faithfully_ess_surj CategoryTheory.Equivalence.ofFullyFaithfullyEssSurj
 -/

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

@@ -157,10 +157,7 @@ abbrev counitInv (e : C ≌ D) : 𝟭 D ⟶ e.inverse ⋙ e.Functor :=
 #align category_theory.equivalence.counit_inv CategoryTheory.Equivalence.counitInv
 
 /- warning: category_theory.equivalence.equivalence_mk'_unit -> CategoryTheory.Equivalence.Equivalence_mk'_unit is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (functor : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (inverse : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1) (unit_iso : CategoryTheory.Iso.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) (counit_iso : CategoryTheory.Iso.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (f : autoParamₓ.{0} (forall (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X)) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) (CategoryTheory.Iso.hom.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Iso.hom.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 118 (OfNat.mk.{0} Nat 118 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 121 (OfNat.mk.{0} Nat 121 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous)), Eq.{succ (max u3 u1)} (Quiver.Hom.{succ (max u3 u1), max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.CategoryStruct.toQuiver.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Category.toCategoryStruct.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1))) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f)))) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Iso.hom.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (functor : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (inverse : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1) (unit_iso : CategoryTheory.Iso.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) (counit_iso : CategoryTheory.Iso.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (f : forall (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) (CategoryTheory.Iso.hom.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Iso.hom.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))), Eq.{max (succ u3) (succ u1)} (Quiver.Hom.{max (succ u3) (succ u1), max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.CategoryStruct.toQuiver.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Category.toCategoryStruct.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1))) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f)))) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Iso.hom.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso)
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.equivalence_mk'_unit CategoryTheory.Equivalence.Equivalence_mk'_unitₓ'. -/
 /- While these abbreviations are convenient, they also cause some trouble,
 preventing structure projections from unfolding. -/
@@ -171,10 +168,7 @@ theorem Equivalence_mk'_unit (functor inverse unit_iso counit_iso f) :
 #align category_theory.equivalence.equivalence_mk'_unit CategoryTheory.Equivalence.Equivalence_mk'_unit
 
 /- warning: category_theory.equivalence.equivalence_mk'_counit -> CategoryTheory.Equivalence.Equivalence_mk'_counit is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (functor : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (inverse : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1) (unit_iso : CategoryTheory.Iso.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) (counit_iso : CategoryTheory.Iso.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (f : autoParamₓ.{0} (forall (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X)) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) (CategoryTheory.Iso.hom.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Iso.hom.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 118 (OfNat.mk.{0} Nat 118 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 121 (OfNat.mk.{0} Nat 121 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous)), Eq.{succ (max u4 u2)} (Quiver.Hom.{succ (max u4 u2), max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2))) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f))) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Iso.hom.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (functor : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (inverse : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1) (unit_iso : CategoryTheory.Iso.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) (counit_iso : CategoryTheory.Iso.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (f : forall (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) (CategoryTheory.Iso.hom.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Iso.hom.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))), Eq.{max (succ u4) (succ u2)} (Quiver.Hom.{max (succ u4) (succ u2), max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2))) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f))) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Iso.hom.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso)
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.equivalence_mk'_counit CategoryTheory.Equivalence.Equivalence_mk'_counitₓ'. -/
 @[simp]
 theorem Equivalence_mk'_counit (functor inverse unit_iso counit_iso f) :
@@ -183,10 +177,7 @@ theorem Equivalence_mk'_counit (functor inverse unit_iso counit_iso f) :
 #align category_theory.equivalence.equivalence_mk'_counit CategoryTheory.Equivalence.Equivalence_mk'_counit
 
 /- warning: category_theory.equivalence.equivalence_mk'_unit_inv -> CategoryTheory.Equivalence.Equivalence_mk'_unitInv is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (functor : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (inverse : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1) (unit_iso : CategoryTheory.Iso.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) (counit_iso : CategoryTheory.Iso.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (f : autoParamₓ.{0} (forall (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X)) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) (CategoryTheory.Iso.hom.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Iso.hom.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 118 (OfNat.mk.{0} Nat 118 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 121 (OfNat.mk.{0} Nat 121 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous)), Eq.{succ (max u3 u1)} (Quiver.Hom.{succ (max u3 u1), max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.CategoryStruct.toQuiver.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Category.toCategoryStruct.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1))) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f))) (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Iso.inv.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (functor : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (inverse : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1) (unit_iso : CategoryTheory.Iso.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) (counit_iso : CategoryTheory.Iso.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (f : forall (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) (CategoryTheory.Iso.hom.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Iso.hom.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))), Eq.{max (succ u3) (succ u1)} (Quiver.Hom.{max (succ u3) (succ u1), max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.CategoryStruct.toQuiver.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Category.toCategoryStruct.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1))) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f))) (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Iso.inv.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso)
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.equivalence_mk'_unit_inv CategoryTheory.Equivalence.Equivalence_mk'_unitInvₓ'. -/
 @[simp]
 theorem Equivalence_mk'_unitInv (functor inverse unit_iso counit_iso f) :
@@ -195,10 +186,7 @@ theorem Equivalence_mk'_unitInv (functor inverse unit_iso counit_iso f) :
 #align category_theory.equivalence.equivalence_mk'_unit_inv CategoryTheory.Equivalence.Equivalence_mk'_unitInv
 
 /- warning: category_theory.equivalence.equivalence_mk'_counit_inv -> CategoryTheory.Equivalence.Equivalence_mk'_counitInv is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (functor : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (inverse : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1) (unit_iso : CategoryTheory.Iso.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) (counit_iso : CategoryTheory.Iso.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (f : autoParamₓ.{0} (forall (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X)) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) (CategoryTheory.Iso.hom.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Iso.hom.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor X))) (Name.mk_string (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str (String.str String.empty (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 98 (OfNat.mk.{0} Nat 98 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 118 (OfNat.mk.{0} Nat 118 (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 105 (OfNat.mk.{0} Nat 105 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 111 (OfNat.mk.{0} Nat 111 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 117 (OfNat.mk.{0} Nat 117 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 115 (OfNat.mk.{0} Nat 115 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 108 (OfNat.mk.{0} Nat 108 (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) (Char.ofNat (OfNat.ofNat.{0} Nat 121 (OfNat.mk.{0} Nat 121 (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit0.{0} Nat Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (bit1.{0} Nat Nat.hasOne Nat.hasAdd (One.one.{0} Nat Nat.hasOne))))))))))) Name.anonymous)), Eq.{succ (max u4 u2)} (Quiver.Hom.{succ (max u4 u2), max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2))) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f)))) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Iso.inv.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso)
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (functor : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (inverse : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1) (unit_iso : CategoryTheory.Iso.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) (counit_iso : CategoryTheory.Iso.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (f : forall (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse)) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) (CategoryTheory.Iso.hom.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 functor inverse) unit_iso) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Iso.hom.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 functor) X))), Eq.{max (succ u4) (succ u2)} (Quiver.Hom.{max (succ u4) (succ u2), max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2))) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f)))) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.mk'.{u1, u2, u3, u4} C D _inst_1 _inst_2 functor inverse unit_iso counit_iso f)) (CategoryTheory.Iso.inv.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 inverse functor) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) counit_iso)
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.equivalence_mk'_counit_inv CategoryTheory.Equivalence.Equivalence_mk'_counitInvₓ'. -/
 @[simp]
 theorem Equivalence_mk'_counitInv (functor inverse unit_iso counit_iso f) :
@@ -207,10 +195,7 @@ theorem Equivalence_mk'_counitInv (functor inverse unit_iso counit_iso f) :
 #align category_theory.equivalence.equivalence_mk'_counit_inv CategoryTheory.Equivalence.Equivalence_mk'_counitInv
 
 /- warning: category_theory.equivalence.functor_unit_comp -> CategoryTheory.Equivalence.functor_unit_comp is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.functor_unit_comp CategoryTheory.Equivalence.functor_unit_compₓ'. -/
 @[simp]
 theorem functor_unit_comp (e : C ≌ D) (X : C) :
@@ -219,10 +204,7 @@ theorem functor_unit_comp (e : C ≌ D) (X : C) :
 #align category_theory.equivalence.functor_unit_comp CategoryTheory.Equivalence.functor_unit_comp
 
 /- warning: category_theory.equivalence.counit_inv_functor_comp -> CategoryTheory.Equivalence.counitInv_functor_comp is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.counit_inv_functor_comp CategoryTheory.Equivalence.counitInv_functor_compₓ'. -/
 @[simp]
 theorem counitInv_functor_comp (e : C ≌ D) (X : C) :
@@ -261,10 +243,7 @@ theorem counit_app_functor (e : C ≌ D) (X : C) :
 #align category_theory.equivalence.counit_app_functor CategoryTheory.Equivalence.counit_app_functor
 
 /- warning: category_theory.equivalence.unit_inverse_comp -> CategoryTheory.Equivalence.unit_inverse_comp is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (Y : D), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) Y))) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) Y)) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.map.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) Y) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.CategoryStruct.id.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (Y : D), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y))) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y)) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.CategoryStruct.id.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.unit_inverse_comp CategoryTheory.Equivalence.unit_inverse_compₓ'. -/
 /-- The other triangle equality. The proof follows the following proof in Globular:
   http://globular.science/1905.001 -/
@@ -295,10 +274,7 @@ theorem unit_inverse_comp (e : C ≌ D) (Y : D) :
 #align category_theory.equivalence.unit_inverse_comp CategoryTheory.Equivalence.unit_inverse_comp
 
 /- warning: category_theory.equivalence.inverse_counit_inv_comp -> CategoryTheory.Equivalence.inverse_counitInv_comp is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (Y : D), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) Y)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) Y)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.map.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) Y) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.CategoryStruct.id.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (Y : D), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) (CategoryTheory.CategoryStruct.id.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inverse_counit_inv_comp CategoryTheory.Equivalence.inverse_counitInv_compₓ'. -/
 @[simp]
 theorem inverse_counitInv_comp (e : C ≌ D) (Y : D) :
@@ -337,10 +313,7 @@ theorem unitInv_app_inverse (e : C ≌ D) (Y : D) :
 #align category_theory.equivalence.unit_inv_app_inverse CategoryTheory.Equivalence.unitInv_app_inverse
 
 /- warning: category_theory.equivalence.fun_inv_map -> CategoryTheory.Equivalence.fun_inv_map is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (X : D) (Y : D) (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y) (CategoryTheory.Functor.map.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X Y f)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) X) Y (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) f (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (X : D) (Y : D) (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X Y f)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) X) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) X) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) X) Y (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) f (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.fun_inv_map CategoryTheory.Equivalence.fun_inv_mapₓ'. -/
 @[simp]
 theorem fun_inv_map (e : C ≌ D) (X Y : D) (f : X ⟶ Y) :
@@ -349,10 +322,7 @@ theorem fun_inv_map (e : C ≌ D) (X Y : D) (f : X ⟶ Y) :
 #align category_theory.equivalence.fun_inv_map CategoryTheory.Equivalence.fun_inv_map
 
 /- warning: category_theory.equivalence.inv_fun_map -> CategoryTheory.Equivalence.inv_fun_map is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) (X : C) (Y : C) (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.Functor.map.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X Y f)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) Y (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) f (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) (X : C) (Y : C) (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) X Y f)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) X) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) Y (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) f (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.inv_fun_map CategoryTheory.Equivalence.inv_fun_mapₓ'. -/
 @[simp]
 theorem inv_fun_map (e : C ≌ D) (X Y : C) (f : X ⟶ Y) :
@@ -383,10 +353,7 @@ def adjointifyη : 𝟭 C ≅ F ⋙ G :=
 -/
 
 /- warning: category_theory.equivalence.adjointify_η_ε -> CategoryTheory.Equivalence.adjointify_η_ε is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] {F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1} (η : CategoryTheory.Iso.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G)) (ε : CategoryTheory.Iso.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 G F) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F X)) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 F (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G) (CategoryTheory.Iso.hom.{max u3 u1, max u1 u3} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G) (CategoryTheory.Equivalence.adjointifyη.{u1, u2, u3, u4} C _inst_1 D _inst_2 F G η ε)) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 G F) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Iso.hom.{max u4 u2, max u2 u4} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 G F) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) ε) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F X))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] {F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u2, u1, u4, u3} D _inst_2 C _inst_1} (η : CategoryTheory.Iso.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G)) (ε : CategoryTheory.Iso.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 G F) (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) X))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G)) X)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) X)) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G)) X) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G) (CategoryTheory.Iso.hom.{max u3 u1, max u3 u1} (CategoryTheory.Functor.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.category.{u1, u1, u3, u3} C _inst_1 C _inst_1) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 F G) (CategoryTheory.Equivalence.adjointifyη.{u1, u2, u3, u4} C _inst_1 D _inst_2 F G η ε)) X)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 G F) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Iso.hom.{max u4 u2, max u4 u2} (CategoryTheory.Functor.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.category.{u2, u2, u4, u4} D _inst_2 D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 G F) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) ε) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) X))) (CategoryTheory.CategoryStruct.id.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) X))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.adjointify_η_ε CategoryTheory.Equivalence.adjointify_η_εₓ'. -/
 theorem adjointify_η_ε (X : C) :
     F.map ((adjointifyη η ε).Hom.app X) ≫ ε.Hom.app (F.obj X) = 𝟙 (F.obj X) :=
@@ -604,10 +571,7 @@ theorem cancel_unit_right {X Y : C} (f f' : X ⟶ Y) :
 #align category_theory.equivalence.cancel_unit_right CategoryTheory.Equivalence.cancel_unit_right
 
 /- warning: category_theory.equivalence.cancel_unit_inv_right -> CategoryTheory.Equivalence.cancel_unitInv_right is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) {X : C} {Y : C} (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (f' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))), Iff (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) Y)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) Y) f (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) Y) f' (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) f f')
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) {X : C} {Y : C} (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) (f' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))), Iff (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) Y)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) Y) f (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) Y) f' (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) f f')
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_unit_inv_right CategoryTheory.Equivalence.cancel_unitInv_rightₓ'. -/
 @[simp]
 theorem cancel_unitInv_right {X Y : C} (f f' : X ⟶ e.inverse.obj (e.Functor.obj Y)) :
@@ -615,10 +579,7 @@ theorem cancel_unitInv_right {X Y : C} (f f' : X ⟶ e.inverse.obj (e.Functor.ob
 #align category_theory.equivalence.cancel_unit_inv_right CategoryTheory.Equivalence.cancel_unitInv_right
 
 /- warning: category_theory.equivalence.cancel_counit_right -> CategoryTheory.Equivalence.cancel_counit_right is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) {X : D} {Y : D} (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (f' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))), Iff (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) Y)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) Y) f (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) Y) f' (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) f f')
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) {X : D} {Y : D} (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) (f' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))), Iff (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y) f (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y)) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) Y) f' (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) Y))) f f')
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_counit_right CategoryTheory.Equivalence.cancel_counit_rightₓ'. -/
 @[simp]
 theorem cancel_counit_right {X Y : D} (f f' : X ⟶ e.Functor.obj (e.inverse.obj Y)) :
@@ -637,10 +598,7 @@ theorem cancel_counitInv_right {X Y : D} (f f' : X ⟶ Y) :
 #align category_theory.equivalence.cancel_counit_inv_right CategoryTheory.Equivalence.cancel_counitInv_right
 
 /- warning: category_theory.equivalence.cancel_unit_right_assoc -> CategoryTheory.Equivalence.cancel_unit_right_assoc is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) {W : C} {X : C} {X' : C} {Y : C} (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W X) (g : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (f' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W X') (g' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X' Y), Iff (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) f (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) g (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X' (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) f' (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X' Y (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) g' (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)))) (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W Y) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X Y f g) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X' Y f' g'))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) {W : C} {X : C} {X' : C} {Y : C} (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W X) (g : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (f' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W X') (g' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X' Y), Iff (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) f (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) g (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X' (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) f' (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X' Y (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) g' (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)))) (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W Y) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X Y f g) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X' Y f' g'))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_unit_right_assoc CategoryTheory.Equivalence.cancel_unit_right_assocₓ'. -/
 @[simp]
 theorem cancel_unit_right_assoc {W X X' Y : C} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X') (g' : X' ⟶ Y) :
@@ -649,10 +607,7 @@ theorem cancel_unit_right_assoc {W X X' Y : C} (f : W ⟶ X) (g : X ⟶ Y) (f' :
 #align category_theory.equivalence.cancel_unit_right_assoc CategoryTheory.Equivalence.cancel_unit_right_assoc
 
 /- warning: category_theory.equivalence.cancel_counit_inv_right_assoc -> CategoryTheory.Equivalence.cancel_counitInv_right_assoc is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) {W : D} {X : D} {X' : D} {Y : D} (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W X) (g : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) (f' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W X') (g' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X' Y), Iff (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) f (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X Y (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) g (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X' (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) f' (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X' Y (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Y) g' (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)))) (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W Y) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X Y f g) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X' Y f' g'))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) {W : D} {X : D} {X' : D} {Y : D} (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W X) (g : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) (f' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W X') (g' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X' Y), Iff (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) f (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X Y (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) g (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X' (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) f' (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X' Y (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Y) g' (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Y)))) (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W Y) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X Y f g) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X' Y f' g'))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_counit_inv_right_assoc CategoryTheory.Equivalence.cancel_counitInv_right_assocₓ'. -/
 @[simp]
 theorem cancel_counitInv_right_assoc {W X X' Y : D} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X')
@@ -661,10 +616,7 @@ theorem cancel_counitInv_right_assoc {W X X' Y : D} (f : W ⟶ X) (g : X ⟶ Y)
 #align category_theory.equivalence.cancel_counit_inv_right_assoc CategoryTheory.Equivalence.cancel_counitInv_right_assoc
 
 /- warning: category_theory.equivalence.cancel_unit_right_assoc' -> CategoryTheory.Equivalence.cancel_unit_right_assoc' is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) {W : C} {X : C} {X' : C} {Y : C} {Y' : C} {Z : C} (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W X) (g : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (h : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) Y Z) (f' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W X') (g' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X' Y') (h' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) Y' Z), Iff (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) f (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) g (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) Y Z (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) h (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Z)))) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X' (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) f' (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X' Y' (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) g' (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) Y' Z (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) h' (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Z))))) (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W Z) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X Z f (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y Z g h)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X' Z f' (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X' Y' Z g' h')))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) {W : C} {X : C} {X' : C} {Y : C} {Y' : C} {Z : C} (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W X) (g : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (h : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) Y Z) (f' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W X') (g' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X' Y') (h' : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) Y' Z), Iff (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) f (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) g (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) Y Z (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) h (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Z)))) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X' (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) f' (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X' Y' (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) g' (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) Y' Z (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) h' (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Z))))) (Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) W Z) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X Z f (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y Z g h)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) W X' Z f' (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X' Y' Z g' h')))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_unit_right_assoc' CategoryTheory.Equivalence.cancel_unit_right_assoc'ₓ'. -/
 @[simp]
 theorem cancel_unit_right_assoc' {W X X' Y Y' Z : C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z)
@@ -674,10 +626,7 @@ theorem cancel_unit_right_assoc' {W X X' Y Y' Z : C} (f : W ⟶ X) (g : X ⟶ Y)
 #align category_theory.equivalence.cancel_unit_right_assoc' CategoryTheory.Equivalence.cancel_unit_right_assoc'
 
 /- warning: category_theory.equivalence.cancel_counit_inv_right_assoc' -> CategoryTheory.Equivalence.cancel_counitInv_right_assoc' is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2) {W : D} {X : D} {X' : D} {Y : D} {Y' : D} {Z : D} (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W X) (g : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) (h : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) Y Z) (f' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W X') (g' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X' Y') (h' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) Y' Z), Iff (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) f (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X Y (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) g (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) Y Z (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) h (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Z)))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X' (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) f' (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X' Y' (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) g' (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) Y' Z (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) Z) h' (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Z))))) (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W Z) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X Z f (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X Y Z g h)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X' Z f' (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X' Y' Z g' h')))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (e : CategoryTheory.Equivalence.{u1, u2, u3, u4} C D _inst_1 _inst_2) {W : D} {X : D} {X' : D} {Y : D} {Y' : D} {Z : D} (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W X) (g : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y) (h : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) Y Z) (f' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W X') (g' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X' Y') (h' : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) Y' Z), Iff (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) f (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X Y (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) g (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) Y Z (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) h (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Z)))) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X' (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) f' (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X' Y' (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) g' (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) Y' Z (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e))) Z) h' (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 e) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 e)) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 e) Z))))) (Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) W Z) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X Z f (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X Y Z g h)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) W X' Z f' (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) X' Y' Z g' h')))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.equivalence.cancel_counit_inv_right_assoc' CategoryTheory.Equivalence.cancel_counitInv_right_assoc'ₓ'. -/
 @[simp]
 theorem cancel_counitInv_right_assoc' {W X X' Y Y' Z : D} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z)
@@ -948,10 +897,7 @@ end Equivalence
 namespace IsEquivalence
 
 /- warning: category_theory.is_equivalence.fun_inv_map -> CategoryTheory.IsEquivalence.fun_inv_map is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.IsEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] (X : D) (Y : D) (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) X)) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) Y))) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 F (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) X) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) Y) (CategoryTheory.Functor.map.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) X Y f)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) X)) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) Y)) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3))) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) X) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (CategoryTheory.Functor.obj.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) X) Y (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) Y)) f (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3))) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) Y)))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.IsEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] (X : D) (Y : D) (f : Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) X Y), Eq.{succ u2} (Quiver.Hom.{succ u2, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) X)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) Y))) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) X) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) Y) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) X Y f)) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)))) X) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) X) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)))) Y) (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3))) (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Equivalence.counit.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) X) (CategoryTheory.CategoryStruct.comp.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2) (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2)) X) Y (Prefunctor.obj.{succ u2, succ u2, u4, u4} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)))) Y) f (CategoryTheory.NatTrans.app.{u2, u2, u4, u4} D _inst_2 D _inst_2 (CategoryTheory.Functor.id.{u2, u4} D _inst_2) (CategoryTheory.Functor.comp.{u2, u1, u2, u4, u3, u4} D _inst_2 C _inst_1 D _inst_2 (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3))) (CategoryTheory.Equivalence.counitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) Y)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.is_equivalence.fun_inv_map CategoryTheory.IsEquivalence.fun_inv_mapₓ'. -/
 @[simp]
 theorem fun_inv_map (F : C ⥤ D) [IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
@@ -962,10 +908,7 @@ theorem fun_inv_map (F : C ⥤ D) [IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
 #align category_theory.is_equivalence.fun_inv_map CategoryTheory.IsEquivalence.fun_inv_map
 
 /- warning: category_theory.is_equivalence.inv_fun_map -> CategoryTheory.IsEquivalence.inv_fun_map is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.IsEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] (X : C) (Y : C) (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F X)) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F Y))) (CategoryTheory.Functor.map.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F Y) (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 F X Y f)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F X)) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F Y)) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3))) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) X) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (CategoryTheory.Functor.obj.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) X) Y (CategoryTheory.Functor.obj.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F Y)) f (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3))) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) Y)))
-but is expected to have type
-  forall {C : Type.{u3}} [_inst_1 : CategoryTheory.Category.{u1, u3} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u2, u4} D] (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.IsEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] (X : C) (Y : C) (f : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) X)) (Prefunctor.obj.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) Y))) (Prefunctor.map.{succ u2, succ u1, u4, u3} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u2, u1, u4, u3} D _inst_2 C _inst_1 (CategoryTheory.Functor.inv.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) X) (Prefunctor.obj.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) Y) (Prefunctor.map.{succ u1, succ u2, u3, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} D (CategoryTheory.Category.toCategoryStruct.{u2, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u3, u4} C _inst_1 D _inst_2 F) X Y f)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)))) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)))) Y) (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3))) (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Equivalence.unitInv.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) X) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1)) X) Y (Prefunctor.obj.{succ u1, succ u1, u3, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)))) Y) f (CategoryTheory.NatTrans.app.{u1, u1, u3, u3} C _inst_1 C _inst_1 (CategoryTheory.Functor.id.{u1, u3} C _inst_1) (CategoryTheory.Functor.comp.{u1, u2, u1, u3, u4, u3} C _inst_1 D _inst_2 C _inst_1 (CategoryTheory.Equivalence.functor.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) (CategoryTheory.Equivalence.inverse.{u1, u2, u3, u4} C D _inst_1 _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3))) (CategoryTheory.Equivalence.unit.{u1, u2, u3, u4} C _inst_1 D _inst_2 (CategoryTheory.Functor.asEquivalence.{u1, u2, u3, u4} C _inst_1 D _inst_2 F _inst_3)) Y)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.is_equivalence.inv_fun_map CategoryTheory.IsEquivalence.inv_fun_mapₓ'. -/
 @[simp]
 theorem inv_fun_map (F : C ⥤ D) [IsEquivalence F] (X Y : C) (f : X ⟶ Y) :
@@ -1105,7 +1048,6 @@ private noncomputable def equivalence_inverse (F : C ⥤ D) [Full F] [Faithful F
   map X Y f := F.preimage ((F.objObjPreimageIso X).Hom ≫ f ≫ (F.objObjPreimageIso Y).inv)
   map_id' X := by apply F.map_injective; tidy
   map_comp' X Y Z f g := by apply F.map_injective <;> simp
-#align category_theory.equivalence.equivalence_inverse category_theory.equivalence.equivalence_inverse
 
 #print CategoryTheory.Equivalence.ofFullyFaithfullyEssSurj /-
 /-- A functor which is full, faithful, and essentially surjective is an equivalence.

mathlib commit https://github.com/leanprover-community/mathlib/commit/75e7fca56381d056096ce5d05e938f63a6567828

@@ -776,7 +776,7 @@ class IsEquivalence (F : C ⥤ D) where mk' ::
 
 restate_axiom is_equivalence.functor_unit_iso_comp'
 
-attribute [simp, reassoc.1] is_equivalence.functor_unit_iso_comp
+attribute [simp, reassoc] is_equivalence.functor_unit_iso_comp
 
 namespace IsEquivalence
 

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

@@ -372,11 +372,11 @@ required for a half-adjoint equivalence. See `equivalence.mk`. -/
 def adjointifyη : 𝟭 C ≅ F ⋙ G :=
   calc
     𝟭 C ≅ F ⋙ G := η
-    _ ≅ F ⋙ 𝟭 D ⋙ G := isoWhiskerLeft F (leftUnitor G).symm
-    _ ≅ F ⋙ (G ⋙ F) ⋙ G := isoWhiskerLeft F (isoWhiskerRight ε.symm G)
-    _ ≅ F ⋙ G ⋙ F ⋙ G := isoWhiskerLeft F (associator G F G)
+    _ ≅ F ⋙ 𝟭 D ⋙ G := (isoWhiskerLeft F (leftUnitor G).symm)
+    _ ≅ F ⋙ (G ⋙ F) ⋙ G := (isoWhiskerLeft F (isoWhiskerRight ε.symm G))
+    _ ≅ F ⋙ G ⋙ F ⋙ G := (isoWhiskerLeft F (associator G F G))
     _ ≅ (F ⋙ G) ⋙ F ⋙ G := (associator F G (F ⋙ G)).symm
-    _ ≅ 𝟭 C ⋙ F ⋙ G := isoWhiskerRight η.symm (F ⋙ G)
+    _ ≅ 𝟭 C ⋙ F ⋙ G := (isoWhiskerRight η.symm (F ⋙ G))
     _ ≅ F ⋙ G := leftUnitor (F ⋙ G)
     
 #align category_theory.equivalence.adjointify_η CategoryTheory.Equivalence.adjointifyη

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

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

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

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

@@ -719,14 +719,13 @@ instance (priority := 100) faithfulOfEquivalence (F : C ⥤ D) [IsEquivalence F]
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-instance (priority := 100) fullOfEquivalence (F : C ⥤ D) [IsEquivalence F] : F.Full
-    where
-  preimage {X Y} f := F.asEquivalence.unit.app X ≫ F.inv.map f ≫ F.asEquivalence.unitInv.app Y
-  witness {X Y} f :=
-    F.inv.map_injective <| by
-      simpa only [IsEquivalence.inv_fun_map, assoc, Iso.inv_hom_id_app_assoc,
-        Iso.inv_hom_id_app] using comp_id _
-#align category_theory.equivalence.full_of_equivalence CategoryTheory.Equivalence.fullOfEquivalence
+instance (priority := 100) full_of_equivalence (F : C ⥤ D) [IsEquivalence F] : F.Full where
+  map_surjective {X Y} f :=
+    ⟨F.asEquivalence.unit.app X ≫ F.inv.map f ≫ F.asEquivalence.unitInv.app Y,
+      F.inv.map_injective <| by
+        simpa only [IsEquivalence.inv_fun_map, assoc, Iso.inv_hom_id_app_assoc,
+          Iso.inv_hom_id_app] using comp_id _⟩
+#align category_theory.equivalence.full_of_equivalence CategoryTheory.Equivalence.full_of_equivalence
 
 @[simps]
 private noncomputable def equivalenceInverse (F : C ⥤ D) [F.Full] [F.Faithful] [F.EssSurj] : D ⥤ C

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

@@ -39,16 +39,16 @@ if it is full, faithful and essentially surjective.
 * `Equivalence`: bundled (half-)adjoint equivalences of categories
 * `IsEquivalence`: type class on a functor `F` containing the data of the inverse `G` as well as
   the natural isomorphisms `η` and `ε`.
-* `EssSurj`: type class on a functor `F` containing the data of the preimages and the isomorphisms
-  `F.obj (preimage d) ≅ d`.
+* `Functor.EssSurj`: type class on a functor `F` containing the data of the preimages
+  and the isomorphisms `F.obj (preimage d) ≅ d`.
 
 ## Main results
 
 * `Equivalence.mk`: upgrade an equivalence to a (half-)adjoint equivalence
-* `IsEquivalence.equivOfIso`: when `F` and `G` are isomorphic functors, `F` is an equivalence
-iff `G` is.
-* `Equivalence.ofFullyFaithfullyEssSurj`: a fully faithful essentially surjective functor is an
-  equivalence.
+* `Functor.IsEquivalence.equivOfIso`: when `F` and `G` are isomorphic functors,
+`F` is an equivalence iff `G` is.
+* `Functor.IsEquivalence.ofFullyFaithfullyEssSurj`: a fully faithful essentially surjective
+functor is an equivalence.
 
 ## Notations
 
@@ -470,6 +470,8 @@ end
 
 end Equivalence
 
+namespace Functor
+
 /-- A functor that is part of a (half) adjoint equivalence -/
 class IsEquivalence (F : C ⥤ D) where mk' ::
   /-- The inverse functor to `F` -/
@@ -484,10 +486,10 @@ class IsEquivalence (F : C ⥤ D) where mk' ::
       F.map ((unitIso.hom : 𝟭 C ⟶ F ⋙ inverse).app X) ≫ counitIso.hom.app (F.obj X) =
         𝟙 (F.obj X) := by
     aesop_cat
-#align category_theory.is_equivalence CategoryTheory.IsEquivalence
-#align category_theory.is_equivalence.unit_iso CategoryTheory.IsEquivalence.unitIso
-#align category_theory.is_equivalence.counit_iso CategoryTheory.IsEquivalence.counitIso
-#align category_theory.is_equivalence.functor_unit_iso_comp CategoryTheory.IsEquivalence.functor_unitIso_comp
+#align category_theory.is_equivalence CategoryTheory.Functor.IsEquivalence
+#align category_theory.is_equivalence.unit_iso CategoryTheory.Functor.IsEquivalence.unitIso
+#align category_theory.is_equivalence.counit_iso CategoryTheory.Functor.IsEquivalence.counitIso
+#align category_theory.is_equivalence.functor_unit_iso_comp CategoryTheory.Functor.IsEquivalence.functor_unitIso_comp
 
 attribute [reassoc (attr := simp)] IsEquivalence.functor_unitIso_comp
 
@@ -495,11 +497,11 @@ namespace IsEquivalence
 
 instance ofEquivalence (F : C ≌ D) : IsEquivalence F.functor :=
   { F with }
-#align category_theory.is_equivalence.of_equivalence CategoryTheory.IsEquivalence.ofEquivalence
+#align category_theory.is_equivalence.of_equivalence CategoryTheory.Functor.IsEquivalence.ofEquivalence
 
 instance ofEquivalenceInverse (F : C ≌ D) : IsEquivalence F.inverse :=
   IsEquivalence.ofEquivalence F.symm
-#align category_theory.is_equivalence.of_equivalence_inverse CategoryTheory.IsEquivalence.ofEquivalenceInverse
+#align category_theory.is_equivalence.of_equivalence_inverse CategoryTheory.Functor.IsEquivalence.ofEquivalenceInverse
 
 open Equivalence
 
@@ -507,12 +509,10 @@ open Equivalence
     `F ⋙ G` and `G ⋙ F` are naturally isomorphic to identity functors. -/
 protected def mk {F : C ⥤ D} (G : D ⥤ C) (η : 𝟭 C ≅ F ⋙ G) (ε : G ⋙ F ≅ 𝟭 D) : IsEquivalence F :=
   ⟨G, adjointifyη η ε, ε, adjointify_η_ε η ε⟩
-#align category_theory.is_equivalence.mk CategoryTheory.IsEquivalence.mk
+#align category_theory.is_equivalence.mk CategoryTheory.Functor.IsEquivalence.mk
 
 end IsEquivalence
 
-namespace Functor
-
 /-- Interpret a functor that is an equivalence as an equivalence. -/
 def asEquivalence (F : C ⥤ D) [IsEquivalence F] : C ≌ D :=
   ⟨F, IsEquivalence.inverse F, IsEquivalence.unitIso, IsEquivalence.counitIso,
@@ -608,21 +608,21 @@ theorem inverse_asEquivalence (E : C ≌ D) : E.inverse.asEquivalence = E.symm :
 
 end Equivalence
 
-namespace IsEquivalence
+namespace Functor.IsEquivalence
 
 @[simp]
 theorem fun_inv_map (F : C ⥤ D) [IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
     F.map (F.inv.map f) = F.asEquivalence.counit.app X ≫ f ≫ F.asEquivalence.counitInv.app Y := by
   erw [NatIso.naturality_2]
   rfl
-#align category_theory.is_equivalence.fun_inv_map CategoryTheory.IsEquivalence.fun_inv_map
+#align category_theory.is_equivalence.fun_inv_map CategoryTheory.Functor.IsEquivalence.fun_inv_map
 
 @[simp]
 theorem inv_fun_map (F : C ⥤ D) [IsEquivalence F] (X Y : C) (f : X ⟶ Y) :
     F.inv.map (F.map f) = F.asEquivalence.unitInv.app X ≫ f ≫ F.asEquivalence.unit.app Y := by
   erw [NatIso.naturality_1]
   rfl
-#align category_theory.is_equivalence.inv_fun_map CategoryTheory.IsEquivalence.inv_fun_map
+#align category_theory.is_equivalence.inv_fun_map CategoryTheory.Functor.IsEquivalence.inv_fun_map
 
 /-- When a functor `F` is an equivalence of categories, and `G` is isomorphic to `F`, then
 `G` is also an equivalence of categories. -/
@@ -642,7 +642,7 @@ def ofIso {F G : C ⥤ D} (e : F ≅ G) (hF : IsEquivalence F) : IsEquivalence G
     erw [hF.counitIso.hom.naturality]
     slice_lhs 1 2 => rw [functor_unitIso_comp]
     simp only [Functor.id_map, id_comp]
-#align category_theory.is_equivalence.of_iso CategoryTheory.IsEquivalence.ofIso
+#align category_theory.is_equivalence.of_iso CategoryTheory.Functor.IsEquivalence.ofIso
 
 /-- Compatibility of `ofIso` with the composition of isomorphisms of functors -/
 theorem ofIso_trans {F G H : C ⥤ D} (e : F ≅ G) (e' : G ≅ H) (hF : IsEquivalence F) :
@@ -651,7 +651,7 @@ theorem ofIso_trans {F G H : C ⥤ D} (e : F ≅ G) (e' : G ≅ H) (hF : IsEquiv
   congr 1 <;> ext X <;> dsimp [NatIso.hcomp]
   · simp only [id_comp, assoc, Functor.map_comp]
   · simp only [Functor.map_id, comp_id, id_comp, assoc]
-#align category_theory.is_equivalence.of_iso_trans CategoryTheory.IsEquivalence.ofIso_trans
+#align category_theory.is_equivalence.of_iso_trans CategoryTheory.Functor.IsEquivalence.ofIso_trans
 
 /-- Compatibility of `ofIso` with identity isomorphisms of functors -/
 theorem ofIso_refl (F : C ⥤ D) (hF : IsEquivalence F) : ofIso (Iso.refl F) hF = hF := by
@@ -660,7 +660,7 @@ theorem ofIso_refl (F : C ⥤ D) (hF : IsEquivalence F) : ofIso (Iso.refl F) hF
   congr 1 <;> ext X <;> dsimp [NatIso.hcomp]
   · simp only [comp_id, map_id]
   · simp only [id_comp, map_id]
-#align category_theory.is_equivalence.of_iso_refl CategoryTheory.IsEquivalence.ofIso_refl
+#align category_theory.is_equivalence.of_iso_refl CategoryTheory.Functor.IsEquivalence.ofIso_refl
 
 /-- When `F` and `G` are two isomorphic functors, then `F` is an equivalence iff `G` is. -/
 @[simps]
@@ -670,7 +670,7 @@ def equivOfIso {F G : C ⥤ D} (e : F ≅ G) : IsEquivalence F ≃ IsEquivalence
   invFun := ofIso e.symm
   left_inv hF := by rw [ofIso_trans, Iso.self_symm_id, ofIso_refl]
   right_inv hF := by rw [ofIso_trans, Iso.symm_self_id, ofIso_refl]
-#align category_theory.is_equivalence.equiv_of_iso CategoryTheory.IsEquivalence.equivOfIso
+#align category_theory.is_equivalence.equiv_of_iso CategoryTheory.Functor.IsEquivalence.equivOfIso
 
 /-- If `G` and `F ⋙ G` are equivalence of categories, then `F` is also an equivalence. -/
 @[simp]
@@ -678,7 +678,7 @@ def cancelCompRight {E : Type*} [Category E] (F : C ⥤ D) (G : D ⥤ E) (hG : I
     (_ : IsEquivalence (F ⋙ G)) : IsEquivalence F :=
   ofIso (Functor.associator F G G.inv ≪≫ NatIso.hcomp (Iso.refl F) hG.unitIso.symm ≪≫ rightUnitor F)
     (Functor.isEquivalenceTrans (F ⋙ G) G.inv)
-#align category_theory.is_equivalence.cancel_comp_right CategoryTheory.IsEquivalence.cancelCompRight
+#align category_theory.is_equivalence.cancel_comp_right CategoryTheory.Functor.IsEquivalence.cancelCompRight
 
 /-- If `F` and `F ⋙ G` are equivalence of categories, then `G` is also an equivalence. -/
 @[simp]
@@ -687,17 +687,19 @@ def cancelCompLeft {E : Type*} [Category E] (F : C ⥤ D) (G : D ⥤ E) (hF : Is
   ofIso
     ((Functor.associator F.inv F G).symm ≪≫ NatIso.hcomp hF.counitIso (Iso.refl G) ≪≫ leftUnitor G)
     (Functor.isEquivalenceTrans F.inv (F ⋙ G))
-#align category_theory.is_equivalence.cancel_comp_left CategoryTheory.IsEquivalence.cancelCompLeft
+#align category_theory.is_equivalence.cancel_comp_left CategoryTheory.Functor.IsEquivalence.cancelCompLeft
 
 end IsEquivalence
 
+end Functor
+
 namespace Equivalence
 
 /-- An equivalence is essentially surjective.
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-theorem essSurj_of_equivalence (F : C ⥤ D) [IsEquivalence F] : EssSurj F :=
+theorem essSurj_of_equivalence (F : C ⥤ D) [IsEquivalence F] : F.EssSurj :=
   ⟨fun Y => ⟨F.inv.obj Y, ⟨F.asEquivalence.counitIso.app Y⟩⟩⟩
 #align category_theory.equivalence.ess_surj_of_equivalence CategoryTheory.Equivalence.essSurj_of_equivalence
 
@@ -706,7 +708,7 @@ theorem essSurj_of_equivalence (F : C ⥤ D) [IsEquivalence F] : EssSurj F :=
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-instance (priority := 100) faithfulOfEquivalence (F : C ⥤ D) [IsEquivalence F] : Faithful F where
+instance (priority := 100) faithfulOfEquivalence (F : C ⥤ D) [IsEquivalence F] : F.Faithful where
   map_injective := @fun X Y f g h => by
     have p : F.inv.map (F.map f) = F.inv.map (F.map g) := congrArg F.inv.map h
     simpa only [cancel_epi, cancel_mono, IsEquivalence.inv_fun_map] using p
@@ -717,7 +719,7 @@ instance (priority := 100) faithfulOfEquivalence (F : C ⥤ D) [IsEquivalence F]
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-instance (priority := 100) fullOfEquivalence (F : C ⥤ D) [IsEquivalence F] : Full F
+instance (priority := 100) fullOfEquivalence (F : C ⥤ D) [IsEquivalence F] : F.Full
     where
   preimage {X Y} f := F.asEquivalence.unit.app X ≫ F.inv.map f ≫ F.asEquivalence.unitInv.app Y
   witness {X Y} f :=
@@ -727,7 +729,7 @@ instance (priority := 100) fullOfEquivalence (F : C ⥤ D) [IsEquivalence F] : F
 #align category_theory.equivalence.full_of_equivalence CategoryTheory.Equivalence.fullOfEquivalence
 
 @[simps]
-private noncomputable def equivalenceInverse (F : C ⥤ D) [Full F] [Faithful F] [EssSurj F] : D ⥤ C
+private noncomputable def equivalenceInverse (F : C ⥤ D) [F.Full] [F.Faithful] [F.EssSurj] : D ⥤ C
     where
   obj X := F.objPreimage X
   map {X Y} f := F.preimage ((F.objObjPreimageIso X).hom ≫ f ≫ (F.objObjPreimageIso Y).inv)
@@ -741,7 +743,8 @@ private noncomputable def equivalenceInverse (F : C ⥤ D) [Full F] [Faithful F]
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-noncomputable def ofFullyFaithfullyEssSurj (F : C ⥤ D) [Full F] [Faithful F] [EssSurj F] :
+noncomputable def _root_.CategoryTheory.Functor.IsEquivalence.ofFullyFaithfullyEssSurj
+  (F : C ⥤ D) [F.Full] [F.Faithful] [F.EssSurj] :
     IsEquivalence F :=
   IsEquivalence.mk (equivalenceInverse F)
     (NatIso.ofComponents (fun X => (F.preimageIso <| F.objObjPreimageIso <| F.obj X).symm)
@@ -749,7 +752,10 @@ noncomputable def ofFullyFaithfullyEssSurj (F : C ⥤ D) [Full F] [Faithful F] [
         apply F.map_injective
         aesop_cat)
     (NatIso.ofComponents F.objObjPreimageIso)
-#align category_theory.equivalence.of_fully_faithfully_ess_surj CategoryTheory.Equivalence.ofFullyFaithfullyEssSurj
+#align category_theory.equivalence.of_fully_faithfully_ess_surj CategoryTheory.Functor.IsEquivalence.ofFullyFaithfullyEssSurj
+
+-- deprecated on 2024-04-06
+@[deprecated] alias ofFullyFaithfullyEssSurj := Functor.IsEquivalence.ofFullyFaithfullyEssSurj
 
 @[simp]
 theorem functor_map_inj_iff (e : C ≌ D) {X Y : C} (f g : X ⟶ Y) :
@@ -763,18 +769,18 @@ theorem inverse_map_inj_iff (e : C ≌ D) {X Y : D} (f g : X ⟶ Y) :
   functor_map_inj_iff e.symm f g
 #align category_theory.equivalence.inverse_map_inj_iff CategoryTheory.Equivalence.inverse_map_inj_iff
 
-instance essSurjInducedFunctor {C' : Type*} (e : C' ≃ D) : EssSurj (inducedFunctor e) where
+instance essSurjInducedFunctor {C' : Type*} (e : C' ≃ D) : (inducedFunctor e).EssSurj where
   mem_essImage Y := ⟨e.symm Y, by simpa using ⟨default⟩⟩
 #align category_theory.equivalence.ess_surj_induced_functor CategoryTheory.Equivalence.essSurjInducedFunctor
 
 noncomputable instance inducedFunctorOfEquiv {C' : Type*} (e : C' ≃ D) :
     IsEquivalence (inducedFunctor e) :=
-  Equivalence.ofFullyFaithfullyEssSurj _
+  Functor.IsEquivalence.ofFullyFaithfullyEssSurj _
 #align category_theory.equivalence.induced_functor_of_equiv CategoryTheory.Equivalence.inducedFunctorOfEquiv
 
-noncomputable instance fullyFaithfulToEssImage (F : C ⥤ D) [Full F] [Faithful F] :
+noncomputable instance fullyFaithfulToEssImage (F : C ⥤ D) [F.Full] [F.Faithful] :
     IsEquivalence F.toEssImage :=
-  ofFullyFaithfullyEssSurj F.toEssImage
+  Functor.IsEquivalence.ofFullyFaithfullyEssSurj F.toEssImage
 #align category_theory.equivalence.fully_faithful_to_ess_image CategoryTheory.Equivalence.fullyFaithfulToEssImage
 
 end Equivalence
@@ -837,4 +843,15 @@ end Iso
 @[deprecated] alias invCompIso := Iso.invCompIso
 @[deprecated] alias isoInvComp := Iso.isoInvComp
 
+-- deprecated on 2024-04-06
+@[deprecated] alias IsEquivalence := Functor.IsEquivalence
+@[deprecated] alias IsEquivalence.fun_inv_map := Functor.IsEquivalence.fun_inv_map
+@[deprecated] alias IsEquivalence.inv_fun_map := Functor.IsEquivalence.inv_fun_map
+@[deprecated] alias IsEquivalence.ofIso := Functor.IsEquivalence.ofIso
+@[deprecated] alias IsEquivalence.ofIso_trans := Functor.IsEquivalence.ofIso_trans
+@[deprecated] alias IsEquivalence.ofIso_refl := Functor.IsEquivalence.ofIso_refl
+@[deprecated] alias IsEquivalence.equivOfIso := Functor.IsEquivalence.equivOfIso
+@[deprecated] alias IsEquivalence.cancelCompRight := Functor.IsEquivalence.cancelCompRight
+@[deprecated] alias IsEquivalence.cancelCompLeft := Functor.IsEquivalence.cancelCompLeft
+
 end CategoryTheory

Release 4.7.0-rc1 makes it unnecessary to add pp_dot to structure fields. It used to be that function fields wouldn't pretty print using dot notation when the function was applied unless pp_dot was added.

@@ -101,8 +101,6 @@ variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
 
 namespace Equivalence
 
-attribute [pp_dot] functor inverse unitIso counitIso
-
 /-- The unit of an equivalence of categories. -/
 @[pp_dot] abbrev unit (e : C ≌ D) : 𝟭 C ⟶ e.functor ⋙ e.inverse :=
   e.unitIso.hom

@@ -149,13 +149,13 @@ theorem Equivalence_mk'_counitInv (functor inverse unit_iso counit_iso f) :
   rfl
 #align category_theory.equivalence.equivalence_mk'_counit_inv CategoryTheory.Equivalence.Equivalence_mk'_counitInv
 
-@[simp]
+@[reassoc (attr := simp)]
 theorem functor_unit_comp (e : C ≌ D) (X : C) :
     e.functor.map (e.unit.app X) ≫ e.counit.app (e.functor.obj X) = 𝟙 (e.functor.obj X) :=
   e.functor_unitIso_comp X
 #align category_theory.equivalence.functor_unit_comp CategoryTheory.Equivalence.functor_unit_comp
 
-@[simp]
+@[reassoc (attr := simp)]
 theorem counitInv_functor_comp (e : C ≌ D) (X : C) :
     e.counitInv.app (e.functor.obj X) ≫ e.functor.map (e.unitInv.app X) = 𝟙 (e.functor.obj X) := by
   erw [Iso.inv_eq_inv (e.functor.mapIso (e.unitIso.app X) ≪≫ e.counitIso.app (e.functor.obj X))
@@ -178,7 +178,7 @@ theorem counit_app_functor (e : C ≌ D) (X : C) :
 
 /-- The other triangle equality. The proof follows the following proof in Globular:
   http://globular.science/1905.001 -/
-@[simp]
+@[reassoc (attr := simp)]
 theorem unit_inverse_comp (e : C ≌ D) (Y : D) :
     e.unit.app (e.inverse.obj Y) ≫ e.inverse.map (e.counit.app Y) = 𝟙 (e.inverse.obj Y) := by
   rw [← id_comp (e.inverse.map _), ← map_id e.inverse, ← counitInv_functor_comp, map_comp]
@@ -203,7 +203,7 @@ theorem unit_inverse_comp (e : C ≌ D) (Y : D) :
   erw [id_comp, (e.unitIso.app _).hom_inv_id]; rfl
 #align category_theory.equivalence.unit_inverse_comp CategoryTheory.Equivalence.unit_inverse_comp
 
-@[simp]
+@[reassoc (attr := simp)]
 theorem inverse_counitInv_comp (e : C ≌ D) (Y : D) :
     e.inverse.map (e.counitInv.app Y) ≫ e.unitInv.app (e.inverse.obj Y) = 𝟙 (e.inverse.obj Y) := by
   erw [Iso.inv_eq_inv (e.unitIso.app (e.inverse.obj Y) ≪≫ e.inverse.mapIso (e.counitIso.app Y))
@@ -224,13 +224,13 @@ theorem unitInv_app_inverse (e : C ≌ D) (Y : D) :
   rfl
 #align category_theory.equivalence.unit_inv_app_inverse CategoryTheory.Equivalence.unitInv_app_inverse
 
-@[simp]
+@[reassoc, simp]
 theorem fun_inv_map (e : C ≌ D) (X Y : D) (f : X ⟶ Y) :
     e.functor.map (e.inverse.map f) = e.counit.app X ≫ f ≫ e.counitInv.app Y :=
   (NatIso.naturality_2 e.counitIso f).symm
 #align category_theory.equivalence.fun_inv_map CategoryTheory.Equivalence.fun_inv_map
 
-@[simp]
+@[reassoc, simp]
 theorem inv_fun_map (e : C ≌ D) (X Y : C) (f : X ⟶ Y) :
     e.inverse.map (e.functor.map f) = e.unitInv.app X ≫ f ≫ e.unit.app Y :=
   (NatIso.naturality_1 e.unitIso f).symm
@@ -255,6 +255,7 @@ def adjointifyη : 𝟭 C ≅ F ⋙ G := by
     _ ≅ F ⋙ G := leftUnitor (F ⋙ G)
 #align category_theory.equivalence.adjointify_η CategoryTheory.Equivalence.adjointifyη
 
+@[reassoc]
 theorem adjointify_η_ε (X : C) :
     F.map ((adjointifyη η ε).hom.app X) ≫ ε.hom.app (F.obj X) = 𝟙 (F.obj X) := by
   dsimp [adjointifyη,Trans.trans]

This PR introduces the typeclass HasRightKanExtension L F which asserts the existence of a right Kan extension of a functor F along L. A chosen extension is obtained as rightKanExtension L F.

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

@@ -567,6 +567,12 @@ instance isEquivalenceTrans (F : C ⥤ D) (G : D ⥤ E) [IsEquivalence F] [IsEqu
   IsEquivalence.ofEquivalence (Equivalence.trans (asEquivalence F) (asEquivalence G))
 #align category_theory.functor.is_equivalence_trans CategoryTheory.Functor.isEquivalenceTrans
 
+instance (F : C ⥤ D) [IsEquivalence F] : IsEquivalence ((whiskeringLeft C D E).obj F) :=
+  (inferInstance : IsEquivalence (Equivalence.congrLeft F.asEquivalence).inverse)
+
+instance (F : C ⥤ D) [IsEquivalence F] : IsEquivalence ((whiskeringRight E C D).obj F) :=
+  (inferInstance : IsEquivalence (Equivalence.congrRight F.asEquivalence).functor)
+
 end Functor
 
 namespace Equivalence

• Move all results from CategoryTheory/Functor/InvIsos.lean to CategoryTheory/Equivalence.lean and delete the former file
• Replace use of eqToIso (Functor.comp_id G) with G.rightUnitor
• Move into Iso namespace to enable dot notation
• Add analogous results stated in terms of Equivalence instead of IsEquivalence

@@ -581,6 +581,14 @@ theorem inverse_inv (E : C ≌ D) : E.inverse.inv = E.functor :=
   rfl
 #align category_theory.equivalence.inverse_inv CategoryTheory.Equivalence.inverse_inv
 
+@[simp]
+theorem isEquivalence_unitIso (E : C ≌ D) : IsEquivalence.unitIso = E.unitIso :=
+  rfl
+
+@[simp]
+theorem isEquivalence_counitIso (E : C ≌ D) : IsEquivalence.counitIso = E.counitIso :=
+  rfl
+
 @[simp]
 theorem functor_asEquivalence (E : C ≌ D) : E.functor.asEquivalence = E := by
   cases E
@@ -766,4 +774,62 @@ noncomputable instance fullyFaithfulToEssImage (F : C ⥤ D) [Full F] [Faithful
 
 end Equivalence
 
+namespace Iso
+
+variable {E : Type u₃} [Category.{v₃} E] {F : C ⥤ E} {G : C ⥤ D} {H : D ⥤ E}
+
+/-- Construct an isomorphism `F ⋙ H.inv ≅ G` from an isomorphism `F ≅ G ⋙ H`. -/
+@[simps!]
+def compInvIso [h : IsEquivalence H] (i : F ≅ G ⋙ H) : F ⋙ H.inv ≅ G :=
+  isoWhiskerRight i H.inv ≪≫
+    associator G H H.inv ≪≫ isoWhiskerLeft G h.unitIso.symm ≪≫ G.rightUnitor
+#align category_theory.comp_inv_iso CategoryTheory.Iso.compInvIso
+
+/-- Construct an isomorphism `F ⋙ H.inverse ≅ G` from an isomorphism `F ≅ G ⋙ H.functor`. -/
+@[simps!]
+def compInverseIso {H : D ≌ E} (i : F ≅ G ⋙ H.functor) : F ⋙ H.inverse ≅ G :=
+  i.compInvIso
+
+/-- Construct an isomorphism `G ≅ F ⋙ H.inv` from an isomorphism `G ⋙ H ≅ F`. -/
+@[simps!]
+def isoCompInv [IsEquivalence H] (i : G ⋙ H ≅ F) : G ≅ F ⋙ H.inv :=
+  (compInvIso i.symm).symm
+#align category_theory.iso_comp_inv CategoryTheory.Iso.isoCompInv
+
+/-- Construct an isomorphism `G ≅ F ⋙ H.inverse` from an isomorphism `G ⋙ H.functor ≅ F`. -/
+@[simps!]
+def isoCompInverse {H : D ≌ E} (i : G ⋙ H.functor ≅ F) : G ≅ F ⋙ H.inverse :=
+  i.isoCompInv
+
+/-- Construct an isomorphism `G.inv ⋙ F ≅ H` from an isomorphism `F ≅ G ⋙ H`. -/
+@[simps!]
+def invCompIso [h : IsEquivalence G] (i : F ≅ G ⋙ H) : G.inv ⋙ F ≅ H :=
+  isoWhiskerLeft G.inv i ≪≫
+    (associator G.inv G H).symm ≪≫ isoWhiskerRight h.counitIso H ≪≫ H.leftUnitor
+#align category_theory.inv_comp_iso CategoryTheory.Iso.invCompIso
+
+/-- Construct an isomorphism `G.inverse ⋙ F ≅ H` from an isomorphism `F ≅ G.functor ⋙ H`. -/
+@[simps!]
+def inverseCompIso {G : C ≌ D} (i : F ≅ G.functor ⋙ H) : G.inverse ⋙ F ≅ H :=
+  i.invCompIso
+
+/-- Construct an isomorphism `H ≅ G.inv ⋙ F` from an isomorphism `G ⋙ H ≅ F`. -/
+@[simps!]
+def isoInvComp [IsEquivalence G] (i : G ⋙ H ≅ F) : H ≅ G.inv ⋙ F :=
+  (invCompIso i.symm).symm
+#align category_theory.iso_inv_comp CategoryTheory.Iso.isoInvComp
+
+/-- Construct an isomorphism `H ≅ G.inverse ⋙ F` from an isomorphism `G.functor ⋙ H ≅ F`. -/
+@[simps!]
+def isoInverseComp {G : C ≌ D} (i : G.functor ⋙ H ≅ F) : H ≅ G.inverse ⋙ F :=
+  i.isoInvComp
+
+end Iso
+
+-- deprecated on 2024-02-07
+@[deprecated] alias compInvIso := Iso.compInvIso
+@[deprecated] alias isoCompInv := Iso.isoCompInv
+@[deprecated] alias invCompIso := Iso.invCompIso
+@[deprecated] alias isoInvComp := Iso.isoInvComp
+
 end CategoryTheory

Fixes the nonterminal simps identified by #7496

@@ -258,7 +258,7 @@ def adjointifyη : 𝟭 C ≅ F ⋙ G := by
 theorem adjointify_η_ε (X : C) :
     F.map ((adjointifyη η ε).hom.app X) ≫ ε.hom.app (F.obj X) = 𝟙 (F.obj X) := by
   dsimp [adjointifyη,Trans.trans]
-  simp
+  simp only [comp_id, assoc, map_comp]
   have := ε.hom.naturality (F.map (η.inv.app X)); dsimp at this; rw [this]; clear this
   rw [← assoc _ _ (F.map _)]
   have := ε.hom.naturality (ε.inv.app <| F.obj X); dsimp at this; rw [this]; clear this

The goal view gets pretty unreadable when working with Equivalences without these.

@@ -101,23 +101,25 @@ variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
 
 namespace Equivalence
 
+attribute [pp_dot] functor inverse unitIso counitIso
+
 /-- The unit of an equivalence of categories. -/
-abbrev unit (e : C ≌ D) : 𝟭 C ⟶ e.functor ⋙ e.inverse :=
+@[pp_dot] abbrev unit (e : C ≌ D) : 𝟭 C ⟶ e.functor ⋙ e.inverse :=
   e.unitIso.hom
 #align category_theory.equivalence.unit CategoryTheory.Equivalence.unit
 
 /-- The counit of an equivalence of categories. -/
-abbrev counit (e : C ≌ D) : e.inverse ⋙ e.functor ⟶ 𝟭 D :=
+@[pp_dot] abbrev counit (e : C ≌ D) : e.inverse ⋙ e.functor ⟶ 𝟭 D :=
   e.counitIso.hom
 #align category_theory.equivalence.counit CategoryTheory.Equivalence.counit
 
 /-- The inverse of the unit of an equivalence of categories. -/
-abbrev unitInv (e : C ≌ D) : e.functor ⋙ e.inverse ⟶ 𝟭 C :=
+@[pp_dot] abbrev unitInv (e : C ≌ D) : e.functor ⋙ e.inverse ⟶ 𝟭 C :=
   e.unitIso.inv
 #align category_theory.equivalence.unit_inv CategoryTheory.Equivalence.unitInv
 
 /-- The inverse of the counit of an equivalence of categories. -/
-abbrev counitInv (e : C ≌ D) : 𝟭 D ⟶ e.inverse ⋙ e.functor :=
+@[pp_dot] abbrev counitInv (e : C ≌ D) : 𝟭 D ⟶ e.inverse ⋙ e.functor :=
   e.counitIso.inv
 #align category_theory.equivalence.counit_inv CategoryTheory.Equivalence.counitInv
 
@@ -283,7 +285,7 @@ instance : Inhabited (C ≌ C) :=
   ⟨refl⟩
 
 /-- Equivalence of categories is symmetric. -/
-@[symm, simps]
+@[symm, simps, pp_dot]
 def symm (e : C ≌ D) : D ≌ C :=
   ⟨e.inverse, e.functor, e.counitIso.symm, e.unitIso.symm, e.inverse_counitInv_comp⟩
 #align category_theory.equivalence.symm CategoryTheory.Equivalence.symm
@@ -291,7 +293,7 @@ def symm (e : C ≌ D) : D ≌ C :=
 variable {E : Type u₃} [Category.{v₃} E]
 
 /-- Equivalence of categories is transitive. -/
-@[trans, simps]
+@[trans, simps, pp_dot]
 def trans (e : C ≌ D) (f : D ≌ E) : C ≌ E
     where
   functor := e.functor ⋙ f.functor

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

This has nice performance benefits.

@@ -659,7 +659,7 @@ def equivOfIso {F G : C ⥤ D} (e : F ≅ G) : IsEquivalence F ≃ IsEquivalence
 
 /-- If `G` and `F ⋙ G` are equivalence of categories, then `F` is also an equivalence. -/
 @[simp]
-def cancelCompRight {E : Type _} [Category E] (F : C ⥤ D) (G : D ⥤ E) (hG : IsEquivalence G)
+def cancelCompRight {E : Type*} [Category E] (F : C ⥤ D) (G : D ⥤ E) (hG : IsEquivalence G)
     (_ : IsEquivalence (F ⋙ G)) : IsEquivalence F :=
   ofIso (Functor.associator F G G.inv ≪≫ NatIso.hcomp (Iso.refl F) hG.unitIso.symm ≪≫ rightUnitor F)
     (Functor.isEquivalenceTrans (F ⋙ G) G.inv)
@@ -667,7 +667,7 @@ def cancelCompRight {E : Type _} [Category E] (F : C ⥤ D) (G : D ⥤ E) (hG :
 
 /-- If `F` and `F ⋙ G` are equivalence of categories, then `G` is also an equivalence. -/
 @[simp]
-def cancelCompLeft {E : Type _} [Category E] (F : C ⥤ D) (G : D ⥤ E) (hF : IsEquivalence F)
+def cancelCompLeft {E : Type*} [Category E] (F : C ⥤ D) (G : D ⥤ E) (hF : IsEquivalence F)
     (_ : IsEquivalence (F ⋙ G)) : IsEquivalence G :=
   ofIso
     ((Functor.associator F.inv F G).symm ≪≫ NatIso.hcomp hF.counitIso (Iso.refl G) ≪≫ leftUnitor G)
@@ -748,11 +748,11 @@ theorem inverse_map_inj_iff (e : C ≌ D) {X Y : D} (f g : X ⟶ Y) :
   functor_map_inj_iff e.symm f g
 #align category_theory.equivalence.inverse_map_inj_iff CategoryTheory.Equivalence.inverse_map_inj_iff
 
-instance essSurjInducedFunctor {C' : Type _} (e : C' ≃ D) : EssSurj (inducedFunctor e) where
+instance essSurjInducedFunctor {C' : Type*} (e : C' ≃ D) : EssSurj (inducedFunctor e) where
   mem_essImage Y := ⟨e.symm Y, by simpa using ⟨default⟩⟩
 #align category_theory.equivalence.ess_surj_induced_functor CategoryTheory.Equivalence.essSurjInducedFunctor
 
-noncomputable instance inducedFunctorOfEquiv {C' : Type _} (e : C' ≃ D) :
+noncomputable instance inducedFunctorOfEquiv {C' : Type*} (e : C' ≃ D) :
     IsEquivalence (inducedFunctor e) :=
   Equivalence.ofFullyFaithfullyEssSurj _
 #align category_theory.equivalence.induced_functor_of_equiv CategoryTheory.Equivalence.inducedFunctorOfEquiv

@@ -85,7 +85,7 @@ structure Equivalence (C : Type u₁) (D : Type u₂) [Category.{v₁} C] [Categ
   unitIso : 𝟭 C ≅ functor ⋙ inverse
   /-- The composition `inverse ⋙ functor` is also isomorphic to the identity -/
   counitIso : inverse ⋙ functor ≅ 𝟭 D
-  /-- The natural isomorphism compose to the identity -/
+  /-- The natural isomorphisms compose to the identity. -/
   functor_unitIso_comp :
     ∀ X : C, functor.map (unitIso.hom.app X) ≫ counitIso.hom.app (functor.obj X) =
       𝟙 (functor.obj X) := by aesop_cat
@@ -475,9 +475,9 @@ class IsEquivalence (F : C ⥤ D) where mk' ::
   inverse : D ⥤ C
   /-- Composition `F ⋙ inverse` is isomorphic to the identity. -/
   unitIso : 𝟭 C ≅ F ⋙ inverse
-  /-- Composition `inverse ⋙ F` is isomorphic to the identity. =-/
+  /-- Composition `inverse ⋙ F` is isomorphic to the identity. -/
   counitIso : inverse ⋙ F ≅ 𝟭 D
-  /-- We natural isomorphisms are inverse -/
+  /-- The natural isomorphisms are inverse. -/
   functor_unitIso_comp :
     ∀ X : C,
       F.map ((unitIso.hom : 𝟭 C ⟶ F ⋙ inverse).app X) ≫ counitIso.hom.app (F.obj X) =

• depends on: #5966

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

@@ -2,17 +2,14 @@
 Copyright (c) 2017 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Tim Baumann, Stephen Morgan, Scott Morrison, Floris van Doorn
-
-! This file was ported from Lean 3 source module category_theory.equivalence
-! leanprover-community/mathlib commit 9aba7801eeecebb61f58a5763c2b6dd1b47dc6ef
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Functor.FullyFaithful
 import Mathlib.CategoryTheory.FullSubcategory
 import Mathlib.CategoryTheory.Whiskering
 import Mathlib.CategoryTheory.EssentialImage
 import Mathlib.Tactic.CategoryTheory.Slice
+
+#align_import category_theory.equivalence from "leanprover-community/mathlib"@"9aba7801eeecebb61f58a5763c2b6dd1b47dc6ef"
 /-!
 # Equivalence of categories
 

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

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

@@ -476,7 +476,7 @@ end Equivalence
 class IsEquivalence (F : C ⥤ D) where mk' ::
   /-- The inverse functor to `F` -/
   inverse : D ⥤ C
-  /-- Composition `F ⋙  inverse` is isomorphic to the identity. -/
+  /-- Composition `F ⋙ inverse` is isomorphic to the identity. -/
   unitIso : 𝟭 C ≅ F ⋙ inverse
   /-- Composition `inverse ⋙ F` is isomorphic to the identity. =-/
   counitIso : inverse ⋙ F ≅ 𝟭 D

These are all doc fixes

@@ -18,7 +18,7 @@ import Mathlib.Tactic.CategoryTheory.Slice
 
 An equivalence of categories `C` and `D` is a pair of functors `F : C ⥤ D` and `G : D ⥤ C` such
 that `η : 𝟭 C ≅ F ⋙ G` and `ε : G ⋙ F ≅ 𝟭 D`. In many situations, equivalences are a better
-notion of "sameness" of categories than the stricter isomorphims of categories.
+notion of "sameness" of categories than the stricter isomorphism of categories.
 
 Recall that one way to express that two functors `F : C ⥤ D` and `G : D ⥤ C` are adjoint is using
 two natural transformations `η : 𝟭 C ⟶ F ⋙ G` and `ε : G ⋙ F ⟶ 𝟭 D`, called the unit and the

Clean up of automation in the category theory library. Leaving out unnecessary proof steps, or fields done by aesop_cat, and making more use of available autoparameters.

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

@@ -359,8 +359,8 @@ theorem invFunIdAssoc_inv_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
 @[simps! functor inverse unitIso counitIso]
 def congrLeft (e : C ≌ D) : C ⥤ E ≌ D ⥤ E :=
   Equivalence.mk ((whiskeringLeft _ _ _).obj e.inverse) ((whiskeringLeft _ _ _).obj e.functor)
-    (NatIso.ofComponents (fun F => (e.funInvIdAssoc F).symm) (by aesop_cat))
-    (NatIso.ofComponents (fun F => e.invFunIdAssoc F) (by aesop_cat))
+    (NatIso.ofComponents fun F => (e.funInvIdAssoc F).symm)
+    (NatIso.ofComponents fun F => e.invFunIdAssoc F)
 #align category_theory.equivalence.congr_left CategoryTheory.Equivalence.congrLeft
 
 /-- If `C` is equivalent to `D`, then `E ⥤ C` is equivalent to `E ⥤ D`. -/
@@ -368,11 +368,9 @@ def congrLeft (e : C ≌ D) : C ⥤ E ≌ D ⥤ E :=
 def congrRight (e : C ≌ D) : E ⥤ C ≌ E ⥤ D :=
   Equivalence.mk ((whiskeringRight _ _ _).obj e.functor) ((whiskeringRight _ _ _).obj e.inverse)
     (NatIso.ofComponents
-      (fun F => F.rightUnitor.symm ≪≫ isoWhiskerLeft F e.unitIso ≪≫ Functor.associator _ _ _)
-      (by aesop_cat))
+      fun F => F.rightUnitor.symm ≪≫ isoWhiskerLeft F e.unitIso ≪≫ Functor.associator _ _ _)
     (NatIso.ofComponents
-      (fun F => Functor.associator _ _ _ ≪≫ isoWhiskerLeft F e.counitIso ≪≫ F.rightUnitor)
-      (by aesop_cat))
+      fun F => Functor.associator _ _ _ ≪≫ isoWhiskerLeft F e.counitIso ≪≫ F.rightUnitor)
 #align category_theory.equivalence.congr_right CategoryTheory.Equivalence.congrRight
 
 section CancellationLemmas
@@ -736,9 +734,9 @@ noncomputable def ofFullyFaithfullyEssSurj (F : C ⥤ D) [Full F] [Faithful F] [
   IsEquivalence.mk (equivalenceInverse F)
     (NatIso.ofComponents (fun X => (F.preimageIso <| F.objObjPreimageIso <| F.obj X).symm)
       fun f => by
-      apply F.map_injective
-      aesop_cat)
-    (NatIso.ofComponents F.objObjPreimageIso (by aesop_cat))
+        apply F.map_injective
+        aesop_cat)
+    (NatIso.ofComponents F.objObjPreimageIso)
 #align category_theory.equivalence.of_fully_faithfully_ess_surj CategoryTheory.Equivalence.ofFullyFaithfullyEssSurj
 
 @[simp]

@@ -12,7 +12,7 @@ import Mathlib.CategoryTheory.Functor.FullyFaithful
 import Mathlib.CategoryTheory.FullSubcategory
 import Mathlib.CategoryTheory.Whiskering
 import Mathlib.CategoryTheory.EssentialImage
-import Mathlib.Tactic.Slice
+import Mathlib.Tactic.CategoryTheory.Slice
 /-!
 # Equivalence of categories
 

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

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

@@ -158,24 +158,21 @@ theorem functor_unit_comp (e : C ≌ D) (X : C) :
 
 @[simp]
 theorem counitInv_functor_comp (e : C ≌ D) (X : C) :
-    e.counitInv.app (e.functor.obj X) ≫ e.functor.map (e.unitInv.app X) = 𝟙 (e.functor.obj X) :=
-  by
+    e.counitInv.app (e.functor.obj X) ≫ e.functor.map (e.unitInv.app X) = 𝟙 (e.functor.obj X) := by
   erw [Iso.inv_eq_inv (e.functor.mapIso (e.unitIso.app X) ≪≫ e.counitIso.app (e.functor.obj X))
       (Iso.refl _)]
   exact e.functor_unit_comp X
 #align category_theory.equivalence.counit_inv_functor_comp CategoryTheory.Equivalence.counitInv_functor_comp
 
 theorem counitInv_app_functor (e : C ≌ D) (X : C) :
-    e.counitInv.app (e.functor.obj X) = e.functor.map (e.unit.app X) :=
-  by
+    e.counitInv.app (e.functor.obj X) = e.functor.map (e.unit.app X) := by
   symm
   erw [← Iso.comp_hom_eq_id (e.counitIso.app _), functor_unit_comp]
   rfl
 #align category_theory.equivalence.counit_inv_app_functor CategoryTheory.Equivalence.counitInv_app_functor
 
 theorem counit_app_functor (e : C ≌ D) (X : C) :
-    e.counit.app (e.functor.obj X) = e.functor.map (e.unitInv.app X) :=
-  by
+    e.counit.app (e.functor.obj X) = e.functor.map (e.unitInv.app X) := by
   erw [← Iso.hom_comp_eq_id (e.functor.mapIso (e.unitIso.app X)), functor_unit_comp]
   rfl
 #align category_theory.equivalence.counit_app_functor CategoryTheory.Equivalence.counit_app_functor
@@ -184,8 +181,7 @@ theorem counit_app_functor (e : C ≌ D) (X : C) :
   http://globular.science/1905.001 -/
 @[simp]
 theorem unit_inverse_comp (e : C ≌ D) (Y : D) :
-    e.unit.app (e.inverse.obj Y) ≫ e.inverse.map (e.counit.app Y) = 𝟙 (e.inverse.obj Y) :=
-  by
+    e.unit.app (e.inverse.obj Y) ≫ e.inverse.map (e.counit.app Y) = 𝟙 (e.inverse.obj Y) := by
   rw [← id_comp (e.inverse.map _), ← map_id e.inverse, ← counitInv_functor_comp, map_comp]
   dsimp
   rw [← Iso.hom_inv_id_assoc (e.unitIso.app _) (e.inverse.map (e.functor.map _)), app_hom, app_inv]
@@ -210,8 +206,7 @@ theorem unit_inverse_comp (e : C ≌ D) (Y : D) :
 
 @[simp]
 theorem inverse_counitInv_comp (e : C ≌ D) (Y : D) :
-    e.inverse.map (e.counitInv.app Y) ≫ e.unitInv.app (e.inverse.obj Y) = 𝟙 (e.inverse.obj Y) :=
-  by
+    e.inverse.map (e.counitInv.app Y) ≫ e.unitInv.app (e.inverse.obj Y) = 𝟙 (e.inverse.obj Y) := by
   erw [Iso.inv_eq_inv (e.unitIso.app (e.inverse.obj Y) ≪≫ e.inverse.mapIso (e.counitIso.app Y))
       (Iso.refl _)]
   exact e.unit_inverse_comp Y
@@ -262,8 +257,7 @@ def adjointifyη : 𝟭 C ≅ F ⋙ G := by
 #align category_theory.equivalence.adjointify_η CategoryTheory.Equivalence.adjointifyη
 
 theorem adjointify_η_ε (X : C) :
-    F.map ((adjointifyη η ε).hom.app X) ≫ ε.hom.app (F.obj X) = 𝟙 (F.obj X) :=
-  by
+    F.map ((adjointifyη η ε).hom.app X) ≫ ε.hom.app (F.obj X) = 𝟙 (F.obj X) := by
   dsimp [adjointifyη,Trans.trans]
   simp
   have := ε.hom.naturality (F.map (η.inv.app X)); dsimp at this; rw [this]; clear this
@@ -329,16 +323,14 @@ def funInvIdAssoc (e : C ≌ D) (F : C ⥤ E) : e.functor ⋙ e.inverse ⋙ F 
 
 @[simp]
 theorem funInvIdAssoc_hom_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
-    (funInvIdAssoc e F).hom.app X = F.map (e.unitInv.app X) :=
-  by
+    (funInvIdAssoc e F).hom.app X = F.map (e.unitInv.app X) := by
   dsimp [funInvIdAssoc]
   aesop_cat
 #align category_theory.equivalence.fun_inv_id_assoc_hom_app CategoryTheory.Equivalence.funInvIdAssoc_hom_app
 
 @[simp]
 theorem funInvIdAssoc_inv_app (e : C ≌ D) (F : C ⥤ E) (X : C) :
-    (funInvIdAssoc e F).inv.app X = F.map (e.unit.app X) :=
-  by
+    (funInvIdAssoc e F).inv.app X = F.map (e.unit.app X) := by
   dsimp [funInvIdAssoc]
   aesop_cat
 #align category_theory.equivalence.fun_inv_id_assoc_inv_app CategoryTheory.Equivalence.funInvIdAssoc_inv_app
@@ -351,16 +343,14 @@ def invFunIdAssoc (e : C ≌ D) (F : D ⥤ E) : e.inverse ⋙ e.functor ⋙ F 
 
 @[simp]
 theorem invFunIdAssoc_hom_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
-    (invFunIdAssoc e F).hom.app X = F.map (e.counit.app X) :=
-  by
+    (invFunIdAssoc e F).hom.app X = F.map (e.counit.app X) := by
   dsimp [invFunIdAssoc]
   aesop_cat
 #align category_theory.equivalence.inv_fun_id_assoc_hom_app CategoryTheory.Equivalence.invFunIdAssoc_hom_app
 
 @[simp]
 theorem invFunIdAssoc_inv_app (e : C ≌ D) (F : D ⥤ E) (X : D) :
-    (invFunIdAssoc e F).inv.app X = F.map (e.counitInv.app X) :=
-  by
+    (invFunIdAssoc e F).inv.app X = F.map (e.counitInv.app X) := by
   dsimp [invFunIdAssoc]
   aesop_cat
 #align category_theory.equivalence.inv_fun_id_assoc_inv_app CategoryTheory.Equivalence.invFunIdAssoc_inv_app
@@ -595,15 +585,13 @@ theorem inverse_inv (E : C ≌ D) : E.inverse.inv = E.functor :=
 #align category_theory.equivalence.inverse_inv CategoryTheory.Equivalence.inverse_inv
 
 @[simp]
-theorem functor_asEquivalence (E : C ≌ D) : E.functor.asEquivalence = E :=
-  by
+theorem functor_asEquivalence (E : C ≌ D) : E.functor.asEquivalence = E := by
   cases E
   congr
 #align category_theory.equivalence.functor_as_equivalence CategoryTheory.Equivalence.functor_asEquivalence
 
 @[simp]
-theorem inverse_asEquivalence (E : C ≌ D) : E.inverse.asEquivalence = E.symm :=
-  by
+theorem inverse_asEquivalence (E : C ≌ D) : E.inverse.asEquivalence = E.symm := by
   cases E
   congr
 #align category_theory.equivalence.inverse_as_equivalence CategoryTheory.Equivalence.inverse_asEquivalence
@@ -614,16 +602,14 @@ namespace IsEquivalence
 
 @[simp]
 theorem fun_inv_map (F : C ⥤ D) [IsEquivalence F] (X Y : D) (f : X ⟶ Y) :
-    F.map (F.inv.map f) = F.asEquivalence.counit.app X ≫ f ≫ F.asEquivalence.counitInv.app Y :=
-  by
+    F.map (F.inv.map f) = F.asEquivalence.counit.app X ≫ f ≫ F.asEquivalence.counitInv.app Y := by
   erw [NatIso.naturality_2]
   rfl
 #align category_theory.is_equivalence.fun_inv_map CategoryTheory.IsEquivalence.fun_inv_map
 
 @[simp]
 theorem inv_fun_map (F : C ⥤ D) [IsEquivalence F] (X Y : C) (f : X ⟶ Y) :
-    F.inv.map (F.map f) = F.asEquivalence.unitInv.app X ≫ f ≫ F.asEquivalence.unit.app Y :=
-  by
+    F.inv.map (F.map f) = F.asEquivalence.unitInv.app X ≫ f ≫ F.asEquivalence.unit.app Y := by
   erw [NatIso.naturality_1]
   rfl
 #align category_theory.is_equivalence.inv_fun_map CategoryTheory.IsEquivalence.inv_fun_map
@@ -650,8 +636,7 @@ def ofIso {F G : C ⥤ D} (e : F ≅ G) (hF : IsEquivalence F) : IsEquivalence G
 
 /-- Compatibility of `ofIso` with the composition of isomorphisms of functors -/
 theorem ofIso_trans {F G H : C ⥤ D} (e : F ≅ G) (e' : G ≅ H) (hF : IsEquivalence F) :
-    ofIso e' (ofIso e hF) = ofIso (e ≪≫ e') hF :=
-  by
+    ofIso e' (ofIso e hF) = ofIso (e ≪≫ e') hF := by
   dsimp [ofIso]
   congr 1 <;> ext X <;> dsimp [NatIso.hcomp]
   · simp only [id_comp, assoc, Functor.map_comp]
@@ -659,8 +644,7 @@ theorem ofIso_trans {F G H : C ⥤ D} (e : F ≅ G) (e' : G ≅ H) (hF : IsEquiv
 #align category_theory.is_equivalence.of_iso_trans CategoryTheory.IsEquivalence.ofIso_trans
 
 /-- Compatibility of `ofIso` with identity isomorphisms of functors -/
-theorem ofIso_refl (F : C ⥤ D) (hF : IsEquivalence F) : ofIso (Iso.refl F) hF = hF :=
-  by
+theorem ofIso_refl (F : C ⥤ D) (hF : IsEquivalence F) : ofIso (Iso.refl F) hF = hF := by
   rcases hF with ⟨Finv, Funit, Fcounit, Fcomp⟩
   dsimp [ofIso]
   congr 1 <;> ext X <;> dsimp [NatIso.hcomp]

@@ -93,6 +93,9 @@ structure Equivalence (C : Type u₁) (D : Type u₂) [Category.{v₁} C] [Categ
     ∀ X : C, functor.map (unitIso.hom.app X) ≫ counitIso.hom.app (functor.obj X) =
       𝟙 (functor.obj X) := by aesop_cat
 #align category_theory.equivalence CategoryTheory.Equivalence
+#align category_theory.equivalence.unit_iso CategoryTheory.Equivalence.unitIso
+#align category_theory.equivalence.counit_iso CategoryTheory.Equivalence.counitIso
+#align category_theory.equivalence.functor_unit_iso_comp CategoryTheory.Equivalence.functor_unitIso_comp
 
 /-- We infix the usual notation for an equivalence -/
 infixr:10 " ≌ " => Equivalence
@@ -496,6 +499,9 @@ class IsEquivalence (F : C ⥤ D) where mk' ::
         𝟙 (F.obj X) := by
     aesop_cat
 #align category_theory.is_equivalence CategoryTheory.IsEquivalence
+#align category_theory.is_equivalence.unit_iso CategoryTheory.IsEquivalence.unitIso
+#align category_theory.is_equivalence.counit_iso CategoryTheory.IsEquivalence.counitIso
+#align category_theory.is_equivalence.functor_unit_iso_comp CategoryTheory.IsEquivalence.functor_unitIso_comp
 
 attribute [reassoc (attr := simp)] IsEquivalence.functor_unitIso_comp
 

@@ -697,9 +697,9 @@ namespace Equivalence
 
 See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
-theorem ess_surj_of_equivalence (F : C ⥤ D) [IsEquivalence F] : EssSurj F :=
+theorem essSurj_of_equivalence (F : C ⥤ D) [IsEquivalence F] : EssSurj F :=
   ⟨fun Y => ⟨F.inv.obj Y, ⟨F.asEquivalence.counitIso.app Y⟩⟩⟩
-#align category_theory.equivalence.ess_surj_of_equivalence CategoryTheory.Equivalence.ess_surj_of_equivalence
+#align category_theory.equivalence.ess_surj_of_equivalence CategoryTheory.Equivalence.essSurj_of_equivalence
 
 -- see Note [lower instance priority]
 /-- An equivalence is faithful.
@@ -719,8 +719,8 @@ See <https://stacks.math.columbia.edu/tag/02C3>.
 -/
 instance (priority := 100) fullOfEquivalence (F : C ⥤ D) [IsEquivalence F] : Full F
     where
-  preimage := @fun X Y f => F.asEquivalence.unit.app X ≫ F.inv.map f ≫ F.asEquivalence.unitInv.app Y
-  witness := @fun X Y f =>
+  preimage {X Y} f := F.asEquivalence.unit.app X ≫ F.inv.map f ≫ F.asEquivalence.unitInv.app Y
+  witness {X Y} f :=
     F.inv.map_injective <| by
       simpa only [IsEquivalence.inv_fun_map, assoc, Iso.inv_hom_id_app_assoc,
         Iso.inv_hom_id_app] using comp_id _
@@ -730,9 +730,9 @@ instance (priority := 100) fullOfEquivalence (F : C ⥤ D) [IsEquivalence F] : F
 private noncomputable def equivalenceInverse (F : C ⥤ D) [Full F] [Faithful F] [EssSurj F] : D ⥤ C
     where
   obj X := F.objPreimage X
-  map := @fun X Y f => F.preimage ((F.objObjPreimageIso X).hom ≫ f ≫ (F.objObjPreimageIso Y).inv)
+  map {X Y} f := F.preimage ((F.objObjPreimageIso X).hom ≫ f ≫ (F.objObjPreimageIso Y).inv)
   map_id X := by apply F.map_injective; aesop_cat
-  map_comp := @fun X Y Z f g => by apply F.map_injective; simp
+  map_comp {X Y Z} f g := by apply F.map_injective; simp
 -- #align category_theory.equivalence.equivalence_inverse CategoryTheory.Equivalence.equivalenceInverse
 /- Porting note: this is a private def in mathlib -/
 
@@ -745,7 +745,7 @@ noncomputable def ofFullyFaithfullyEssSurj (F : C ⥤ D) [Full F] [Faithful F] [
     IsEquivalence F :=
   IsEquivalence.mk (equivalenceInverse F)
     (NatIso.ofComponents (fun X => (F.preimageIso <| F.objObjPreimageIso <| F.obj X).symm)
-      @fun X Y f => by
+      fun f => by
       apply F.map_injective
       aesop_cat)
     (NatIso.ofComponents F.objObjPreimageIso (by aesop_cat))
@@ -763,9 +763,8 @@ theorem inverse_map_inj_iff (e : C ≌ D) {X Y : D} (f g : X ⟶ Y) :
   functor_map_inj_iff e.symm f g
 #align category_theory.equivalence.inverse_map_inj_iff CategoryTheory.Equivalence.inverse_map_inj_iff
 
-instance essSurjInducedFunctor {C' : Type _} (e : C' ≃ D) : EssSurj (inducedFunctor e)
-    where mem_essImage Y :=
-      ⟨e.symm Y, by simpa using ⟨default⟩⟩
+instance essSurjInducedFunctor {C' : Type _} (e : C' ≃ D) : EssSurj (inducedFunctor e) where
+  mem_essImage Y := ⟨e.symm Y, by simpa using ⟨default⟩⟩
 #align category_theory.equivalence.ess_surj_induced_functor CategoryTheory.Equivalence.essSurjInducedFunctor
 
 noncomputable instance inducedFunctorOfEquiv {C' : Type _} (e : C' ≃ D) :

@@ -89,7 +89,7 @@ structure Equivalence (C : Type u₁) (D : Type u₂) [Category.{v₁} C] [Categ
   /-- The composition `inverse ⋙ functor` is also isomorphic to the identity -/
   counitIso : inverse ⋙ functor ≅ 𝟭 D
   /-- The natural isomorphism compose to the identity -/
-  functor_unit_iso_comp :
+  functor_unitIso_comp :
     ∀ X : C, functor.map (unitIso.hom.app X) ≫ counitIso.hom.app (functor.obj X) =
       𝟙 (functor.obj X) := by aesop_cat
 #align category_theory.equivalence CategoryTheory.Equivalence
@@ -150,7 +150,7 @@ theorem Equivalence_mk'_counitInv (functor inverse unit_iso counit_iso f) :
 @[simp]
 theorem functor_unit_comp (e : C ≌ D) (X : C) :
     e.functor.map (e.unit.app X) ≫ e.counit.app (e.functor.obj X) = 𝟙 (e.functor.obj X) :=
-  e.functor_unit_iso_comp X
+  e.functor_unitIso_comp X
 #align category_theory.equivalence.functor_unit_comp CategoryTheory.Equivalence.functor_unit_comp
 
 @[simp]
@@ -311,7 +311,7 @@ def trans (e : C ≌ D) (f : D ≌ E) : C ≌ E
   -- We wouldn't have needed to give this proof if we'd used `Equivalence.mk`,
   -- but we choose to avoid using that here, for the sake of good structure projection `simp`
   -- lemmas.
-  functor_unit_iso_comp X := by
+  functor_unitIso_comp X := by
     dsimp
     rw [← f.functor.map_comp_assoc, e.functor.map_comp, ← counitInv_app_functor, fun_inv_map,
       Iso.inv_hom_id_app_assoc, assoc, Iso.inv_hom_id_app, counit_app_functor, ← Functor.map_comp]
@@ -490,14 +490,14 @@ class IsEquivalence (F : C ⥤ D) where mk' ::
   /-- Composition `inverse ⋙ F` is isomorphic to the identity. =-/
   counitIso : inverse ⋙ F ≅ 𝟭 D
   /-- We natural isomorphisms are inverse -/
-  functor_unit_iso_comp :
+  functor_unitIso_comp :
     ∀ X : C,
       F.map ((unitIso.hom : 𝟭 C ⟶ F ⋙ inverse).app X) ≫ counitIso.hom.app (F.obj X) =
         𝟙 (F.obj X) := by
     aesop_cat
 #align category_theory.is_equivalence CategoryTheory.IsEquivalence
 
-attribute [reassoc (attr := simp)] IsEquivalence.functor_unit_iso_comp
+attribute [reassoc (attr := simp)] IsEquivalence.functor_unitIso_comp
 
 namespace IsEquivalence
 
@@ -524,7 +524,7 @@ namespace Functor
 /-- Interpret a functor that is an equivalence as an equivalence. -/
 def asEquivalence (F : C ⥤ D) [IsEquivalence F] : C ≌ D :=
   ⟨F, IsEquivalence.inverse F, IsEquivalence.unitIso, IsEquivalence.counitIso,
-    IsEquivalence.functor_unit_iso_comp⟩
+    IsEquivalence.functor_unitIso_comp⟩
 #align category_theory.functor.as_equivalence CategoryTheory.Functor.asEquivalence
 
 instance isEquivalenceRefl : IsEquivalence (𝟭 C) :=
@@ -630,7 +630,7 @@ def ofIso {F G : C ⥤ D} (e : F ≅ G) (hF : IsEquivalence F) : IsEquivalence G
   inverse := hF.inverse
   unitIso := hF.unitIso ≪≫ NatIso.hcomp e (Iso.refl hF.inverse)
   counitIso := NatIso.hcomp (Iso.refl hF.inverse) e.symm ≪≫ hF.counitIso
-  functor_unit_iso_comp X := by
+  functor_unitIso_comp X := by
     dsimp [NatIso.hcomp]
     erw [id_comp, F.map_id, comp_id]
     apply (cancel_epi (e.hom.app X)).mp
@@ -638,7 +638,7 @@ def ofIso {F G : C ⥤ D} (e : F ≅ G) (hF : IsEquivalence F) : IsEquivalence G
     slice_lhs 2 3 => rw [← NatTrans.vcomp_app', e.hom_inv_id]
     simp only [NatTrans.id_app, id_comp, comp_id, F.map_comp, assoc]
     erw [hF.counitIso.hom.naturality]
-    slice_lhs 1 2 => rw [functor_unit_iso_comp]
+    slice_lhs 1 2 => rw [functor_unitIso_comp]
     simp only [Functor.id_map, id_comp]
 #align category_theory.is_equivalence.of_iso CategoryTheory.IsEquivalence.ofIso
 

This is missing slice_lhs which is only used in two proofs though.

Update: slice_lhs (and other slice tactics) have now been ported

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: thorimur <68410468+thorimur@users.noreply.github.com>