category_theory.functor.fully_faithful

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

70d50ecf

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

c3291da4

bump to nightly-2024-04-29-08

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

6607d135

Diff

@@ -90,35 +90,31 @@ def preimage (F : C ⥤ D) [CategoryTheory.Functor.Full F] (f : F.obj X ⟶ F.ob
 #align category_theory.functor.preimage CategoryTheory.Functor.preimage
 -/
 
-#print CategoryTheory.Functor.image_preimage /-
+#print CategoryTheory.Functor.map_preimage /-
 @[simp]
-theorem image_preimage (F : C ⥤ D) [CategoryTheory.Functor.Full F] {X Y : C}
-    (f : F.obj X ⟶ F.obj Y) : F.map (preimage F f) = f := by unfold preimage <;> obviously
-#align category_theory.functor.image_preimage CategoryTheory.Functor.image_preimage
+theorem map_preimage (F : C ⥤ D) [CategoryTheory.Functor.Full F] {X Y : C} (f : F.obj X ⟶ F.obj Y) :
+    F.map (preimage F f) = f := by unfold preimage <;> obviously
+#align category_theory.functor.image_preimage CategoryTheory.Functor.map_preimage
 -/
 
 #print CategoryTheory.Functor.map_surjective /-
 theorem map_surjective (F : C ⥤ D) [CategoryTheory.Functor.Full F] :
-    Function.Surjective (@Functor.map _ _ _ _ F X Y) := fun f => ⟨F.preimage f, F.image_preimage f⟩
+    Function.Surjective (@Functor.map _ _ _ _ F X Y) := fun f => ⟨F.preimage f, F.map_preimage f⟩
 #align category_theory.functor.map_surjective CategoryTheory.Functor.map_surjective
 -/
 
-#print CategoryTheory.Functor.fullOfExists /-
 /-- Deduce that `F` is full from the existence of preimages, using choice. -/
-noncomputable def fullOfExists (F : C ⥤ D)
+noncomputable def full_of_exists (F : C ⥤ D)
     (h : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), ∃ p, F.map p = f) : CategoryTheory.Functor.Full F :=
   by choose p hp using h; exact ⟨p, hp⟩
-#align category_theory.functor.full_of_exists CategoryTheory.Functor.fullOfExists
--/
+#align category_theory.functor.full_of_exists CategoryTheory.Functor.full_of_exists
 
-#print CategoryTheory.Functor.fullOfSurjective /-
 /-- Deduce that `F` is full from surjectivity of `F.map`, using choice. -/
-noncomputable def fullOfSurjective (F : C ⥤ D)
+noncomputable def full_of_surjective (F : C ⥤ D)
     (h : ∀ X Y : C, Function.Surjective (@Functor.map _ _ _ _ F X Y)) :
     CategoryTheory.Functor.Full F :=
-  fullOfExists _ h
-#align category_theory.functor.full_of_surjective CategoryTheory.Functor.fullOfSurjective
--/
+  full_of_exists _ h
+#align category_theory.functor.full_of_surjective CategoryTheory.Functor.full_of_surjective
 
 end Functor
 
@@ -314,14 +310,14 @@ section
 
 variable {F F'}
 
-#print CategoryTheory.Functor.Full.ofIso /-
+#print CategoryTheory.Functor.Full.of_iso /-
 /-- If `F` is full, and naturally isomorphic to some `F'`, then `F'` is also full. -/
-def CategoryTheory.Functor.Full.ofIso [CategoryTheory.Functor.Full F] (α : F ≅ F') :
+def CategoryTheory.Functor.Full.of_iso [CategoryTheory.Functor.Full F] (α : F ≅ F') :
     CategoryTheory.Functor.Full F'
     where
   preimage X Y f := F.preimage ((α.app X).Hom ≫ f ≫ (α.app Y).inv)
   witness' X Y f := by simp [← nat_iso.naturality_1 α]
-#align category_theory.full.of_iso CategoryTheory.Functor.Full.ofIso
+#align category_theory.full.of_iso CategoryTheory.Functor.Full.of_iso
 -/
 
 #print CategoryTheory.Functor.Faithful.of_iso /-
@@ -426,24 +422,24 @@ instance CategoryTheory.Functor.Full.comp [CategoryTheory.Functor.Full F]
 #align category_theory.full.comp CategoryTheory.Functor.Full.comp
 -/
 
-#print CategoryTheory.Functor.Full.ofCompFaithful /-
+#print CategoryTheory.Functor.Full.of_comp_faithful /-
 /-- If `F ⋙ G` is full and `G` is faithful, then `F` is full. -/
-def CategoryTheory.Functor.Full.ofCompFaithful [CategoryTheory.Functor.Full <| F ⋙ G]
+def CategoryTheory.Functor.Full.of_comp_faithful [CategoryTheory.Functor.Full <| F ⋙ G]
     [CategoryTheory.Functor.Faithful G] : CategoryTheory.Functor.Full F
     where
   preimage X Y f := (F ⋙ G).preimage (G.map f)
-  witness' X Y f := G.map_injective ((F ⋙ G).image_preimage _)
-#align category_theory.full.of_comp_faithful CategoryTheory.Functor.Full.ofCompFaithful
+  witness' X Y f := G.map_injective ((F ⋙ G).map_preimage _)
+#align category_theory.full.of_comp_faithful CategoryTheory.Functor.Full.of_comp_faithful
 -/
 
-#print CategoryTheory.Functor.Full.ofCompFaithfulIso /-
+#print CategoryTheory.Functor.Full.of_comp_faithful_iso /-
 /-- If `F ⋙ G` is full and `G` is faithful, then `F` is full. -/
-def CategoryTheory.Functor.Full.ofCompFaithfulIso {F : C ⥤ D} {G : D ⥤ E} {H : C ⥤ E}
+def CategoryTheory.Functor.Full.of_comp_faithful_iso {F : C ⥤ D} {G : D ⥤ E} {H : C ⥤ E}
     [CategoryTheory.Functor.Full H] [CategoryTheory.Functor.Faithful G] (h : F ⋙ G ≅ H) :
     CategoryTheory.Functor.Full F :=
-  @CategoryTheory.Functor.Full.ofCompFaithful _ _ _ _ _ _ F G
-    (CategoryTheory.Functor.Full.ofIso h.symm) _
-#align category_theory.full.of_comp_faithful_iso CategoryTheory.Functor.Full.ofCompFaithfulIso
+  @CategoryTheory.Functor.Full.of_comp_faithful _ _ _ _ _ _ F G
+    (CategoryTheory.Functor.Full.of_iso h.symm) _
+#align category_theory.full.of_comp_faithful_iso CategoryTheory.Functor.Full.of_comp_faithful_iso
 -/
 
 #print CategoryTheory.Functor.fullyFaithfulCancelRight /-

c3291da4

bump to nightly-2024-04-14-09

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

f736ea6b

Diff

@@ -39,30 +39,30 @@ namespace CategoryTheory
 
 variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
 
-#print CategoryTheory.Full /-
+#print CategoryTheory.Functor.Full /-
 /-- A functor `F : C ⥤ D` is full if for each `X Y : C`, `F.map` is surjective.
 In fact, we use a constructive definition, so the `full F` typeclass contains data,
 specifying a particular preimage of each `f : F.obj X ⟶ F.obj Y`.
 
 See <https://stacks.math.columbia.edu/tag/001C>.
 -/
-class Full (F : C ⥤ D) where
+class CategoryTheory.Functor.Full (F : C ⥤ D) where
   preimage : ∀ {X Y : C} (f : F.obj X ⟶ F.obj Y), X ⟶ Y
   witness' : ∀ {X Y : C} (f : F.obj X ⟶ F.obj Y), F.map (preimage f) = f := by obviously
-#align category_theory.full CategoryTheory.Full
+#align category_theory.full CategoryTheory.Functor.Full
 -/
 
 attribute [simp] full.witness
 
-#print CategoryTheory.Faithful /-
+#print CategoryTheory.Functor.Faithful /-
 /- ./././Mathport/Syntax/Translate/Command.lean:400:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
 /-- A functor `F : C ⥤ D` is faithful if for each `X Y : C`, `F.map` is injective.
 
 See <https://stacks.math.columbia.edu/tag/001C>.
 -/
-class Faithful (F : C ⥤ D) : Prop where
+class CategoryTheory.Functor.Faithful (F : C ⥤ D) : Prop where
   map_injective' : ∀ {X Y : C}, Function.Injective (@Functor.map _ _ _ _ F X Y) := by obviously
-#align category_theory.faithful CategoryTheory.Faithful
+#align category_theory.faithful CategoryTheory.Functor.Faithful
 -/
 
 namespace Functor
@@ -70,13 +70,14 @@ namespace Functor
 variable {X Y : C}
 
 #print CategoryTheory.Functor.map_injective /-
-theorem map_injective (F : C ⥤ D) [Faithful F] : Function.Injective <| @Functor.map _ _ _ _ F X Y :=
-  Faithful.map_injective F
+theorem map_injective (F : C ⥤ D) [CategoryTheory.Functor.Faithful F] :
+    Function.Injective <| @Functor.map _ _ _ _ F X Y :=
+  CategoryTheory.Functor.Faithful.map_injective F
 #align category_theory.functor.map_injective CategoryTheory.Functor.map_injective
 -/
 
 #print CategoryTheory.Functor.mapIso_injective /-
-theorem mapIso_injective (F : C ⥤ D) [Faithful F] :
+theorem mapIso_injective (F : C ⥤ D) [CategoryTheory.Functor.Faithful F] :
     Function.Injective <| @Functor.mapIso _ _ _ _ F X Y := fun i j h =>
   Iso.ext (map_injective F (congr_arg Iso.hom h : _))
 #align category_theory.functor.map_iso_injective CategoryTheory.Functor.mapIso_injective
@@ -84,36 +85,37 @@ theorem mapIso_injective (F : C ⥤ D) [Faithful F] :
 
 #print CategoryTheory.Functor.preimage /-
 /-- The specified preimage of a morphism under a full functor. -/
-def preimage (F : C ⥤ D) [Full F] (f : F.obj X ⟶ F.obj Y) : X ⟶ Y :=
-  Full.preimage.{v₁, v₂} f
+def preimage (F : C ⥤ D) [CategoryTheory.Functor.Full F] (f : F.obj X ⟶ F.obj Y) : X ⟶ Y :=
+  CategoryTheory.Functor.Full.preimage.{v₁, v₂} f
 #align category_theory.functor.preimage CategoryTheory.Functor.preimage
 -/
 
 #print CategoryTheory.Functor.image_preimage /-
 @[simp]
-theorem image_preimage (F : C ⥤ D) [Full F] {X Y : C} (f : F.obj X ⟶ F.obj Y) :
-    F.map (preimage F f) = f := by unfold preimage <;> obviously
+theorem image_preimage (F : C ⥤ D) [CategoryTheory.Functor.Full F] {X Y : C}
+    (f : F.obj X ⟶ F.obj Y) : F.map (preimage F f) = f := by unfold preimage <;> obviously
 #align category_theory.functor.image_preimage CategoryTheory.Functor.image_preimage
 -/
 
 #print CategoryTheory.Functor.map_surjective /-
-theorem map_surjective (F : C ⥤ D) [Full F] : Function.Surjective (@Functor.map _ _ _ _ F X Y) :=
-  fun f => ⟨F.preimage f, F.image_preimage f⟩
+theorem map_surjective (F : C ⥤ D) [CategoryTheory.Functor.Full F] :
+    Function.Surjective (@Functor.map _ _ _ _ F X Y) := fun f => ⟨F.preimage f, F.image_preimage f⟩
 #align category_theory.functor.map_surjective CategoryTheory.Functor.map_surjective
 -/
 
 #print CategoryTheory.Functor.fullOfExists /-
 /-- Deduce that `F` is full from the existence of preimages, using choice. -/
 noncomputable def fullOfExists (F : C ⥤ D)
-    (h : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), ∃ p, F.map p = f) : Full F := by choose p hp using h;
-  exact ⟨p, hp⟩
+    (h : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), ∃ p, F.map p = f) : CategoryTheory.Functor.Full F :=
+  by choose p hp using h; exact ⟨p, hp⟩
 #align category_theory.functor.full_of_exists CategoryTheory.Functor.fullOfExists
 -/
 
 #print CategoryTheory.Functor.fullOfSurjective /-
 /-- Deduce that `F` is full from surjectivity of `F.map`, using choice. -/
 noncomputable def fullOfSurjective (F : C ⥤ D)
-    (h : ∀ X Y : C, Function.Surjective (@Functor.map _ _ _ _ F X Y)) : Full F :=
+    (h : ∀ X Y : C, Function.Surjective (@Functor.map _ _ _ _ F X Y)) :
+    CategoryTheory.Functor.Full F :=
   fullOfExists _ h
 #align category_theory.functor.full_of_surjective CategoryTheory.Functor.fullOfSurjective
 -/
@@ -122,28 +124,28 @@ end Functor
 
 section
 
-variable {F : C ⥤ D} [Full F] [Faithful F] {X Y Z : C}
+variable {F : C ⥤ D} [CategoryTheory.Functor.Full F] [CategoryTheory.Functor.Faithful F] {X Y Z : C}
 
-#print CategoryTheory.preimage_id /-
+#print CategoryTheory.Functor.preimage_id /-
 @[simp]
-theorem preimage_id : F.preimage (𝟙 (F.obj X)) = 𝟙 X :=
+theorem CategoryTheory.Functor.preimage_id : F.preimage (𝟙 (F.obj X)) = 𝟙 X :=
   F.map_injective (by simp)
-#align category_theory.preimage_id CategoryTheory.preimage_id
+#align category_theory.preimage_id CategoryTheory.Functor.preimage_id
 -/
 
-#print CategoryTheory.preimage_comp /-
+#print CategoryTheory.Functor.preimage_comp /-
 @[simp]
-theorem preimage_comp (f : F.obj X ⟶ F.obj Y) (g : F.obj Y ⟶ F.obj Z) :
+theorem CategoryTheory.Functor.preimage_comp (f : F.obj X ⟶ F.obj Y) (g : F.obj Y ⟶ F.obj Z) :
     F.preimage (f ≫ g) = F.preimage f ≫ F.preimage g :=
   F.map_injective (by simp)
-#align category_theory.preimage_comp CategoryTheory.preimage_comp
+#align category_theory.preimage_comp CategoryTheory.Functor.preimage_comp
 -/
 
-#print CategoryTheory.preimage_map /-
+#print CategoryTheory.Functor.preimage_map /-
 @[simp]
-theorem preimage_map (f : X ⟶ Y) : F.preimage (F.map f) = f :=
+theorem CategoryTheory.Functor.preimage_map (f : X ⟶ Y) : F.preimage (F.map f) = f :=
   F.map_injective (by simp)
-#align category_theory.preimage_map CategoryTheory.preimage_map
+#align category_theory.preimage_map CategoryTheory.Functor.preimage_map
 -/
 
 variable (F)
@@ -207,7 +209,8 @@ end
 
 section
 
-variable {E : Type _} [Category E] {F G : C ⥤ D} (H : D ⥤ E) [Full H] [Faithful H]
+variable {E : Type _} [Category E] {F G : C ⥤ D} (H : D ⥤ E) [CategoryTheory.Functor.Full H]
+  [CategoryTheory.Functor.Faithful H]
 
 #print CategoryTheory.natTransOfCompFullyFaithful /-
 /-- We can construct a natural transformation between functors by constructing a
@@ -278,72 +281,80 @@ namespace CategoryTheory
 
 variable {C : Type u₁} [Category.{v₁} C]
 
-#print CategoryTheory.Full.id /-
-instance Full.id : Full (𝟭 C) where preimage _ _ f := f
-#align category_theory.full.id CategoryTheory.Full.id
+#print CategoryTheory.Functor.Full.id /-
+instance CategoryTheory.Functor.Full.id : CategoryTheory.Functor.Full (𝟭 C)
+    where preimage _ _ f := f
+#align category_theory.full.id CategoryTheory.Functor.Full.id
 -/
 
-#print CategoryTheory.Faithful.id /-
-instance Faithful.id : Faithful (𝟭 C) := by obviously
-#align category_theory.faithful.id CategoryTheory.Faithful.id
+#print CategoryTheory.Functor.Faithful.id /-
+instance CategoryTheory.Functor.Faithful.id : CategoryTheory.Functor.Faithful (𝟭 C) := by obviously
+#align category_theory.faithful.id CategoryTheory.Functor.Faithful.id
 -/
 
 variable {D : Type u₂} [Category.{v₂} D] {E : Type u₃} [Category.{v₃} E]
 
 variable (F F' : C ⥤ D) (G : D ⥤ E)
 
-#print CategoryTheory.Faithful.comp /-
-instance Faithful.comp [Faithful F] [Faithful G] : Faithful (F ⋙ G)
+#print CategoryTheory.Functor.Faithful.comp /-
+instance CategoryTheory.Functor.Faithful.comp [CategoryTheory.Functor.Faithful F]
+    [CategoryTheory.Functor.Faithful G] : CategoryTheory.Functor.Faithful (F ⋙ G)
     where map_injective' _ _ _ _ p := F.map_injective (G.map_injective p)
-#align category_theory.faithful.comp CategoryTheory.Faithful.comp
+#align category_theory.faithful.comp CategoryTheory.Functor.Faithful.comp
 -/
 
-#print CategoryTheory.Faithful.of_comp /-
-theorem Faithful.of_comp [Faithful <| F ⋙ G] : Faithful F :=
+#print CategoryTheory.Functor.Faithful.of_comp /-
+theorem CategoryTheory.Functor.Faithful.of_comp [CategoryTheory.Functor.Faithful <| F ⋙ G] :
+    CategoryTheory.Functor.Faithful F :=
   { map_injective' := fun X Y => (F ⋙ G).map_injective.of_comp }
-#align category_theory.faithful.of_comp CategoryTheory.Faithful.of_comp
+#align category_theory.faithful.of_comp CategoryTheory.Functor.Faithful.of_comp
 -/
 
 section
 
 variable {F F'}
 
-#print CategoryTheory.Full.ofIso /-
+#print CategoryTheory.Functor.Full.ofIso /-
 /-- If `F` is full, and naturally isomorphic to some `F'`, then `F'` is also full. -/
-def Full.ofIso [Full F] (α : F ≅ F') : Full F'
+def CategoryTheory.Functor.Full.ofIso [CategoryTheory.Functor.Full F] (α : F ≅ F') :
+    CategoryTheory.Functor.Full F'
     where
   preimage X Y f := F.preimage ((α.app X).Hom ≫ f ≫ (α.app Y).inv)
   witness' X Y f := by simp [← nat_iso.naturality_1 α]
-#align category_theory.full.of_iso CategoryTheory.Full.ofIso
+#align category_theory.full.of_iso CategoryTheory.Functor.Full.ofIso
 -/
 
-#print CategoryTheory.Faithful.of_iso /-
-theorem Faithful.of_iso [Faithful F] (α : F ≅ F') : Faithful F' :=
+#print CategoryTheory.Functor.Faithful.of_iso /-
+theorem CategoryTheory.Functor.Faithful.of_iso [CategoryTheory.Functor.Faithful F] (α : F ≅ F') :
+    CategoryTheory.Functor.Faithful F' :=
   {
     map_injective' := fun X Y f f' h =>
       F.map_injective (by rw [← nat_iso.naturality_1 α.symm, h, nat_iso.naturality_1 α.symm]) }
-#align category_theory.faithful.of_iso CategoryTheory.Faithful.of_iso
+#align category_theory.faithful.of_iso CategoryTheory.Functor.Faithful.of_iso
 -/
 
 end
 
 variable {F G}
 
-#print CategoryTheory.Faithful.of_comp_iso /-
-theorem Faithful.of_comp_iso {H : C ⥤ E} [ℋ : Faithful H] (h : F ⋙ G ≅ H) : Faithful F :=
-  @Faithful.of_comp _ _ _ _ _ _ F G (Faithful.of_iso h.symm)
-#align category_theory.faithful.of_comp_iso CategoryTheory.Faithful.of_comp_iso
+#print CategoryTheory.Functor.Faithful.of_comp_iso /-
+theorem CategoryTheory.Functor.Faithful.of_comp_iso {H : C ⥤ E}
+    [ℋ : CategoryTheory.Functor.Faithful H] (h : F ⋙ G ≅ H) : CategoryTheory.Functor.Faithful F :=
+  @CategoryTheory.Functor.Faithful.of_comp _ _ _ _ _ _ F G
+    (CategoryTheory.Functor.Faithful.of_iso h.symm)
+#align category_theory.faithful.of_comp_iso CategoryTheory.Functor.Faithful.of_comp_iso
 -/
 
 alias _root_.category_theory.iso.faithful_of_comp := faithful.of_comp_iso
 #align category_theory.iso.faithful_of_comp CategoryTheory.Iso.faithful_of_comp
 
-#print CategoryTheory.Faithful.of_comp_eq /-
+#print CategoryTheory.Functor.Faithful.of_comp_eq /-
 -- We could prove this from `faithful.of_comp_iso` using `eq_to_iso`,
 -- but that would introduce a cyclic import.
-theorem Faithful.of_comp_eq {H : C ⥤ E} [ℋ : Faithful H] (h : F ⋙ G = H) : Faithful F :=
-  @Faithful.of_comp _ _ _ _ _ _ F G (h.symm ▸ ℋ)
-#align category_theory.faithful.of_comp_eq CategoryTheory.Faithful.of_comp_eq
+theorem CategoryTheory.Functor.Faithful.of_comp_eq {H : C ⥤ E}
+    [ℋ : CategoryTheory.Functor.Faithful H] (h : F ⋙ G = H) : CategoryTheory.Functor.Faithful F :=
+  @CategoryTheory.Functor.Faithful.of_comp _ _ _ _ _ _ F G (h.symm ▸ ℋ)
+#align category_theory.faithful.of_comp_eq CategoryTheory.Functor.Faithful.of_comp_eq
 -/
 
 alias _root_.eq.faithful_of_comp := faithful.of_comp_eq
@@ -351,10 +362,11 @@ alias _root_.eq.faithful_of_comp := faithful.of_comp_eq
 
 variable (F G)
 
-#print CategoryTheory.Faithful.div /-
+#print CategoryTheory.Functor.Faithful.div /-
 /-- “Divide” a functor by a faithful functor. -/
-protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C → D)
-    (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
+protected def CategoryTheory.Functor.Faithful.div (F : C ⥤ E) (G : D ⥤ E)
+    [CategoryTheory.Functor.Faithful G] (obj : C → D) (h_obj : ∀ X, G.obj (obj X) = F.obj X)
+    (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
     (h_map : ∀ {X Y} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)) : C ⥤ D :=
   { obj
     map := @map
@@ -371,18 +383,19 @@ protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C →
       trans F.map (f ≫ g); exact h_map
       rw [F.map_comp, G.map_comp]
       congr 1 <;> try exact (h_obj _).symm <;> exact h_map.symm }
-#align category_theory.faithful.div CategoryTheory.Faithful.div
+#align category_theory.faithful.div CategoryTheory.Functor.Faithful.div
 -/
 
-#print CategoryTheory.Faithful.div_comp /-
+#print CategoryTheory.Functor.Faithful.div_comp /-
 -- This follows immediately from `functor.hext` (`functor.hext h_obj @h_map`),
 -- but importing `category_theory.eq_to_hom` causes an import loop:
 -- category_theory.eq_to_hom → category_theory.opposites →
 -- category_theory.equivalence → category_theory.fully_faithful
-theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G] (obj : C → D)
+theorem CategoryTheory.Functor.Faithful.div_comp (F : C ⥤ E) [CategoryTheory.Functor.Faithful F]
+    (G : D ⥤ E) [CategoryTheory.Functor.Faithful G] (obj : C → D)
     (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
     (h_map : ∀ {X Y} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)) :
-    Faithful.div F G obj @h_obj @map @h_map ⋙ G = F :=
+    CategoryTheory.Functor.Faithful.div F G obj @h_obj @map @h_map ⋙ G = F :=
   by
   cases' F with F_obj _ _ _; cases' G with G_obj _ _ _
   unfold faithful.div Functor.Comp
@@ -392,68 +405,79 @@ theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G]
   congr
   funext
   exact eq_of_hEq h_map
-#align category_theory.faithful.div_comp CategoryTheory.Faithful.div_comp
+#align category_theory.faithful.div_comp CategoryTheory.Functor.Faithful.div_comp
 -/
 
-#print CategoryTheory.Faithful.div_faithful /-
-theorem Faithful.div_faithful (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G] (obj : C → D)
+#print CategoryTheory.Functor.Faithful.div_faithful /-
+theorem CategoryTheory.Functor.Faithful.div_faithful (F : C ⥤ E) [CategoryTheory.Functor.Faithful F]
+    (G : D ⥤ E) [CategoryTheory.Functor.Faithful G] (obj : C → D)
     (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
     (h_map : ∀ {X Y} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)) :
-    Faithful (Faithful.div F G obj @h_obj @map @h_map) :=
-  (Faithful.div_comp F G _ h_obj _ @h_map).faithful_of_comp
-#align category_theory.faithful.div_faithful CategoryTheory.Faithful.div_faithful
+    CategoryTheory.Functor.Faithful
+      (CategoryTheory.Functor.Faithful.div F G obj @h_obj @map @h_map) :=
+  (CategoryTheory.Functor.Faithful.div_comp F G _ h_obj _ @h_map).faithful_of_comp
+#align category_theory.faithful.div_faithful CategoryTheory.Functor.Faithful.div_faithful
 -/
 
-#print CategoryTheory.Full.comp /-
-instance Full.comp [Full F] [Full G] : Full (F ⋙ G)
+#print CategoryTheory.Functor.Full.comp /-
+instance CategoryTheory.Functor.Full.comp [CategoryTheory.Functor.Full F]
+    [CategoryTheory.Functor.Full G] : CategoryTheory.Functor.Full (F ⋙ G)
     where preimage _ _ f := F.preimage (G.preimage f)
-#align category_theory.full.comp CategoryTheory.Full.comp
+#align category_theory.full.comp CategoryTheory.Functor.Full.comp
 -/
 
-#print CategoryTheory.Full.ofCompFaithful /-
+#print CategoryTheory.Functor.Full.ofCompFaithful /-
 /-- If `F ⋙ G` is full and `G` is faithful, then `F` is full. -/
-def Full.ofCompFaithful [Full <| F ⋙ G] [Faithful G] : Full F
+def CategoryTheory.Functor.Full.ofCompFaithful [CategoryTheory.Functor.Full <| F ⋙ G]
+    [CategoryTheory.Functor.Faithful G] : CategoryTheory.Functor.Full F
     where
   preimage X Y f := (F ⋙ G).preimage (G.map f)
   witness' X Y f := G.map_injective ((F ⋙ G).image_preimage _)
-#align category_theory.full.of_comp_faithful CategoryTheory.Full.ofCompFaithful
+#align category_theory.full.of_comp_faithful CategoryTheory.Functor.Full.ofCompFaithful
 -/
 
-#print CategoryTheory.Full.ofCompFaithfulIso /-
+#print CategoryTheory.Functor.Full.ofCompFaithfulIso /-
 /-- If `F ⋙ G` is full and `G` is faithful, then `F` is full. -/
-def Full.ofCompFaithfulIso {F : C ⥤ D} {G : D ⥤ E} {H : C ⥤ E} [Full H] [Faithful G]
-    (h : F ⋙ G ≅ H) : Full F :=
-  @Full.ofCompFaithful _ _ _ _ _ _ F G (Full.ofIso h.symm) _
-#align category_theory.full.of_comp_faithful_iso CategoryTheory.Full.ofCompFaithfulIso
+def CategoryTheory.Functor.Full.ofCompFaithfulIso {F : C ⥤ D} {G : D ⥤ E} {H : C ⥤ E}
+    [CategoryTheory.Functor.Full H] [CategoryTheory.Functor.Faithful G] (h : F ⋙ G ≅ H) :
+    CategoryTheory.Functor.Full F :=
+  @CategoryTheory.Functor.Full.ofCompFaithful _ _ _ _ _ _ F G
+    (CategoryTheory.Functor.Full.ofIso h.symm) _
+#align category_theory.full.of_comp_faithful_iso CategoryTheory.Functor.Full.ofCompFaithfulIso
 -/
 
-#print CategoryTheory.fullyFaithfulCancelRight /-
+#print CategoryTheory.Functor.fullyFaithfulCancelRight /-
 /-- Given a natural isomorphism between `F ⋙ H` and `G ⋙ H` for a fully faithful functor `H`, we
 can 'cancel' it to give a natural iso between `F` and `G`.
 -/
-def fullyFaithfulCancelRight {F G : C ⥤ D} (H : D ⥤ E) [Full H] [Faithful H]
-    (comp_iso : F ⋙ H ≅ G ⋙ H) : F ≅ G :=
+def CategoryTheory.Functor.fullyFaithfulCancelRight {F G : C ⥤ D} (H : D ⥤ E)
+    [CategoryTheory.Functor.Full H] [CategoryTheory.Functor.Faithful H] (comp_iso : F ⋙ H ≅ G ⋙ H) :
+    F ≅ G :=
   NatIso.ofComponents (fun X => H.preimageIso (comp_iso.app X)) fun X Y f =>
     H.map_injective (by simpa using comp_iso.hom.naturality f)
-#align category_theory.fully_faithful_cancel_right CategoryTheory.fullyFaithfulCancelRight
+#align category_theory.fully_faithful_cancel_right CategoryTheory.Functor.fullyFaithfulCancelRight
 -/
 
-#print CategoryTheory.fullyFaithfulCancelRight_hom_app /-
+#print CategoryTheory.Functor.fullyFaithfulCancelRight_hom_app /-
 @[simp]
-theorem fullyFaithfulCancelRight_hom_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [Faithful H]
-    (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
-    (fullyFaithfulCancelRight H comp_iso).Hom.app X = H.preimage (comp_iso.Hom.app X) :=
+theorem CategoryTheory.Functor.fullyFaithfulCancelRight_hom_app {F G : C ⥤ D} {H : D ⥤ E}
+    [CategoryTheory.Functor.Full H] [CategoryTheory.Functor.Faithful H] (comp_iso : F ⋙ H ≅ G ⋙ H)
+    (X : C) :
+    (CategoryTheory.Functor.fullyFaithfulCancelRight H comp_iso).Hom.app X =
+      H.preimage (comp_iso.Hom.app X) :=
   rfl
-#align category_theory.fully_faithful_cancel_right_hom_app CategoryTheory.fullyFaithfulCancelRight_hom_app
+#align category_theory.fully_faithful_cancel_right_hom_app CategoryTheory.Functor.fullyFaithfulCancelRight_hom_app
 -/
 
-#print CategoryTheory.fullyFaithfulCancelRight_inv_app /-
+#print CategoryTheory.Functor.fullyFaithfulCancelRight_inv_app /-
 @[simp]
-theorem fullyFaithfulCancelRight_inv_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [Faithful H]
-    (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
-    (fullyFaithfulCancelRight H comp_iso).inv.app X = H.preimage (comp_iso.inv.app X) :=
+theorem CategoryTheory.Functor.fullyFaithfulCancelRight_inv_app {F G : C ⥤ D} {H : D ⥤ E}
+    [CategoryTheory.Functor.Full H] [CategoryTheory.Functor.Faithful H] (comp_iso : F ⋙ H ≅ G ⋙ H)
+    (X : C) :
+    (CategoryTheory.Functor.fullyFaithfulCancelRight H comp_iso).inv.app X =
+      H.preimage (comp_iso.inv.app X) :=
   rfl
-#align category_theory.fully_faithful_cancel_right_inv_app CategoryTheory.fullyFaithfulCancelRight_inv_app
+#align category_theory.fully_faithful_cancel_right_inv_app CategoryTheory.Functor.fullyFaithfulCancelRight_inv_app
 -/
 
 end CategoryTheory

c3291da4

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2018 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import CategoryTheory.NaturalIsomorphism
+import CategoryTheory.NatIso
 import Logic.Equiv.Defs
 
 #align_import category_theory.functor.fully_faithful from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"

c3291da4

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -386,7 +386,7 @@ theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G]
   by
   cases' F with F_obj _ _ _; cases' G with G_obj _ _ _
   unfold faithful.div Functor.Comp
-  unfold_projs  at h_obj 
+  unfold_projs  at h_obj
   have : F_obj = G_obj ∘ obj := (funext h_obj).symm
   subst this
   congr

c3291da4

bump to nightly-2024-02-05-08

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

516c6ec2

Diff

@@ -55,7 +55,7 @@ class Full (F : C ⥤ D) where
 attribute [simp] full.witness
 
 #print CategoryTheory.Faithful /-
-/- ./././Mathport/Syntax/Translate/Command.lean:404:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:400:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
 /-- A functor `F : C ⥤ D` is faithful if for each `X Y : C`, `F.map` is injective.
 
 See <https://stacks.math.columbia.edu/tag/001C>.

c3291da4

bump to nightly-2023-12-23-06

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

b8c74971

Diff

@@ -55,7 +55,7 @@ class Full (F : C ⥤ D) where
 attribute [simp] full.witness
 
 #print CategoryTheory.Faithful /-
-/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:404:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
 /-- A functor `F : C ⥤ D` is faithful if for each `X Y : C`, `F.map` is injective.
 
 See <https://stacks.math.columbia.edu/tag/001C>.

c3291da4

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2018 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Mathbin.CategoryTheory.NaturalIsomorphism
-import Mathbin.Logic.Equiv.Defs
+import CategoryTheory.NaturalIsomorphism
+import Logic.Equiv.Defs
 
 #align_import category_theory.functor.fully_faithful from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
 
@@ -55,7 +55,7 @@ class Full (F : C ⥤ D) where
 attribute [simp] full.witness
 
 #print CategoryTheory.Faithful /-
-/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
 /-- A functor `F : C ⥤ D` is faithful if for each `X Y : C`, `F.map` is injective.
 
 See <https://stacks.math.columbia.edu/tag/001C>.

c3291da4

bump to nightly-2023-09-06-06

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

f3106448

Diff

@@ -52,8 +52,6 @@ class Full (F : C ⥤ D) where
 #align category_theory.full CategoryTheory.Full
 -/
 
-restate_axiom full.witness'
-
 attribute [simp] full.witness
 
 #print CategoryTheory.Faithful /-
@@ -67,8 +65,6 @@ class Faithful (F : C ⥤ D) : Prop where
 #align category_theory.faithful CategoryTheory.Faithful
 -/
 
-restate_axiom faithful.map_injective'
-
 namespace Functor
 
 variable {X Y : C}

c3291da4

bump to nightly-2023-08-25-23

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

3290f295

Diff

@@ -390,7 +390,7 @@ theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G]
   by
   cases' F with F_obj _ _ _; cases' G with G_obj _ _ _
   unfold faithful.div Functor.Comp
-  unfold_projs at h_obj 
+  unfold_projs  at h_obj 
   have : F_obj = G_obj ∘ obj := (funext h_obj).symm
   subst this
   congr

c3291da4

bump to nightly-2023-08-23-23

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

f612b9e0

Diff

@@ -339,7 +339,7 @@ theorem Faithful.of_comp_iso {H : C ⥤ E} [ℋ : Faithful H] (h : F ⋙ G ≅ H
 #align category_theory.faithful.of_comp_iso CategoryTheory.Faithful.of_comp_iso
 -/
 
-alias faithful.of_comp_iso ← _root_.category_theory.iso.faithful_of_comp
+alias _root_.category_theory.iso.faithful_of_comp := faithful.of_comp_iso
 #align category_theory.iso.faithful_of_comp CategoryTheory.Iso.faithful_of_comp
 
 #print CategoryTheory.Faithful.of_comp_eq /-
@@ -350,7 +350,7 @@ theorem Faithful.of_comp_eq {H : C ⥤ E} [ℋ : Faithful H] (h : F ⋙ G = H) :
 #align category_theory.faithful.of_comp_eq CategoryTheory.Faithful.of_comp_eq
 -/
 
-alias faithful.of_comp_eq ← _root_.eq.faithful_of_comp
+alias _root_.eq.faithful_of_comp := faithful.of_comp_eq
 #align eq.faithful_of_comp Eq.faithful_of_comp
 
 variable (F G)

c3291da4

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module category_theory.functor.fully_faithful
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.NaturalIsomorphism
 import Mathbin.Logic.Equiv.Defs
 
+#align_import category_theory.functor.fully_faithful from "leanprover-community/mathlib"@"c3291da49cfa65f0d43b094750541c0731edc932"
+
 /-!
 # Full and faithful functors

c3291da4

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -60,7 +60,7 @@ restate_axiom full.witness'
 attribute [simp] full.witness
 
 #print CategoryTheory.Faithful /-
-/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
 /-- A functor `F : C ⥤ D` is faithful if for each `X Y : C`, `F.map` is injective.
 
 See <https://stacks.math.columbia.edu/tag/001C>.
@@ -76,40 +76,54 @@ namespace Functor
 
 variable {X Y : C}
 
+#print CategoryTheory.Functor.map_injective /-
 theorem map_injective (F : C ⥤ D) [Faithful F] : Function.Injective <| @Functor.map _ _ _ _ F X Y :=
   Faithful.map_injective F
 #align category_theory.functor.map_injective CategoryTheory.Functor.map_injective
+-/
 
+#print CategoryTheory.Functor.mapIso_injective /-
 theorem mapIso_injective (F : C ⥤ D) [Faithful F] :
     Function.Injective <| @Functor.mapIso _ _ _ _ F X Y := fun i j h =>
   Iso.ext (map_injective F (congr_arg Iso.hom h : _))
 #align category_theory.functor.map_iso_injective CategoryTheory.Functor.mapIso_injective
+-/
 
+#print CategoryTheory.Functor.preimage /-
 /-- The specified preimage of a morphism under a full functor. -/
 def preimage (F : C ⥤ D) [Full F] (f : F.obj X ⟶ F.obj Y) : X ⟶ Y :=
   Full.preimage.{v₁, v₂} f
 #align category_theory.functor.preimage CategoryTheory.Functor.preimage
+-/
 
+#print CategoryTheory.Functor.image_preimage /-
 @[simp]
 theorem image_preimage (F : C ⥤ D) [Full F] {X Y : C} (f : F.obj X ⟶ F.obj Y) :
     F.map (preimage F f) = f := by unfold preimage <;> obviously
 #align category_theory.functor.image_preimage CategoryTheory.Functor.image_preimage
+-/
 
+#print CategoryTheory.Functor.map_surjective /-
 theorem map_surjective (F : C ⥤ D) [Full F] : Function.Surjective (@Functor.map _ _ _ _ F X Y) :=
   fun f => ⟨F.preimage f, F.image_preimage f⟩
 #align category_theory.functor.map_surjective CategoryTheory.Functor.map_surjective
+-/
 
+#print CategoryTheory.Functor.fullOfExists /-
 /-- Deduce that `F` is full from the existence of preimages, using choice. -/
 noncomputable def fullOfExists (F : C ⥤ D)
     (h : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), ∃ p, F.map p = f) : Full F := by choose p hp using h;
   exact ⟨p, hp⟩
 #align category_theory.functor.full_of_exists CategoryTheory.Functor.fullOfExists
+-/
 
+#print CategoryTheory.Functor.fullOfSurjective /-
 /-- Deduce that `F` is full from surjectivity of `F.map`, using choice. -/
 noncomputable def fullOfSurjective (F : C ⥤ D)
     (h : ∀ X Y : C, Function.Surjective (@Functor.map _ _ _ _ F X Y)) : Full F :=
   fullOfExists _ h
 #align category_theory.functor.full_of_surjective CategoryTheory.Functor.fullOfSurjective
+-/
 
 end Functor
 
@@ -117,26 +131,33 @@ section
 
 variable {F : C ⥤ D} [Full F] [Faithful F] {X Y Z : C}
 
+#print CategoryTheory.preimage_id /-
 @[simp]
 theorem preimage_id : F.preimage (𝟙 (F.obj X)) = 𝟙 X :=
   F.map_injective (by simp)
 #align category_theory.preimage_id CategoryTheory.preimage_id
+-/
 
+#print CategoryTheory.preimage_comp /-
 @[simp]
 theorem preimage_comp (f : F.obj X ⟶ F.obj Y) (g : F.obj Y ⟶ F.obj Z) :
     F.preimage (f ≫ g) = F.preimage f ≫ F.preimage g :=
   F.map_injective (by simp)
 #align category_theory.preimage_comp CategoryTheory.preimage_comp
+-/
 
+#print CategoryTheory.preimage_map /-
 @[simp]
 theorem preimage_map (f : X ⟶ Y) : F.preimage (F.map f) = f :=
   F.map_injective (by simp)
 #align category_theory.preimage_map CategoryTheory.preimage_map
+-/
 
 variable (F)
 
 namespace Functor
 
+#print CategoryTheory.Functor.preimageIso /-
 /-- If `F : C ⥤ D` is fully faithful, every isomorphism `F.obj X ≅ F.obj Y` has a preimage. -/
 @[simps]
 def preimageIso (f : F.obj X ≅ F.obj Y) : X ≅ Y
@@ -146,6 +167,7 @@ def preimageIso (f : F.obj X ≅ F.obj Y) : X ≅ Y
   hom_inv_id' := F.map_injective (by simp)
   inv_hom_id' := F.map_injective (by simp)
 #align category_theory.functor.preimage_iso CategoryTheory.Functor.preimageIso
+-/
 
 #print CategoryTheory.Functor.preimageIso_mapIso /-
 @[simp]
@@ -155,13 +177,16 @@ theorem preimageIso_mapIso (f : X ≅ Y) : F.preimageIso (F.mapIso f) = f := by
 
 end Functor
 
+#print CategoryTheory.isIso_of_fully_faithful /-
 /-- If the image of a morphism under a fully faithful functor in an isomorphism,
 then the original morphisms is also an isomorphism.
 -/
 theorem isIso_of_fully_faithful (f : X ⟶ Y) [IsIso (F.map f)] : IsIso f :=
   ⟨⟨F.preimage (inv (F.map f)), ⟨F.map_injective (by simp), F.map_injective (by simp)⟩⟩⟩
 #align category_theory.is_iso_of_fully_faithful CategoryTheory.isIso_of_fully_faithful
+-/
 
+#print CategoryTheory.equivOfFullyFaithful /-
 /-- If `F` is fully faithful, we have an equivalence of hom-sets `X ⟶ Y` and `F X ⟶ F Y`. -/
 @[simps]
 def equivOfFullyFaithful {X Y} : (X ⟶ Y) ≃ (F.obj X ⟶ F.obj Y)
@@ -171,7 +196,9 @@ def equivOfFullyFaithful {X Y} : (X ⟶ Y) ≃ (F.obj X ⟶ F.obj Y)
   left_inv f := by simp
   right_inv f := by simp
 #align category_theory.equiv_of_fully_faithful CategoryTheory.equivOfFullyFaithful
+-/
 
+#print CategoryTheory.isoEquivOfFullyFaithful /-
 /-- If `F` is fully faithful, we have an equivalence of iso-sets `X ≅ Y` and `F X ≅ F Y`. -/
 @[simps]
 def isoEquivOfFullyFaithful {X Y} : (X ≅ Y) ≃ (F.obj X ≅ F.obj Y)
@@ -181,6 +208,7 @@ def isoEquivOfFullyFaithful {X Y} : (X ≅ Y) ≃ (F.obj X ≅ F.obj Y)
   left_inv f := by simp
   right_inv f := by ext; simp
 #align category_theory.iso_equiv_of_fully_faithful CategoryTheory.isoEquivOfFullyFaithful
+-/
 
 end
 
@@ -209,15 +237,19 @@ def natIsoOfCompFullyFaithful (i : F ⋙ H ≅ G ⋙ H) : F ≅ G :=
 #align category_theory.nat_iso_of_comp_fully_faithful CategoryTheory.natIsoOfCompFullyFaithful
 -/
 
+#print CategoryTheory.natIsoOfCompFullyFaithful_hom /-
 theorem natIsoOfCompFullyFaithful_hom (i : F ⋙ H ≅ G ⋙ H) :
     (natIsoOfCompFullyFaithful H i).Hom = natTransOfCompFullyFaithful H i.Hom := by ext;
   simp [nat_iso_of_comp_fully_faithful]
 #align category_theory.nat_iso_of_comp_fully_faithful_hom CategoryTheory.natIsoOfCompFullyFaithful_hom
+-/
 
+#print CategoryTheory.natIsoOfCompFullyFaithful_inv /-
 theorem natIsoOfCompFullyFaithful_inv (i : F ⋙ H ≅ G ⋙ H) :
     (natIsoOfCompFullyFaithful H i).inv = natTransOfCompFullyFaithful H i.inv := by ext;
   simp [← preimage_comp]; dsimp; simp
 #align category_theory.nat_iso_of_comp_fully_faithful_inv CategoryTheory.natIsoOfCompFullyFaithful_inv
+-/
 
 #print CategoryTheory.NatTrans.equivOfCompFullyFaithful /-
 /-- Horizontal composition with a fully faithful functor induces a bijection on
@@ -326,6 +358,7 @@ alias faithful.of_comp_eq ← _root_.eq.faithful_of_comp
 
 variable (F G)
 
+#print CategoryTheory.Faithful.div /-
 /-- “Divide” a functor by a faithful functor. -/
 protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C → D)
     (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
@@ -346,7 +379,9 @@ protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C →
       rw [F.map_comp, G.map_comp]
       congr 1 <;> try exact (h_obj _).symm <;> exact h_map.symm }
 #align category_theory.faithful.div CategoryTheory.Faithful.div
+-/
 
+#print CategoryTheory.Faithful.div_comp /-
 -- This follows immediately from `functor.hext` (`functor.hext h_obj @h_map`),
 -- but importing `category_theory.eq_to_hom` causes an import loop:
 -- category_theory.eq_to_hom → category_theory.opposites →
@@ -365,13 +400,16 @@ theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G]
   funext
   exact eq_of_hEq h_map
 #align category_theory.faithful.div_comp CategoryTheory.Faithful.div_comp
+-/
 
+#print CategoryTheory.Faithful.div_faithful /-
 theorem Faithful.div_faithful (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G] (obj : C → D)
     (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
     (h_map : ∀ {X Y} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)) :
     Faithful (Faithful.div F G obj @h_obj @map @h_map) :=
   (Faithful.div_comp F G _ h_obj _ @h_map).faithful_of_comp
 #align category_theory.faithful.div_faithful CategoryTheory.Faithful.div_faithful
+-/
 
 #print CategoryTheory.Full.comp /-
 instance Full.comp [Full F] [Full G] : Full (F ⋙ G)
@@ -407,19 +445,23 @@ def fullyFaithfulCancelRight {F G : C ⥤ D} (H : D ⥤ E) [Full H] [Faithful H]
 #align category_theory.fully_faithful_cancel_right CategoryTheory.fullyFaithfulCancelRight
 -/
 
+#print CategoryTheory.fullyFaithfulCancelRight_hom_app /-
 @[simp]
 theorem fullyFaithfulCancelRight_hom_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [Faithful H]
     (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
     (fullyFaithfulCancelRight H comp_iso).Hom.app X = H.preimage (comp_iso.Hom.app X) :=
   rfl
 #align category_theory.fully_faithful_cancel_right_hom_app CategoryTheory.fullyFaithfulCancelRight_hom_app
+-/
 
+#print CategoryTheory.fullyFaithfulCancelRight_inv_app /-
 @[simp]
 theorem fullyFaithfulCancelRight_inv_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [Faithful H]
     (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
     (fullyFaithfulCancelRight H comp_iso).inv.app X = H.preimage (comp_iso.inv.app X) :=
   rfl
 #align category_theory.fully_faithful_cancel_right_inv_app CategoryTheory.fullyFaithfulCancelRight_inv_app
+-/
 
 end CategoryTheory

c3291da4

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -60,7 +60,7 @@ restate_axiom full.witness'
 attribute [simp] full.witness
 
 #print CategoryTheory.Faithful /-
-/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:394:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
 /-- A functor `F : C ⥤ D` is faithful if for each `X Y : C`, `F.map` is injective.
 
 See <https://stacks.math.columbia.edu/tag/001C>.
@@ -358,7 +358,7 @@ theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G]
   by
   cases' F with F_obj _ _ _; cases' G with G_obj _ _ _
   unfold faithful.div Functor.Comp
-  unfold_projs  at h_obj 
+  unfold_projs at h_obj 
   have : F_obj = G_obj ∘ obj := (funext h_obj).symm
   subst this
   congr

c3291da4

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -358,7 +358,7 @@ theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G]
   by
   cases' F with F_obj _ _ _; cases' G with G_obj _ _ _
   unfold faithful.div Functor.Comp
-  unfold_projs  at h_obj
+  unfold_projs  at h_obj 
   have : F_obj = G_obj ∘ obj := (funext h_obj).symm
   subst this
   congr

c3291da4

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -76,77 +76,35 @@ namespace Functor
 
 variable {X Y : C}
 
-/- warning: category_theory.functor.map_injective -> CategoryTheory.Functor.map_injective 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] {X : C} {Y : C} (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F], Function.Injective.{succ u1, succ u2} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (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 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)
-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] {X : C} {Y : C} (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F], Function.Injective.{succ u1, succ u2} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (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) 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)
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.map_injective CategoryTheory.Functor.map_injectiveₓ'. -/
 theorem map_injective (F : C ⥤ D) [Faithful F] : Function.Injective <| @Functor.map _ _ _ _ F X Y :=
   Faithful.map_injective F
 #align category_theory.functor.map_injective CategoryTheory.Functor.map_injective
 
-/- warning: category_theory.functor.map_iso_injective -> CategoryTheory.Functor.mapIso_injective 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] {X : C} {Y : C} (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F], Function.Injective.{succ u1, succ u2} (CategoryTheory.Iso.{u1, u3} C _inst_1 X Y) (CategoryTheory.Iso.{u2, u4} D _inst_2 (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.mapIso.{u1, u3, u4, u2} C _inst_1 D _inst_2 F X 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] {X : C} {Y : C} (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F], Function.Injective.{succ u1, succ u2} (CategoryTheory.Iso.{u1, u3} C _inst_1 X Y) (CategoryTheory.Iso.{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.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)) (CategoryTheory.Functor.mapIso.{u1, u3, u4, u2} C _inst_1 D _inst_2 F X Y)
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.map_iso_injective CategoryTheory.Functor.mapIso_injectiveₓ'. -/
 theorem mapIso_injective (F : C ⥤ D) [Faithful F] :
     Function.Injective <| @Functor.mapIso _ _ _ _ F X Y := fun i j h =>
   Iso.ext (map_injective F (congr_arg Iso.hom h : _))
 #align category_theory.functor.map_iso_injective CategoryTheory.Functor.mapIso_injective
 
-/- warning: category_theory.functor.preimage -> CategoryTheory.Functor.preimage 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] {X : C} {Y : C} (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F], (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 X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F Y)) -> (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X 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] {X : C} {Y : C} (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F], (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) 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)) -> (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y)
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.preimage CategoryTheory.Functor.preimageₓ'. -/
 /-- The specified preimage of a morphism under a full functor. -/
 def preimage (F : C ⥤ D) [Full F] (f : F.obj X ⟶ F.obj Y) : X ⟶ Y :=
   Full.preimage.{v₁, v₂} f
 #align category_theory.functor.preimage CategoryTheory.Functor.preimage
 
-/- warning: category_theory.functor.image_preimage -> CategoryTheory.Functor.image_preimage 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.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C} {Y : C} (f : 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 X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F 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 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 (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 X Y F _inst_3 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] (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C} {Y : C} (f : 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) 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)), 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) 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 (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 X Y F _inst_3 f)) f
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.image_preimage CategoryTheory.Functor.image_preimageₓ'. -/
 @[simp]
 theorem image_preimage (F : C ⥤ D) [Full F] {X Y : C} (f : F.obj X ⟶ F.obj Y) :
     F.map (preimage F f) = f := by unfold preimage <;> obviously
 #align category_theory.functor.image_preimage CategoryTheory.Functor.image_preimage
 
-/- warning: category_theory.functor.map_surjective -> CategoryTheory.Functor.map_surjective 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] {X : C} {Y : C} (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F], Function.Surjective.{succ u1, succ u2} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (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 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)
-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] {X : C} {Y : C} (F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F], Function.Surjective.{succ u1, succ u2} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (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) 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)
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.map_surjective CategoryTheory.Functor.map_surjectiveₓ'. -/
 theorem map_surjective (F : C ⥤ D) [Full F] : Function.Surjective (@Functor.map _ _ _ _ F X Y) :=
   fun f => ⟨F.preimage f, F.image_preimage f⟩
 #align category_theory.functor.map_surjective CategoryTheory.Functor.map_surjective
 
-/- warning: category_theory.functor.full_of_exists -> CategoryTheory.Functor.fullOfExists 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), (forall (X : C) (Y : C) (f : 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 X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F Y)), Exists.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (fun (p : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) 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 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 p) f)) -> (CategoryTheory.Full.{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.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2), (forall (X : C) (Y : C) (f : 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) 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)), Exists.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (fun (p : Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) 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) 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 p) f)) -> (CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F)
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.full_of_exists CategoryTheory.Functor.fullOfExistsₓ'. -/
 /-- Deduce that `F` is full from the existence of preimages, using choice. -/
 noncomputable def fullOfExists (F : C ⥤ D)
     (h : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), ∃ p, F.map p = f) : Full F := by choose p hp using h;
   exact ⟨p, hp⟩
 #align category_theory.functor.full_of_exists CategoryTheory.Functor.fullOfExists
 
-/- warning: category_theory.functor.full_of_surjective -> CategoryTheory.Functor.fullOfSurjective 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), (forall (X : C) (Y : C), Function.Surjective.{succ u1, succ u2} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (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 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)) -> (CategoryTheory.Full.{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.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2), (forall (X : C) (Y : C), Function.Surjective.{succ u1, succ u2} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (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) 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)) -> (CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F)
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.full_of_surjective CategoryTheory.Functor.fullOfSurjectiveₓ'. -/
 /-- Deduce that `F` is full from surjectivity of `F.map`, using choice. -/
 noncomputable def fullOfSurjective (F : C ⥤ D)
     (h : ∀ X Y : C, Function.Surjective (@Functor.map _ _ _ _ F X Y)) : Full F :=
@@ -159,35 +117,17 @@ section
 
 variable {F : C ⥤ D} [Full F] [Faithful F] {X Y Z : C}
 
-/- warning: category_theory.preimage_id -> CategoryTheory.preimage_id 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.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C}, Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X X) (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 X X F _inst_3 (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))) (CategoryTheory.CategoryStruct.id.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) 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} [_inst_3 : CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C}, Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X X) (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 X X F _inst_3 (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))) (CategoryTheory.CategoryStruct.id.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X)
-Case conversion may be inaccurate. Consider using '#align category_theory.preimage_id CategoryTheory.preimage_idₓ'. -/
 @[simp]
 theorem preimage_id : F.preimage (𝟙 (F.obj X)) = 𝟙 X :=
   F.map_injective (by simp)
 #align category_theory.preimage_id CategoryTheory.preimage_id
 
-/- warning: category_theory.preimage_comp -> CategoryTheory.preimage_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] {F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2} [_inst_3 : CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C} {Y : C} {Z : C} (f : 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 X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F Y)) (g : 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 Y) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F Z)), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Z) (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 X Z F _inst_3 (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 X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F Y) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F Z) f g)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y Z (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 X Y F _inst_3 f) (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 Y Z F _inst_3 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] {F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2} [_inst_3 : CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C} {Y : C} {Z : C} (f : 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) 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)) (g : 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) Y) (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) Z)), Eq.{succ u1} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Z) (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 X Z F _inst_3 (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) 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.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) Z) f g)) (CategoryTheory.CategoryStruct.comp.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1) X Y Z (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 X Y F _inst_3 f) (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 Y Z F _inst_3 g))
-Case conversion may be inaccurate. Consider using '#align category_theory.preimage_comp CategoryTheory.preimage_compₓ'. -/
 @[simp]
 theorem preimage_comp (f : F.obj X ⟶ F.obj Y) (g : F.obj Y ⟶ F.obj Z) :
     F.preimage (f ≫ g) = F.preimage f ≫ F.preimage g :=
   F.map_injective (by simp)
 #align category_theory.preimage_comp CategoryTheory.preimage_comp
 
-/- warning: category_theory.preimage_map -> CategoryTheory.preimage_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.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{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)) X Y) (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 X Y F _inst_3 (CategoryTheory.Functor.map.{u1, u2, u3, u4} C _inst_1 D _inst_2 F 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] {F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2} [_inst_3 : CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{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)) X Y) (CategoryTheory.Functor.preimage.{u1, u2, u3, u4} C _inst_1 D _inst_2 X Y F _inst_3 (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)) f
-Case conversion may be inaccurate. Consider using '#align category_theory.preimage_map CategoryTheory.preimage_mapₓ'. -/
 @[simp]
 theorem preimage_map (f : X ⟶ Y) : F.preimage (F.map f) = f :=
   F.map_injective (by simp)
@@ -197,12 +137,6 @@ variable (F)
 
 namespace Functor
 
-/- warning: category_theory.functor.preimage_iso -> CategoryTheory.Functor.preimageIso 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.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C} {Y : C}, (CategoryTheory.Iso.{u2, u4} D _inst_2 (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.Iso.{u1, u3} C _inst_1 X 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.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C} {Y : C}, (CategoryTheory.Iso.{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.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)) -> (CategoryTheory.Iso.{u1, u3} C _inst_1 X Y)
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.preimage_iso CategoryTheory.Functor.preimageIsoₓ'. -/
 /-- If `F : C ⥤ D` is fully faithful, every isomorphism `F.obj X ≅ F.obj Y` has a preimage. -/
 @[simps]
 def preimageIso (f : F.obj X ≅ F.obj Y) : X ≅ Y
@@ -221,12 +155,6 @@ theorem preimageIso_mapIso (f : X ≅ Y) : F.preimageIso (F.mapIso f) = f := by
 
 end Functor
 
-/- warning: category_theory.is_iso_of_fully_faithful -> CategoryTheory.isIso_of_fully_faithful 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.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{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) [_inst_5 : CategoryTheory.IsIso.{u2, u4} D _inst_2 (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.IsIso.{u1, u3} C _inst_1 X Y 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.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) [_inst_3 : CategoryTheory.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{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) [_inst_5 : CategoryTheory.IsIso.{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.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.IsIso.{u1, u3} C _inst_1 X Y f
-Case conversion may be inaccurate. Consider using '#align category_theory.is_iso_of_fully_faithful CategoryTheory.isIso_of_fully_faithfulₓ'. -/
 /-- If the image of a morphism under a fully faithful functor in an isomorphism,
 then the original morphisms is also an isomorphism.
 -/
@@ -234,12 +162,6 @@ theorem isIso_of_fully_faithful (f : X ⟶ Y) [IsIso (F.map f)] : IsIso f :=
   ⟨⟨F.preimage (inv (F.map f)), ⟨F.map_injective (by simp), F.map_injective (by simp)⟩⟩⟩
 #align category_theory.is_iso_of_fully_faithful CategoryTheory.isIso_of_fully_faithful
 
-/- warning: category_theory.equiv_of_fully_faithful -> CategoryTheory.equivOfFullyFaithful 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.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C} {Y : C}, Equiv.{succ u1, succ u2} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (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 X) (CategoryTheory.Functor.obj.{u1, u2, u3, u4} C _inst_1 D _inst_2 F 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.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C} {Y : C}, Equiv.{succ u1, succ u2} (Quiver.Hom.{succ u1, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} C (CategoryTheory.Category.toCategoryStruct.{u1, u3} C _inst_1)) X Y) (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) 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))
-Case conversion may be inaccurate. Consider using '#align category_theory.equiv_of_fully_faithful CategoryTheory.equivOfFullyFaithfulₓ'. -/
 /-- If `F` is fully faithful, we have an equivalence of hom-sets `X ⟶ Y` and `F X ⟶ F Y`. -/
 @[simps]
 def equivOfFullyFaithful {X Y} : (X ⟶ Y) ≃ (F.obj X ⟶ F.obj Y)
@@ -250,12 +172,6 @@ def equivOfFullyFaithful {X Y} : (X ⟶ Y) ≃ (F.obj X ⟶ F.obj Y)
   right_inv f := by simp
 #align category_theory.equiv_of_fully_faithful CategoryTheory.equivOfFullyFaithful
 
-/- warning: category_theory.iso_equiv_of_fully_faithful -> CategoryTheory.isoEquivOfFullyFaithful 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.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C} {Y : C}, Equiv.{succ u1, succ u2} (CategoryTheory.Iso.{u1, u3} C _inst_1 X Y) (CategoryTheory.Iso.{u2, u4} D _inst_2 (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))
-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.Full.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] [_inst_4 : CategoryTheory.Faithful.{u1, u2, u3, u4} C _inst_1 D _inst_2 F] {X : C} {Y : C}, Equiv.{succ u1, succ u2} (CategoryTheory.Iso.{u1, u3} C _inst_1 X Y) (CategoryTheory.Iso.{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.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))
-Case conversion may be inaccurate. Consider using '#align category_theory.iso_equiv_of_fully_faithful CategoryTheory.isoEquivOfFullyFaithfulₓ'. -/
 /-- If `F` is fully faithful, we have an equivalence of iso-sets `X ≅ Y` and `F X ≅ F Y`. -/
 @[simps]
 def isoEquivOfFullyFaithful {X Y} : (X ≅ Y) ≃ (F.obj X ≅ F.obj Y)
@@ -293,23 +209,11 @@ def natIsoOfCompFullyFaithful (i : F ⋙ H ≅ G ⋙ H) : F ≅ G :=
 #align category_theory.nat_iso_of_comp_fully_faithful CategoryTheory.natIsoOfCompFullyFaithful
 -/
 
-/- warning: category_theory.nat_iso_of_comp_fully_faithful_hom -> CategoryTheory.natIsoOfCompFullyFaithful_hom 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 : Type.{u5}} [_inst_3 : CategoryTheory.Category.{u6, u5} E] {F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2} (H : CategoryTheory.Functor.{u2, u6, u4, u5} D _inst_2 E _inst_3) [_inst_4 : CategoryTheory.Full.{u2, u6, u4, u5} D _inst_2 E _inst_3 H] [_inst_5 : CategoryTheory.Faithful.{u2, u6, u4, u5} D _inst_2 E _inst_3 H] (i : CategoryTheory.Iso.{max u3 u6, max u1 u6 u3 u5} (CategoryTheory.Functor.{u1, u6, u3, u5} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u6, u3, u5} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u1, u2, u6, u3, u4, u5} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u1, u2, u6, u3, u4, u5} C _inst_1 D _inst_2 E _inst_3 G H)), Eq.{succ (max u3 u2)} (Quiver.Hom.{succ (max u3 u2), max u1 u2 u3 u4} (CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u3 u2, max u1 u2 u3 u4} (CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u3 u2, max u1 u2 u3 u4} (CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u2, u3, u4} C _inst_1 D _inst_2))) F G) (CategoryTheory.Iso.hom.{max u3 u2, max u1 u2 u3 u4} (CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u2, u3, u4} C _inst_1 D _inst_2) F G (CategoryTheory.natIsoOfCompFullyFaithful.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 i)) (CategoryTheory.natTransOfCompFullyFaithful.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 (CategoryTheory.Iso.hom.{max u3 u6, max u1 u6 u3 u5} (CategoryTheory.Functor.{u1, u6, u3, u5} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u6, u3, u5} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u1, u2, u6, u3, u4, u5} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u1, u2, u6, u3, u4, u5} C _inst_1 D _inst_2 E _inst_3 G H) i))
-but is expected to have type
-  forall {C : Type.{u5}} [_inst_1 : CategoryTheory.Category.{u3, u5} C] {D : Type.{u6}} [_inst_2 : CategoryTheory.Category.{u4, u6} D] {E : Type.{u1}} [_inst_3 : CategoryTheory.Category.{u2, u1} E] {F : CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2} (H : CategoryTheory.Functor.{u4, u2, u6, u1} D _inst_2 E _inst_3) [_inst_4 : CategoryTheory.Full.{u4, u2, u6, u1} D _inst_2 E _inst_3 H] [_inst_5 : CategoryTheory.Faithful.{u4, u2, u6, u1} D _inst_2 E _inst_3 H] (i : CategoryTheory.Iso.{max u5 u2, max (max (max u1 u5) u2) u3} (CategoryTheory.Functor.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 G H)), Eq.{max (succ u5) (succ u4)} (Quiver.Hom.{succ (max u5 u4), max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u3, u4, u5, u6} C _inst_1 D _inst_2))) F G) (CategoryTheory.Iso.hom.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u3, u4, u5, u6} C _inst_1 D _inst_2) F G (CategoryTheory.natIsoOfCompFullyFaithful.{u3, u4, u5, u6, u1, u2} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 i)) (CategoryTheory.natTransOfCompFullyFaithful.{u3, u4, u5, u6, u1, u2} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 (CategoryTheory.Iso.hom.{max u5 u2, max (max (max u5 u3) u1) u2} (CategoryTheory.Functor.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 G H) i))
-Case conversion may be inaccurate. Consider using '#align category_theory.nat_iso_of_comp_fully_faithful_hom CategoryTheory.natIsoOfCompFullyFaithful_homₓ'. -/
 theorem natIsoOfCompFullyFaithful_hom (i : F ⋙ H ≅ G ⋙ H) :
     (natIsoOfCompFullyFaithful H i).Hom = natTransOfCompFullyFaithful H i.Hom := by ext;
   simp [nat_iso_of_comp_fully_faithful]
 #align category_theory.nat_iso_of_comp_fully_faithful_hom CategoryTheory.natIsoOfCompFullyFaithful_hom
 
-/- warning: category_theory.nat_iso_of_comp_fully_faithful_inv -> CategoryTheory.natIsoOfCompFullyFaithful_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 : Type.{u5}} [_inst_3 : CategoryTheory.Category.{u6, u5} E] {F : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2} (H : CategoryTheory.Functor.{u2, u6, u4, u5} D _inst_2 E _inst_3) [_inst_4 : CategoryTheory.Full.{u2, u6, u4, u5} D _inst_2 E _inst_3 H] [_inst_5 : CategoryTheory.Faithful.{u2, u6, u4, u5} D _inst_2 E _inst_3 H] (i : CategoryTheory.Iso.{max u3 u6, max u1 u6 u3 u5} (CategoryTheory.Functor.{u1, u6, u3, u5} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u6, u3, u5} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u1, u2, u6, u3, u4, u5} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u1, u2, u6, u3, u4, u5} C _inst_1 D _inst_2 E _inst_3 G H)), Eq.{succ (max u3 u2)} (Quiver.Hom.{succ (max u3 u2), max u1 u2 u3 u4} (CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u3 u2, max u1 u2 u3 u4} (CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u3 u2, max u1 u2 u3 u4} (CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u2, u3, u4} C _inst_1 D _inst_2))) G F) (CategoryTheory.Iso.inv.{max u3 u2, max u1 u2 u3 u4} (CategoryTheory.Functor.{u1, u2, u3, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u2, u3, u4} C _inst_1 D _inst_2) F G (CategoryTheory.natIsoOfCompFullyFaithful.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 i)) (CategoryTheory.natTransOfCompFullyFaithful.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G F H _inst_4 _inst_5 (CategoryTheory.Iso.inv.{max u3 u6, max u1 u6 u3 u5} (CategoryTheory.Functor.{u1, u6, u3, u5} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u1, u6, u3, u5} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u1, u2, u6, u3, u4, u5} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u1, u2, u6, u3, u4, u5} C _inst_1 D _inst_2 E _inst_3 G H) i))
-but is expected to have type
-  forall {C : Type.{u5}} [_inst_1 : CategoryTheory.Category.{u3, u5} C] {D : Type.{u6}} [_inst_2 : CategoryTheory.Category.{u4, u6} D] {E : Type.{u1}} [_inst_3 : CategoryTheory.Category.{u2, u1} E] {F : CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2} (H : CategoryTheory.Functor.{u4, u2, u6, u1} D _inst_2 E _inst_3) [_inst_4 : CategoryTheory.Full.{u4, u2, u6, u1} D _inst_2 E _inst_3 H] [_inst_5 : CategoryTheory.Faithful.{u4, u2, u6, u1} D _inst_2 E _inst_3 H] (i : CategoryTheory.Iso.{max u5 u2, max (max (max u1 u5) u2) u3} (CategoryTheory.Functor.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 G H)), Eq.{max (succ u5) (succ u4)} (Quiver.Hom.{succ (max u5 u4), max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u3, u4, u5, u6} C _inst_1 D _inst_2))) G F) (CategoryTheory.Iso.inv.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u3, u4, u5, u6} C _inst_1 D _inst_2) F G (CategoryTheory.natIsoOfCompFullyFaithful.{u3, u4, u5, u6, u1, u2} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 i)) (CategoryTheory.natTransOfCompFullyFaithful.{u3, u4, u5, u6, u1, u2} C _inst_1 D _inst_2 E _inst_3 G F H _inst_4 _inst_5 (CategoryTheory.Iso.inv.{max u5 u2, max (max (max u5 u3) u1) u2} (CategoryTheory.Functor.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 G H) i))
-Case conversion may be inaccurate. Consider using '#align category_theory.nat_iso_of_comp_fully_faithful_inv CategoryTheory.natIsoOfCompFullyFaithful_invₓ'. -/
 theorem natIsoOfCompFullyFaithful_inv (i : F ⋙ H ≅ G ⋙ H) :
     (natIsoOfCompFullyFaithful H i).inv = natTransOfCompFullyFaithful H i.inv := by ext;
   simp [← preimage_comp]; dsimp; simp
@@ -422,12 +326,6 @@ alias faithful.of_comp_eq ← _root_.eq.faithful_of_comp
 
 variable (F G)
 
-/- warning: category_theory.faithful.div -> CategoryTheory.Faithful.div 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] (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (G : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) [_inst_4 : CategoryTheory.Faithful.{u2, u3, u5, u6} D _inst_2 E _inst_3 G] (obj : C -> D), (forall (X : C), Eq.{succ u6} E (CategoryTheory.Functor.obj.{u2, u3, u5, u6} D _inst_2 E _inst_3 G (obj X)) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} C _inst_1 E _inst_3 F X)) -> (forall (map : forall {X : C} {Y : C}, (Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y) -> (Quiver.Hom.{succ u2, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (obj X) (obj Y))), (forall {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y}, HEq.{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 G (obj X)) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} D _inst_2 E _inst_3 G (obj Y))) (CategoryTheory.Functor.map.{u2, u3, u5, u6} D _inst_2 E _inst_3 G (obj X) (obj Y) (map X Y f)) (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 F Y)) (CategoryTheory.Functor.map.{u1, u3, u4, u6} C _inst_1 E _inst_3 F X Y f)) -> (CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 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] (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) (G : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) [_inst_4 : CategoryTheory.Faithful.{u2, u3, u5, u6} D _inst_2 E _inst_3 G] (obj : C -> D), (forall (X : C), Eq.{succ u6} E (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 G) (obj 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)) -> (forall (map : forall {X : C} {Y : C}, (Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y) -> (Quiver.Hom.{succ u2, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (obj X) (obj Y))), (forall {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y}, HEq.{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 G) (obj 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 G) (obj Y))) (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 G) (obj X) (obj Y) (map X Y f)) (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 F) Y)) (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) X Y f)) -> (CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2))
-Case conversion may be inaccurate. Consider using '#align category_theory.faithful.div CategoryTheory.Faithful.divₓ'. -/
 /-- “Divide” a functor by a faithful functor. -/
 protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C → D)
     (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
@@ -449,9 +347,6 @@ protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C →
       congr 1 <;> try exact (h_obj _).symm <;> exact h_map.symm }
 #align category_theory.faithful.div CategoryTheory.Faithful.div
 
-/- warning: category_theory.faithful.div_comp -> CategoryTheory.Faithful.div_comp is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.faithful.div_comp CategoryTheory.Faithful.div_compₓ'. -/
 -- This follows immediately from `functor.hext` (`functor.hext h_obj @h_map`),
 -- but importing `category_theory.eq_to_hom` causes an import loop:
 -- category_theory.eq_to_hom → category_theory.opposites →
@@ -471,9 +366,6 @@ theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G]
   exact eq_of_hEq h_map
 #align category_theory.faithful.div_comp CategoryTheory.Faithful.div_comp
 
-/- warning: category_theory.faithful.div_faithful -> CategoryTheory.Faithful.div_faithful is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.faithful.div_faithful CategoryTheory.Faithful.div_faithfulₓ'. -/
 theorem Faithful.div_faithful (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G] (obj : C → D)
     (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
     (h_map : ∀ {X Y} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)) :
@@ -515,12 +407,6 @@ def fullyFaithfulCancelRight {F G : C ⥤ D} (H : D ⥤ E) [Full H] [Faithful H]
 #align category_theory.fully_faithful_cancel_right CategoryTheory.fullyFaithfulCancelRight
 -/
 
-/- warning: category_theory.fully_faithful_cancel_right_hom_app -> CategoryTheory.fullyFaithfulCancelRight_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] {F : CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2} {H : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3} [_inst_4 : CategoryTheory.Full.{u2, u3, u5, u6} D _inst_2 E _inst_3 H] [_inst_5 : CategoryTheory.Faithful.{u2, u3, u5, u6} D _inst_2 E _inst_3 H] (comp_iso : 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 F H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G H)) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 F X) (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 G X)) (CategoryTheory.NatTrans.app.{u1, u2, u4, u5} C _inst_1 D _inst_2 F G (CategoryTheory.Iso.hom.{max u4 u2, max u1 u2 u4 u5} (CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u2, u4, u5} C _inst_1 D _inst_2) F G (CategoryTheory.fullyFaithfulCancelRight.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 comp_iso)) X) (CategoryTheory.Functor.preimage.{u2, u3, u5, u6} D _inst_2 E _inst_3 (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 F X) (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 G X) H _inst_4 (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 F H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G H) (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 F H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G H) comp_iso) 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] {F : CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2} {H : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3} [_inst_4 : CategoryTheory.Full.{u2, u3, u5, u6} D _inst_2 E _inst_3 H] [_inst_5 : CategoryTheory.Faithful.{u2, u3, u5, u6} D _inst_2 E _inst_3 H] (comp_iso : 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 F H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G H)) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u4, u5} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u4, u5} C _inst_1 D _inst_2 F) X) (Prefunctor.obj.{succ u1, succ u2, u4, u5} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u4, u5} C _inst_1 D _inst_2 G) X)) (CategoryTheory.NatTrans.app.{u1, u2, u4, u5} C _inst_1 D _inst_2 F G (CategoryTheory.Iso.hom.{max u4 u2, max (max (max u4 u5) u1) u2} (CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u2, u4, u5} C _inst_1 D _inst_2) F G (CategoryTheory.fullyFaithfulCancelRight.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 comp_iso)) X) (CategoryTheory.Functor.preimage.{u2, u3, u5, u6} D _inst_2 E _inst_3 (Prefunctor.obj.{succ u1, succ u2, u4, u5} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u4, u5} C _inst_1 D _inst_2 F) X) (Prefunctor.obj.{succ u1, succ u2, u4, u5} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u4, u5} C _inst_1 D _inst_2 G) X) H _inst_4 (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 F H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G H) (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 F H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G H) comp_iso) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.fully_faithful_cancel_right_hom_app CategoryTheory.fullyFaithfulCancelRight_hom_appₓ'. -/
 @[simp]
 theorem fullyFaithfulCancelRight_hom_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [Faithful H]
     (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
@@ -528,12 +414,6 @@ theorem fullyFaithfulCancelRight_hom_app {F G : C ⥤ D} {H : D ⥤ E} [Full H]
   rfl
 #align category_theory.fully_faithful_cancel_right_hom_app CategoryTheory.fullyFaithfulCancelRight_hom_app
 
-/- warning: category_theory.fully_faithful_cancel_right_inv_app -> CategoryTheory.fullyFaithfulCancelRight_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] {F : CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2} {H : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3} [_inst_4 : CategoryTheory.Full.{u2, u3, u5, u6} D _inst_2 E _inst_3 H] [_inst_5 : CategoryTheory.Faithful.{u2, u3, u5, u6} D _inst_2 E _inst_3 H] (comp_iso : 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 F H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G H)) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 G X) (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 F X)) (CategoryTheory.NatTrans.app.{u1, u2, u4, u5} C _inst_1 D _inst_2 G F (CategoryTheory.Iso.inv.{max u4 u2, max u1 u2 u4 u5} (CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u2, u4, u5} C _inst_1 D _inst_2) F G (CategoryTheory.fullyFaithfulCancelRight.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 comp_iso)) X) (CategoryTheory.Functor.preimage.{u2, u3, u5, u6} D _inst_2 E _inst_3 (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 G X) (CategoryTheory.Functor.obj.{u1, u2, u4, u5} C _inst_1 D _inst_2 F X) H _inst_4 (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 G H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F H) (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 F H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G H) comp_iso) 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] {F : CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2} {H : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3} [_inst_4 : CategoryTheory.Full.{u2, u3, u5, u6} D _inst_2 E _inst_3 H] [_inst_5 : CategoryTheory.Faithful.{u2, u3, u5, u6} D _inst_2 E _inst_3 H] (comp_iso : 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 F H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G H)) (X : C), Eq.{succ u2} (Quiver.Hom.{succ u2, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (Prefunctor.obj.{succ u1, succ u2, u4, u5} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u4, u5} C _inst_1 D _inst_2 G) X) (Prefunctor.obj.{succ u1, succ u2, u4, u5} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u4, u5} C _inst_1 D _inst_2 F) X)) (CategoryTheory.NatTrans.app.{u1, u2, u4, u5} C _inst_1 D _inst_2 G F (CategoryTheory.Iso.inv.{max u4 u2, max (max (max u4 u5) u1) u2} (CategoryTheory.Functor.{u1, u2, u4, u5} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u2, u4, u5} C _inst_1 D _inst_2) F G (CategoryTheory.fullyFaithfulCancelRight.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 comp_iso)) X) (CategoryTheory.Functor.preimage.{u2, u3, u5, u6} D _inst_2 E _inst_3 (Prefunctor.obj.{succ u1, succ u2, u4, u5} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u4, u5} C _inst_1 D _inst_2 G) X) (Prefunctor.obj.{succ u1, succ u2, u4, u5} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u2, u4, u5} C _inst_1 D _inst_2 F) X) H _inst_4 (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 G H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F H) (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 F H) (CategoryTheory.Functor.comp.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 G H) comp_iso) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.fully_faithful_cancel_right_inv_app CategoryTheory.fullyFaithfulCancelRight_inv_appₓ'. -/
 @[simp]
 theorem fullyFaithfulCancelRight_inv_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [Faithful H]
     (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :

c3291da4

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -137,9 +137,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align category_theory.functor.full_of_exists CategoryTheory.Functor.fullOfExistsₓ'. -/
 /-- Deduce that `F` is full from the existence of preimages, using choice. -/
 noncomputable def fullOfExists (F : C ⥤ D)
-    (h : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), ∃ p, F.map p = f) : Full F :=
-  by
-  choose p hp using h
+    (h : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), ∃ p, F.map p = f) : Full F := by choose p hp using h;
   exact ⟨p, hp⟩
 #align category_theory.functor.full_of_exists CategoryTheory.Functor.fullOfExists
 
@@ -217,10 +215,7 @@ def preimageIso (f : F.obj X ≅ F.obj Y) : X ≅ Y
 
 #print CategoryTheory.Functor.preimageIso_mapIso /-
 @[simp]
-theorem preimageIso_mapIso (f : X ≅ Y) : F.preimageIso (F.mapIso f) = f :=
-  by
-  ext
-  simp
+theorem preimageIso_mapIso (f : X ≅ Y) : F.preimageIso (F.mapIso f) = f := by ext; simp
 #align category_theory.functor.preimage_iso_map_iso CategoryTheory.Functor.preimageIso_mapIso
 -/
 
@@ -268,9 +263,7 @@ def isoEquivOfFullyFaithful {X Y} : (X ≅ Y) ≃ (F.obj X ≅ F.obj Y)
   toFun f := F.mapIso f
   invFun f := F.preimageIso f
   left_inv f := by simp
-  right_inv f := by
-    ext
-    simp
+  right_inv f := by ext; simp
 #align category_theory.iso_equiv_of_fully_faithful CategoryTheory.isoEquivOfFullyFaithful
 
 end
@@ -286,10 +279,7 @@ natural transformation between those functors composed with a fully faithful fun
 def natTransOfCompFullyFaithful (α : F ⋙ H ⟶ G ⋙ H) : F ⟶ G
     where
   app X := (equivOfFullyFaithful H).symm (α.app X)
-  naturality' X Y f := by
-    dsimp
-    apply H.map_injective
-    simpa using α.naturality f
+  naturality' X Y f := by dsimp; apply H.map_injective; simpa using α.naturality f
 #align category_theory.nat_trans_of_comp_fully_faithful CategoryTheory.natTransOfCompFullyFaithful
 -/
 
@@ -298,11 +288,8 @@ def natTransOfCompFullyFaithful (α : F ⋙ H ⟶ G ⋙ H) : F ⟶ G
 between those functors composed with a fully faithful functor. -/
 @[simps]
 def natIsoOfCompFullyFaithful (i : F ⋙ H ≅ G ⋙ H) : F ≅ G :=
-  NatIso.ofComponents (fun X => (isoEquivOfFullyFaithful H).symm (i.app X)) fun X Y f =>
-    by
-    dsimp
-    apply H.map_injective
-    simpa using i.hom.naturality f
+  NatIso.ofComponents (fun X => (isoEquivOfFullyFaithful H).symm (i.app X)) fun X Y f => by dsimp;
+    apply H.map_injective; simpa using i.hom.naturality f
 #align category_theory.nat_iso_of_comp_fully_faithful CategoryTheory.natIsoOfCompFullyFaithful
 -/
 
@@ -313,9 +300,7 @@ but is expected to have type
   forall {C : Type.{u5}} [_inst_1 : CategoryTheory.Category.{u3, u5} C] {D : Type.{u6}} [_inst_2 : CategoryTheory.Category.{u4, u6} D] {E : Type.{u1}} [_inst_3 : CategoryTheory.Category.{u2, u1} E] {F : CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2} (H : CategoryTheory.Functor.{u4, u2, u6, u1} D _inst_2 E _inst_3) [_inst_4 : CategoryTheory.Full.{u4, u2, u6, u1} D _inst_2 E _inst_3 H] [_inst_5 : CategoryTheory.Faithful.{u4, u2, u6, u1} D _inst_2 E _inst_3 H] (i : CategoryTheory.Iso.{max u5 u2, max (max (max u1 u5) u2) u3} (CategoryTheory.Functor.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 G H)), Eq.{max (succ u5) (succ u4)} (Quiver.Hom.{succ (max u5 u4), max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u3, u4, u5, u6} C _inst_1 D _inst_2))) F G) (CategoryTheory.Iso.hom.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u3, u4, u5, u6} C _inst_1 D _inst_2) F G (CategoryTheory.natIsoOfCompFullyFaithful.{u3, u4, u5, u6, u1, u2} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 i)) (CategoryTheory.natTransOfCompFullyFaithful.{u3, u4, u5, u6, u1, u2} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 (CategoryTheory.Iso.hom.{max u5 u2, max (max (max u5 u3) u1) u2} (CategoryTheory.Functor.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 G H) i))
 Case conversion may be inaccurate. Consider using '#align category_theory.nat_iso_of_comp_fully_faithful_hom CategoryTheory.natIsoOfCompFullyFaithful_homₓ'. -/
 theorem natIsoOfCompFullyFaithful_hom (i : F ⋙ H ≅ G ⋙ H) :
-    (natIsoOfCompFullyFaithful H i).Hom = natTransOfCompFullyFaithful H i.Hom :=
-  by
-  ext
+    (natIsoOfCompFullyFaithful H i).Hom = natTransOfCompFullyFaithful H i.Hom := by ext;
   simp [nat_iso_of_comp_fully_faithful]
 #align category_theory.nat_iso_of_comp_fully_faithful_hom CategoryTheory.natIsoOfCompFullyFaithful_hom
 
@@ -326,12 +311,8 @@ but is expected to have type
   forall {C : Type.{u5}} [_inst_1 : CategoryTheory.Category.{u3, u5} C] {D : Type.{u6}} [_inst_2 : CategoryTheory.Category.{u4, u6} D] {E : Type.{u1}} [_inst_3 : CategoryTheory.Category.{u2, u1} E] {F : CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2} {G : CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2} (H : CategoryTheory.Functor.{u4, u2, u6, u1} D _inst_2 E _inst_3) [_inst_4 : CategoryTheory.Full.{u4, u2, u6, u1} D _inst_2 E _inst_3 H] [_inst_5 : CategoryTheory.Faithful.{u4, u2, u6, u1} D _inst_2 E _inst_3 H] (i : CategoryTheory.Iso.{max u5 u2, max (max (max u1 u5) u2) u3} (CategoryTheory.Functor.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 G H)), Eq.{max (succ u5) (succ u4)} (Quiver.Hom.{succ (max u5 u4), max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u3, u4, u5, u6} C _inst_1 D _inst_2))) G F) (CategoryTheory.Iso.inv.{max u5 u4, max (max (max u5 u6) u3) u4} (CategoryTheory.Functor.{u3, u4, u5, u6} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u3, u4, u5, u6} C _inst_1 D _inst_2) F G (CategoryTheory.natIsoOfCompFullyFaithful.{u3, u4, u5, u6, u1, u2} C _inst_1 D _inst_2 E _inst_3 F G H _inst_4 _inst_5 i)) (CategoryTheory.natTransOfCompFullyFaithful.{u3, u4, u5, u6, u1, u2} C _inst_1 D _inst_2 E _inst_3 G F H _inst_4 _inst_5 (CategoryTheory.Iso.inv.{max u5 u2, max (max (max u5 u3) u1) u2} (CategoryTheory.Functor.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.category.{u3, u2, u5, u1} C _inst_1 E _inst_3) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 F H) (CategoryTheory.Functor.comp.{u3, u4, u2, u5, u6, u1} C _inst_1 D _inst_2 E _inst_3 G H) i))
 Case conversion may be inaccurate. Consider using '#align category_theory.nat_iso_of_comp_fully_faithful_inv CategoryTheory.natIsoOfCompFullyFaithful_invₓ'. -/
 theorem natIsoOfCompFullyFaithful_inv (i : F ⋙ H ≅ G ⋙ H) :
-    (natIsoOfCompFullyFaithful H i).inv = natTransOfCompFullyFaithful H i.inv :=
-  by
-  ext
-  simp [← preimage_comp]
-  dsimp
-  simp
+    (natIsoOfCompFullyFaithful H i).inv = natTransOfCompFullyFaithful H i.inv := by ext;
+  simp [← preimage_comp]; dsimp; simp
 #align category_theory.nat_iso_of_comp_fully_faithful_inv CategoryTheory.natIsoOfCompFullyFaithful_inv
 
 #print CategoryTheory.NatTrans.equivOfCompFullyFaithful /-

c3291da4

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -469,10 +469,7 @@ protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C →
 #align category_theory.faithful.div CategoryTheory.Faithful.div
 
 /- warning: category_theory.faithful.div_comp -> CategoryTheory.Faithful.div_comp 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] (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) [_inst_4 : CategoryTheory.Faithful.{u1, u3, u4, u6} C _inst_1 E _inst_3 F] (G : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) [_inst_5 : CategoryTheory.Faithful.{u2, u3, u5, u6} D _inst_2 E _inst_3 G] (obj : C -> D) (h_obj : forall (X : C), Eq.{succ u6} E (CategoryTheory.Functor.obj.{u2, u3, u5, u6} D _inst_2 E _inst_3 G (obj X)) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} C _inst_1 E _inst_3 F X)) (map : forall {X : C} {Y : C}, (Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y) -> (Quiver.Hom.{succ u2, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (obj X) (obj Y))) (h_map : forall {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y}, HEq.{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 G (obj X)) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} D _inst_2 E _inst_3 G (obj Y))) (CategoryTheory.Functor.map.{u2, u3, u5, u6} D _inst_2 E _inst_3 G (obj X) (obj Y) (map X Y f)) (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 F Y)) (CategoryTheory.Functor.map.{u1, u3, u4, u6} C _inst_1 E _inst_3 F X Y f)), Eq.{succ (max u1 u3 u4 u6)} (CategoryTheory.Functor.{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.Faithful.div.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G _inst_5 obj h_obj map h_map) G) 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] (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) [_inst_4 : CategoryTheory.Faithful.{u1, u3, u4, u6} C _inst_1 E _inst_3 F] (G : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) [_inst_5 : CategoryTheory.Faithful.{u2, u3, u5, u6} D _inst_2 E _inst_3 G] (obj : C -> D) (h_obj : forall (X : C), Eq.{succ u6} E (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 G) (obj 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)) (map : forall {X : C} {Y : C}, (Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y) -> (Quiver.Hom.{succ u2, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (obj X) (obj Y))) (h_map : forall {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y}, HEq.{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 G) (obj 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 G) (obj Y))) (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 G) (obj X) (obj Y) (map X Y f)) (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 F) Y)) (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) X Y f)), Eq.{max (max (max (succ u4) (succ u6)) (succ u1)) (succ u3)} (CategoryTheory.Functor.{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.Faithful.div.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G _inst_5 obj h_obj map h_map) G) F
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.faithful.div_comp CategoryTheory.Faithful.div_compₓ'. -/
 -- This follows immediately from `functor.hext` (`functor.hext h_obj @h_map`),
 -- but importing `category_theory.eq_to_hom` causes an import loop:
@@ -494,10 +491,7 @@ theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G]
 #align category_theory.faithful.div_comp CategoryTheory.Faithful.div_comp
 
 /- warning: category_theory.faithful.div_faithful -> CategoryTheory.Faithful.div_faithful 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] (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) [_inst_4 : CategoryTheory.Faithful.{u1, u3, u4, u6} C _inst_1 E _inst_3 F] (G : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) [_inst_5 : CategoryTheory.Faithful.{u2, u3, u5, u6} D _inst_2 E _inst_3 G] (obj : C -> D) (h_obj : forall (X : C), Eq.{succ u6} E (CategoryTheory.Functor.obj.{u2, u3, u5, u6} D _inst_2 E _inst_3 G (obj X)) (CategoryTheory.Functor.obj.{u1, u3, u4, u6} C _inst_1 E _inst_3 F X)) (map : forall {X : C} {Y : C}, (Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y) -> (Quiver.Hom.{succ u2, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (obj X) (obj Y))) (h_map : forall {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y}, HEq.{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 G (obj X)) (CategoryTheory.Functor.obj.{u2, u3, u5, u6} D _inst_2 E _inst_3 G (obj Y))) (CategoryTheory.Functor.map.{u2, u3, u5, u6} D _inst_2 E _inst_3 G (obj X) (obj Y) (map X Y f)) (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 F Y)) (CategoryTheory.Functor.map.{u1, u3, u4, u6} C _inst_1 E _inst_3 F X Y f)), CategoryTheory.Faithful.{u1, u2, u4, u5} C _inst_1 D _inst_2 (CategoryTheory.Faithful.div.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G _inst_5 obj h_obj map h_map)
-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] (F : CategoryTheory.Functor.{u1, u3, u4, u6} C _inst_1 E _inst_3) [_inst_4 : CategoryTheory.Faithful.{u1, u3, u4, u6} C _inst_1 E _inst_3 F] (G : CategoryTheory.Functor.{u2, u3, u5, u6} D _inst_2 E _inst_3) [_inst_5 : CategoryTheory.Faithful.{u2, u3, u5, u6} D _inst_2 E _inst_3 G] (obj : C -> D) (h_obj : forall (X : C), Eq.{succ u6} E (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 G) (obj 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)) (map : forall {X : C} {Y : C}, (Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y) -> (Quiver.Hom.{succ u2, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u2, u5} D (CategoryTheory.Category.toCategoryStruct.{u2, u5} D _inst_2)) (obj X) (obj Y))) (h_map : forall {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u4} C (CategoryTheory.Category.toCategoryStruct.{u1, u4} C _inst_1)) X Y}, HEq.{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 G) (obj 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 G) (obj Y))) (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 G) (obj X) (obj Y) (map X Y f)) (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 F) Y)) (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) X Y f)), CategoryTheory.Faithful.{u1, u2, u4, u5} C _inst_1 D _inst_2 (CategoryTheory.Faithful.div.{u1, u2, u3, u4, u5, u6} C _inst_1 D _inst_2 E _inst_3 F G _inst_5 obj h_obj map h_map)
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.faithful.div_faithful CategoryTheory.Faithful.div_faithfulₓ'. -/
 theorem Faithful.div_faithful (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G] (obj : C → D)
     (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))

c3291da4

bump to nightly-2023-04-24-06

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

ff662d55

Diff

@@ -60,7 +60,7 @@ restate_axiom full.witness'
 attribute [simp] full.witness
 
 #print CategoryTheory.Faithful /-
-/- ./././Mathport/Syntax/Translate/Command.lean:388:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
+/- ./././Mathport/Syntax/Translate/Command.lean:393:30: infer kinds are unsupported in Lean 4: #[`map_injective'] [] -/
 /-- A functor `F : C ⥤ D` is faithful if for each `X Y : C`, `F.map` is injective.
 
 See <https://stacks.math.columbia.edu/tag/001C>.

c3291da4

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

70d50ecf

chore(CategoryTheory): make Functor.Full a Prop (#12449)

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>

ce289a0e

Diff

@@ -19,9 +19,7 @@ We define typeclasses `Full` and `Faithful`, decorating functors.
 * Use `F.preimage` to obtain preimages of morphisms when `[Full F]`.
 * We prove some basic "cancellation" lemmas for full and/or faithful functors, as well as a
   construction for "dividing" a functor by a faithful functor, see `Faithful.div`.
-* `Full F` carries data, so definitional properties of the preimage can be used when using
-  `F.preimage`. To obtain an instance of `Full F` non-constructively, you can use `fullOfExists`
-  and `fullOfSurjective`.
+* `Full F` carries no data.
 
 See `CategoryTheory.Equivalence.of_fullyFaithful_ess_surj` for the fact that a functor is an
 equivalence if and only if it is fully faithful and essentially surjective.
@@ -39,20 +37,12 @@ variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
 namespace Functor
 
 /-- A functor `F : C ⥤ D` is full if for each `X Y : C`, `F.map` is surjective.
-In fact, we use a constructive definition, so the `Full F` typeclass contains data,
-specifying a particular preimage of each `f : F.obj X ⟶ F.obj Y`.
 
 See <https://stacks.math.columbia.edu/tag/001C>.
 -/
-class Full (F : C ⥤ D) where
-  /-- The data of a preimage for every `f : F.obj X ⟶ F.obj Y`. -/
-  preimage : ∀ {X Y : C} (_ : F.obj X ⟶ F.obj Y), X ⟶ Y
-  /-- The property that `Full.preimage f` of maps to `f` via `F.map`. -/
-  witness : ∀ {X Y : C} (f : F.obj X ⟶ F.obj Y), F.map (preimage f) = f := by aesop_cat
+class Full (F : C ⥤ D) : Prop where
+  map_surjective {X Y : C} : Function.Surjective (F.map (X := X) (Y := Y))
 #align category_theory.full CategoryTheory.Functor.Full
-#align category_theory.full.witness CategoryTheory.Functor.Full.witness
-
-attribute [simp] Full.witness
 
 /- ./././Mathport/Syntax/Translate/Command.lean:379:30: infer kinds are unsupported in Lean 4:
 #[`map_injective'] [] -/
@@ -79,34 +69,22 @@ theorem mapIso_injective (F : C ⥤ D) [Faithful F] :
   Iso.ext (map_injective F (congr_arg Iso.hom h : _))
 #align category_theory.functor.map_iso_injective CategoryTheory.Functor.mapIso_injective
 
-/-- The specified preimage of a morphism under a full functor. -/
-@[pp_dot]
-def preimage (F : C ⥤ D) [Full F] (f : F.obj X ⟶ F.obj Y) : X ⟶ Y :=
-  Full.preimage.{v₁, v₂} f
-#align category_theory.functor.preimage CategoryTheory.Functor.preimage
-
-@[simp]
-theorem image_preimage (F : C ⥤ D) [Full F] {X Y : C} (f : F.obj X ⟶ F.obj Y) :
-    F.map (preimage F f) = f := by unfold preimage; aesop_cat
-#align category_theory.functor.image_preimage CategoryTheory.Functor.image_preimage
-
 theorem map_surjective (F : C ⥤ D) [Full F] :
     Function.Surjective (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y)) :=
-  fun f => ⟨F.preimage f, F.image_preimage f⟩
+  Full.map_surjective
 #align category_theory.functor.map_surjective CategoryTheory.Functor.map_surjective
 
-/-- Deduce that `F` is full from the existence of preimages, using choice. -/
-noncomputable def fullOfExists (F : C ⥤ D)
-    (h : ∀ (X Y : C) (f : F.obj X ⟶ F.obj Y), ∃ p, F.map p = f) : Full F := by
-  choose p hp using h
-  exact ⟨@p, @hp⟩
-#align category_theory.functor.full_of_exists CategoryTheory.Functor.fullOfExists
+/-- The choice of a preimage of a morphism under a full functor. -/
+@[pp_dot]
+noncomputable def preimage (F : C ⥤ D) [Full F] (f : F.obj X ⟶ F.obj Y) : X ⟶ Y :=
+  (F.map_surjective f).choose
+#align category_theory.functor.preimage CategoryTheory.Functor.preimage
 
-/-- Deduce that `F` is full from surjectivity of `F.map`, using choice. -/
-noncomputable def fullOfSurjective (F : C ⥤ D)
-    (h : ∀ X Y : C, Function.Surjective (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y))) : Full F :=
-  fullOfExists _ h
-#align category_theory.functor.full_of_surjective CategoryTheory.Functor.fullOfSurjective
+@[simp]
+theorem map_preimage (F : C ⥤ D) [Full F] {X Y : C} (f : F.obj X ⟶ F.obj Y) :
+    F.map (preimage F f) = f :=
+  (F.map_surjective f).choose_spec
+#align category_theory.functor.image_preimage CategoryTheory.Functor.map_preimage
 
 variable {F : C ⥤ D} [Full F] [F.Faithful] {X Y Z : C}
 
@@ -130,7 +108,7 @@ variable (F)
 
 /-- If `F : C ⥤ D` is fully faithful, every isomorphism `F.obj X ≅ F.obj Y` has a preimage. -/
 @[simps]
-def preimageIso (f : F.obj X ≅ F.obj Y) :
+noncomputable def preimageIso (f : F.obj X ≅ F.obj Y) :
     X ≅ Y where
   hom := F.preimage f.hom
   inv := F.preimage f.inv
@@ -161,7 +139,7 @@ theorem isIso_of_fully_faithful (f : X ⟶ Y) [IsIso (F.map f)] : IsIso f :=
 
 /-- If `F` is fully faithful, we have an equivalence of hom-sets `X ⟶ Y` and `F X ⟶ F Y`. -/
 @[simps]
-def equivOfFullyFaithful :
+noncomputable def equivOfFullyFaithful :
     (X ⟶ Y) ≃ (F.obj X ⟶ F.obj Y) where
   toFun f := F.map f
   invFun f := F.preimage f
@@ -173,7 +151,7 @@ def equivOfFullyFaithful :
 
 /-- If `F` is fully faithful, we have an equivalence of iso-sets `X ≅ Y` and `F X ≅ F Y`. -/
 @[simps]
-def isoEquivOfFullyFaithful :
+noncomputable def isoEquivOfFullyFaithful :
     (X ≅ Y) ≃ (F.obj X ≅ F.obj Y) where
   toFun f := F.mapIso f
   invFun f := F.preimageIso f
@@ -194,7 +172,7 @@ variable {E : Type*} [Category E] {F G : C ⥤ D} (H : D ⥤ E) [H.Full] [H.Fait
 /-- We can construct a natural transformation between functors by constructing a
 natural transformation between those functors composed with a fully faithful functor. -/
 @[simps]
-def natTransOfCompFullyFaithful (α : F ⋙ H ⟶ G ⋙ H) :
+noncomputable def natTransOfCompFullyFaithful (α : F ⋙ H ⟶ G ⋙ H) :
     F ⟶ G where
   app X := (equivOfFullyFaithful H).symm (α.app X)
   naturality X Y f := by
@@ -207,7 +185,7 @@ def natTransOfCompFullyFaithful (α : F ⋙ H ⟶ G ⋙ H) :
 /-- We can construct a natural isomorphism between functors by constructing a natural isomorphism
 between those functors composed with a fully faithful functor. -/
 @[simps!]
-def natIsoOfCompFullyFaithful (i : F ⋙ H ≅ G ⋙ H) : F ≅ G :=
+noncomputable def natIsoOfCompFullyFaithful (i : F ⋙ H ≅ G ⋙ H) : F ≅ G :=
   NatIso.ofComponents (fun X => (isoEquivOfFullyFaithful H).symm (i.app X)) fun f => by
     dsimp
     apply H.map_injective
@@ -231,7 +209,7 @@ theorem natIsoOfCompFullyFaithful_inv (i : F ⋙ H ≅ G ⋙ H) :
 /-- Horizontal composition with a fully faithful functor induces a bijection on
 natural transformations. -/
 @[simps]
-def NatTrans.equivOfCompFullyFaithful :
+noncomputable def NatTrans.equivOfCompFullyFaithful :
     (F ⟶ G) ≃ (F ⋙ H ⟶ G ⋙ H) where
   toFun α := α ◫ 𝟙 H
   invFun := natTransOfCompFullyFaithful H
@@ -244,7 +222,7 @@ def NatTrans.equivOfCompFullyFaithful :
 /-- Horizontal composition with a fully faithful functor induces a bijection on
 natural isomorphisms. -/
 @[simps]
-def NatIso.equivOfCompFullyFaithful :
+noncomputable def NatIso.equivOfCompFullyFaithful :
     (F ≅ G) ≃ (F ⋙ H ≅ G ⋙ H) where
   toFun e := NatIso.hcomp e (Iso.refl H)
   invFun := natIsoOfCompFullyFaithful H
@@ -264,7 +242,7 @@ namespace Functor
 
 variable {C : Type u₁} [Category.{v₁} C]
 
-instance Full.id : Full (𝟭 C) where preimage f := f
+instance Full.id : Full (𝟭 C) where map_surjective := Function.surjective_id
 #align category_theory.full.id CategoryTheory.Functor.Full.id
 
 instance Faithful.id : Functor.Faithful (𝟭 C) := { }
@@ -289,11 +267,10 @@ section
 variable {F F'}
 
 /-- If `F` is full, and naturally isomorphic to some `F'`, then `F'` is also full. -/
-def Full.ofIso [Full F] (α : F ≅ F') :
-    Full F' where
-  preimage {X Y} f := F.preimage ((α.app X).hom ≫ f ≫ (α.app Y).inv)
-  witness f := by simp [← NatIso.naturality_1 α]
-#align category_theory.full.of_iso CategoryTheory.Functor.Full.ofIso
+lemma Full.of_iso [Full F] (α : F ≅ F') : Full F' where
+  map_surjective {X Y} f :=
+    ⟨F.preimage ((α.app X).hom ≫ f ≫ (α.app Y).inv), by simp [← NatIso.naturality_1 α]⟩
+#align category_theory.full.of_iso CategoryTheory.Functor.Full.of_iso
 
 theorem Faithful.of_iso [F.Faithful] (α : F ≅ F') : F'.Faithful :=
   { map_injective := fun h =>
@@ -370,27 +347,26 @@ theorem Faithful.div_faithful (F : C ⥤ E) [F.Faithful] (G : D ⥤ E) [G.Faithf
   (Faithful.div_comp F G _ h_obj _ @h_map).faithful_of_comp
 #align category_theory.faithful.div_faithful CategoryTheory.Functor.Faithful.div_faithful
 
-instance Full.comp [Full F] [Full G] :
-    Full (F ⋙ G) where preimage f := F.preimage (G.preimage f)
+instance Full.comp [Full F] [Full G] : Full (F ⋙ G) where
+  map_surjective f := ⟨F.preimage (G.preimage f), by simp⟩
 #align category_theory.full.comp CategoryTheory.Functor.Full.comp
 
 /-- If `F ⋙ G` is full and `G` is faithful, then `F` is full. -/
-def Full.ofCompFaithful [Full <| F ⋙ G] [G.Faithful] :
-    Full F where
-  preimage f := (F ⋙ G).preimage (G.map f)
-  witness _ := G.map_injective ((F ⋙ G).image_preimage _)
-#align category_theory.full.of_comp_faithful CategoryTheory.Functor.Full.ofCompFaithful
+lemma Full.of_comp_faithful [Full <| F ⋙ G] [G.Faithful] : Full F where
+  map_surjective f := ⟨(F ⋙ G).preimage (G.map f), G.map_injective ((F ⋙ G).map_preimage _)⟩
+#align category_theory.full.of_comp_faithful CategoryTheory.Functor.Full.of_comp_faithful
 
 /-- If `F ⋙ G` is full and `G` is faithful, then `F` is full. -/
-def Full.ofCompFaithfulIso {F : C ⥤ D} {G : D ⥤ E} {H : C ⥤ E} [Full H] [G.Faithful]
-    (h : F ⋙ G ≅ H) : Full F :=
-  @Full.ofCompFaithful _ _ _ _ _ _ F G (Full.ofIso h.symm) _
-#align category_theory.full.of_comp_faithful_iso CategoryTheory.Functor.Full.ofCompFaithfulIso
+lemma Full.of_comp_faithful_iso {F : C ⥤ D} {G : D ⥤ E} {H : C ⥤ E} [Full H] [G.Faithful]
+    (h : F ⋙ G ≅ H) : Full F := by
+  have := Full.of_iso h.symm
+  exact Full.of_comp_faithful F G
+#align category_theory.full.of_comp_faithful_iso CategoryTheory.Functor.Full.of_comp_faithful_iso
 
 /-- Given a natural isomorphism between `F ⋙ H` and `G ⋙ H` for a fully faithful functor `H`, we
 can 'cancel' it to give a natural iso between `F` and `G`.
 -/
-def fullyFaithfulCancelRight {F G : C ⥤ D} (H : D ⥤ E) [Full H] [H.Faithful]
+noncomputable def fullyFaithfulCancelRight {F G : C ⥤ D} (H : D ⥤ E) [Full H] [H.Faithful]
     (comp_iso : F ⋙ H ≅ G ⋙ H) : F ≅ G :=
   NatIso.ofComponents (fun X => H.preimageIso (comp_iso.app X)) fun f =>
     H.map_injective (by simpa using comp_iso.hom.naturality f)
@@ -419,17 +395,20 @@ end Functor
 @[deprecated] alias preimage_comp := Functor.preimage_comp
 @[deprecated] alias preimage_map := Functor.preimage_map
 @[deprecated] alias Faithful.of_comp := Functor.Faithful.of_comp
-@[deprecated] alias Full.ofIso := Functor.Full.ofIso
+@[deprecated] alias Full.ofIso := Functor.Full.of_iso
 @[deprecated] alias Faithful.of_iso := Functor.Faithful.of_iso
 @[deprecated] alias Faithful.of_comp_iso := Functor.Faithful.of_comp_iso
 @[deprecated] alias Faithful.of_comp_eq := Functor.Faithful.of_comp_eq
 @[deprecated] alias Faithful.div := Functor.Faithful.div
 @[deprecated] alias Faithful.div_comp := Functor.Faithful.div_comp
 @[deprecated] alias Faithful.div_faithful := Functor.Faithful.div_faithful
-@[deprecated] alias Full.ofCompFaithful := Functor.Full.ofCompFaithful
-@[deprecated] alias Full.ofCompFaithfulIso := Functor.Full.ofCompFaithfulIso
+@[deprecated] alias Full.ofCompFaithful := Functor.Full.of_comp_faithful
+@[deprecated] alias Full.ofCompFaithfulIso := Functor.Full.of_comp_faithful_iso
 @[deprecated] alias fullyFaithfulCancelRight := Functor.fullyFaithfulCancelRight
 @[deprecated] alias fullyFaithfulCancelRight_hom_app := Functor.fullyFaithfulCancelRight_hom_app
 @[deprecated] alias fullyFaithfulCancelRight_inv_app := Functor.fullyFaithfulCancelRight_inv_app
 
+-- deprecated on 2024-04-26
+@[deprecated] alias Functor.image_preimage := Functor.map_preimage
+
 end CategoryTheory

70d50ecf

feat: order embedding is fully faithful as a functor (#12283)

As discussed on Zulip.

ec96058c

Diff

@@ -282,6 +282,8 @@ theorem Faithful.of_comp [(F ⋙ G).Faithful] : F.Faithful :=
   { map_injective := fun {_ _} => Function.Injective.of_comp (F ⋙ G).map_injective }
 #align category_theory.faithful.of_comp CategoryTheory.Functor.Faithful.of_comp
 
+instance (priority := 100) [Quiver.IsThin C] : F.Faithful where
+
 section
 
 variable {F F'}

70d50ecf

chore(CategoryTheory): move Full, Faithful, EssSurj, IsEquivalence and ReflectsIsomorphisms to the Functor namespace (#11985)

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

65b7affc

Diff

@@ -36,6 +36,8 @@ namespace CategoryTheory
 
 variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
 
+namespace Functor
+
 /-- A functor `F : C ⥤ D` is full if for each `X Y : C`, `F.map` is surjective.
 In fact, we use a constructive definition, so the `Full F` typeclass contains data,
 specifying a particular preimage of each `f : F.obj X ⟶ F.obj Y`.
@@ -47,12 +49,11 @@ class Full (F : C ⥤ D) where
   preimage : ∀ {X Y : C} (_ : F.obj X ⟶ F.obj Y), X ⟶ Y
   /-- The property that `Full.preimage f` of maps to `f` via `F.map`. -/
   witness : ∀ {X Y : C} (f : F.obj X ⟶ F.obj Y), F.map (preimage f) = f := by aesop_cat
-#align category_theory.full CategoryTheory.Full
-#align category_theory.full.witness CategoryTheory.Full.witness
+#align category_theory.full CategoryTheory.Functor.Full
+#align category_theory.full.witness CategoryTheory.Functor.Full.witness
 
 attribute [simp] Full.witness
 
-
 /- ./././Mathport/Syntax/Translate/Command.lean:379:30: infer kinds are unsupported in Lean 4:
 #[`map_injective'] [] -/
 /-- A functor `F : C ⥤ D` is faithful if for each `X Y : C`, `F.map` is injective.
@@ -63,10 +64,8 @@ class Faithful (F : C ⥤ D) : Prop where
   /-- `F.map` is injective for each `X Y : C`. -/
   map_injective : ∀ {X Y : C}, Function.Injective (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y)) := by
     aesop_cat
-#align category_theory.faithful CategoryTheory.Faithful
-#align category_theory.faithful.map_injective CategoryTheory.Faithful.map_injective
-
-namespace Functor
+#align category_theory.faithful CategoryTheory.Functor.Faithful
+#align category_theory.faithful.map_injective CategoryTheory.Functor.Faithful.map_injective
 
 variable {X Y : C}
 
@@ -109,32 +108,26 @@ noncomputable def fullOfSurjective (F : C ⥤ D)
   fullOfExists _ h
 #align category_theory.functor.full_of_surjective CategoryTheory.Functor.fullOfSurjective
 
-end Functor
-
-section
-
-variable {F : C ⥤ D} [Full F] [Faithful F] {X Y Z : C}
+variable {F : C ⥤ D} [Full F] [F.Faithful] {X Y Z : C}
 
 @[simp]
 theorem preimage_id : F.preimage (𝟙 (F.obj X)) = 𝟙 X :=
   F.map_injective (by simp)
-#align category_theory.preimage_id CategoryTheory.preimage_id
+#align category_theory.preimage_id CategoryTheory.Functor.preimage_id
 
 @[simp]
 theorem preimage_comp (f : F.obj X ⟶ F.obj Y) (g : F.obj Y ⟶ F.obj Z) :
     F.preimage (f ≫ g) = F.preimage f ≫ F.preimage g :=
   F.map_injective (by simp)
-#align category_theory.preimage_comp CategoryTheory.preimage_comp
+#align category_theory.preimage_comp CategoryTheory.Functor.preimage_comp
 
 @[simp]
 theorem preimage_map (f : X ⟶ Y) : F.preimage (F.map f) = f :=
   F.map_injective (by simp)
-#align category_theory.preimage_map CategoryTheory.preimage_map
+#align category_theory.preimage_map CategoryTheory.Functor.preimage_map
 
 variable (F)
 
-namespace Functor
-
 /-- If `F : C ⥤ D` is fully faithful, every isomorphism `F.obj X ≅ F.obj Y` has a preimage. -/
 @[simps]
 def preimageIso (f : F.obj X ≅ F.obj Y) :
@@ -155,6 +148,10 @@ theorem preimageIso_mapIso (f : X ≅ Y) : F.preimageIso (F.mapIso f) = f := by
 
 end Functor
 
+section
+
+variable (F : C ⥤ D) [F.Full] [F.Faithful] {X Y : C}
+
 /-- If the image of a morphism under a fully faithful functor in an isomorphism,
 then the original morphisms is also an isomorphism.
 -/
@@ -164,7 +161,7 @@ theorem isIso_of_fully_faithful (f : X ⟶ Y) [IsIso (F.map f)] : IsIso f :=
 
 /-- If `F` is fully faithful, we have an equivalence of hom-sets `X ⟶ Y` and `F X ⟶ F Y`. -/
 @[simps]
-def equivOfFullyFaithful {X Y} :
+def equivOfFullyFaithful :
     (X ⟶ Y) ≃ (F.obj X ⟶ F.obj Y) where
   toFun f := F.map f
   invFun f := F.preimage f
@@ -176,7 +173,7 @@ def equivOfFullyFaithful {X Y} :
 
 /-- If `F` is fully faithful, we have an equivalence of iso-sets `X ≅ Y` and `F X ≅ F Y`. -/
 @[simps]
-def isoEquivOfFullyFaithful {X Y} :
+def isoEquivOfFullyFaithful :
     (X ≅ Y) ≃ (F.obj X ≅ F.obj Y) where
   toFun f := F.mapIso f
   invFun f := F.preimageIso f
@@ -192,7 +189,7 @@ end
 
 section
 
-variable {E : Type*} [Category E] {F G : C ⥤ D} (H : D ⥤ E) [Full H] [Faithful H]
+variable {E : Type*} [Category E] {F G : C ⥤ D} (H : D ⥤ E) [H.Full] [H.Faithful]
 
 /-- We can construct a natural transformation between functors by constructing a
 natural transformation between those functors composed with a fully faithful functor. -/
@@ -228,7 +225,7 @@ theorem natIsoOfCompFullyFaithful_hom (i : F ⋙ H ≅ G ⋙ H) :
 theorem natIsoOfCompFullyFaithful_inv (i : F ⋙ H ≅ G ⋙ H) :
     (natIsoOfCompFullyFaithful H i).inv = natTransOfCompFullyFaithful H i.inv := by
   ext
-  simp [← preimage_comp]
+  simp [← H.preimage_comp]
 #align category_theory.nat_iso_of_comp_fully_faithful_inv CategoryTheory.natIsoOfCompFullyFaithful_inv
 
 /-- Horizontal composition with a fully faithful functor induces a bijection on
@@ -263,25 +260,27 @@ end CategoryTheory
 
 namespace CategoryTheory
 
+namespace Functor
+
 variable {C : Type u₁} [Category.{v₁} C]
 
 instance Full.id : Full (𝟭 C) where preimage f := f
-#align category_theory.full.id CategoryTheory.Full.id
+#align category_theory.full.id CategoryTheory.Functor.Full.id
 
-instance Faithful.id : Faithful (𝟭 C) := { }
-#align category_theory.faithful.id CategoryTheory.Faithful.id
+instance Faithful.id : Functor.Faithful (𝟭 C) := { }
+#align category_theory.faithful.id CategoryTheory.Functor.Faithful.id
 
 variable {D : Type u₂} [Category.{v₂} D] {E : Type u₃} [Category.{v₃} E]
 variable (F F' : C ⥤ D) (G : D ⥤ E)
 
-instance Faithful.comp [Faithful F] [Faithful G] :
-    Faithful (F ⋙ G) where map_injective p := F.map_injective (G.map_injective p)
-#align category_theory.faithful.comp CategoryTheory.Faithful.comp
+instance Faithful.comp [F.Faithful] [G.Faithful] :
+    (F ⋙ G).Faithful  where map_injective p := F.map_injective (G.map_injective p)
+#align category_theory.faithful.comp CategoryTheory.Functor.Faithful.comp
 
-theorem Faithful.of_comp [Faithful <| F ⋙ G] : Faithful F :=
+theorem Faithful.of_comp [(F ⋙ G).Faithful] : F.Faithful :=
   -- Porting note: (F ⋙ G).map_injective.of_comp has the incorrect type
   { map_injective := fun {_ _} => Function.Injective.of_comp (F ⋙ G).map_injective }
-#align category_theory.faithful.of_comp CategoryTheory.Faithful.of_comp
+#align category_theory.faithful.of_comp CategoryTheory.Functor.Faithful.of_comp
 
 section
 
@@ -292,36 +291,36 @@ def Full.ofIso [Full F] (α : F ≅ F') :
     Full F' where
   preimage {X Y} f := F.preimage ((α.app X).hom ≫ f ≫ (α.app Y).inv)
   witness f := by simp [← NatIso.naturality_1 α]
-#align category_theory.full.of_iso CategoryTheory.Full.ofIso
+#align category_theory.full.of_iso CategoryTheory.Functor.Full.ofIso
 
-theorem Faithful.of_iso [Faithful F] (α : F ≅ F') : Faithful F' :=
+theorem Faithful.of_iso [F.Faithful] (α : F ≅ F') : F'.Faithful :=
   { map_injective := fun h =>
       F.map_injective (by rw [← NatIso.naturality_1 α.symm, h, NatIso.naturality_1 α.symm]) }
-#align category_theory.faithful.of_iso CategoryTheory.Faithful.of_iso
+#align category_theory.faithful.of_iso CategoryTheory.Functor.Faithful.of_iso
 
 end
 
 variable {F G}
 
-theorem Faithful.of_comp_iso {H : C ⥤ E} [Faithful H] (h : F ⋙ G ≅ H) : Faithful F :=
+theorem Faithful.of_comp_iso {H : C ⥤ E} [H.Faithful] (h : F ⋙ G ≅ H) : F.Faithful :=
   @Faithful.of_comp _ _ _ _ _ _ F G (Faithful.of_iso h.symm)
-#align category_theory.faithful.of_comp_iso CategoryTheory.Faithful.of_comp_iso
+#align category_theory.faithful.of_comp_iso CategoryTheory.Functor.Faithful.of_comp_iso
 
 alias _root_.CategoryTheory.Iso.faithful_of_comp := Faithful.of_comp_iso
 #align category_theory.iso.faithful_of_comp CategoryTheory.Iso.faithful_of_comp
 
 -- We could prove this from `Faithful.of_comp_iso` using `eq_to_iso`,
 -- but that would introduce a cyclic import.
-theorem Faithful.of_comp_eq {H : C ⥤ E} [ℋ : Faithful H] (h : F ⋙ G = H) : Faithful F :=
+theorem Faithful.of_comp_eq {H : C ⥤ E} [ℋ : H.Faithful] (h : F ⋙ G = H) : F.Faithful :=
   @Faithful.of_comp _ _ _ _ _ _ F G (h.symm ▸ ℋ)
-#align category_theory.faithful.of_comp_eq CategoryTheory.Faithful.of_comp_eq
+#align category_theory.faithful.of_comp_eq CategoryTheory.Functor.Faithful.of_comp_eq
 
 alias _root_.Eq.faithful_of_comp := Faithful.of_comp_eq
 #align eq.faithful_of_comp Eq.faithful_of_comp
 
 variable (F G)
 /-- “Divide” a functor by a faithful functor. -/
-protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C → D)
+protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [G.Faithful] (obj : C → D)
     (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
     (h_map : ∀ {X Y} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)) : C ⥤ D :=
   { obj, map := @map,
@@ -338,13 +337,13 @@ protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C →
       simp only [Functor.map_comp]
       convert HEq.refl (F.map f ≫ F.map g)
       all_goals { first | apply h_obj | apply h_map } }
-#align category_theory.faithful.div CategoryTheory.Faithful.div
+#align category_theory.faithful.div CategoryTheory.Functor.Faithful.div
 
 -- This follows immediately from `Functor.hext` (`Functor.hext h_obj @h_map`),
 -- but importing `CategoryTheory.EqToHom` causes an import loop:
 -- CategoryTheory.EqToHom → CategoryTheory.Opposites →
 -- CategoryTheory.Equivalence → CategoryTheory.FullyFaithful
-theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G] (obj : C → D)
+theorem Faithful.div_comp (F : C ⥤ E) [F.Faithful] (G : D ⥤ E) [G.Faithful] (obj : C → D)
     (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
     (h_map : ∀ {X Y} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)) :
     Faithful.div F G obj @h_obj @map @h_map ⋙ G = F := by
@@ -360,53 +359,75 @@ theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G]
   simp only [Function.comp_apply, heq_eq_eq] at h_map
   ext
   exact h_map
-#align category_theory.faithful.div_comp CategoryTheory.Faithful.div_comp
+#align category_theory.faithful.div_comp CategoryTheory.Functor.Faithful.div_comp
 
-theorem Faithful.div_faithful (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G] (obj : C → D)
+theorem Faithful.div_faithful (F : C ⥤ E) [F.Faithful] (G : D ⥤ E) [G.Faithful] (obj : C → D)
     (h_obj : ∀ X, G.obj (obj X) = F.obj X) (map : ∀ {X Y}, (X ⟶ Y) → (obj X ⟶ obj Y))
     (h_map : ∀ {X Y} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f)) :
-    Faithful (Faithful.div F G obj @h_obj @map @h_map) :=
+    Functor.Faithful (Faithful.div F G obj @h_obj @map @h_map) :=
   (Faithful.div_comp F G _ h_obj _ @h_map).faithful_of_comp
-#align category_theory.faithful.div_faithful CategoryTheory.Faithful.div_faithful
+#align category_theory.faithful.div_faithful CategoryTheory.Functor.Faithful.div_faithful
 
 instance Full.comp [Full F] [Full G] :
     Full (F ⋙ G) where preimage f := F.preimage (G.preimage f)
-#align category_theory.full.comp CategoryTheory.Full.comp
+#align category_theory.full.comp CategoryTheory.Functor.Full.comp
 
 /-- If `F ⋙ G` is full and `G` is faithful, then `F` is full. -/
-def Full.ofCompFaithful [Full <| F ⋙ G] [Faithful G] :
+def Full.ofCompFaithful [Full <| F ⋙ G] [G.Faithful] :
     Full F where
   preimage f := (F ⋙ G).preimage (G.map f)
   witness _ := G.map_injective ((F ⋙ G).image_preimage _)
-#align category_theory.full.of_comp_faithful CategoryTheory.Full.ofCompFaithful
+#align category_theory.full.of_comp_faithful CategoryTheory.Functor.Full.ofCompFaithful
 
 /-- If `F ⋙ G` is full and `G` is faithful, then `F` is full. -/
-def Full.ofCompFaithfulIso {F : C ⥤ D} {G : D ⥤ E} {H : C ⥤ E} [Full H] [Faithful G]
+def Full.ofCompFaithfulIso {F : C ⥤ D} {G : D ⥤ E} {H : C ⥤ E} [Full H] [G.Faithful]
     (h : F ⋙ G ≅ H) : Full F :=
   @Full.ofCompFaithful _ _ _ _ _ _ F G (Full.ofIso h.symm) _
-#align category_theory.full.of_comp_faithful_iso CategoryTheory.Full.ofCompFaithfulIso
+#align category_theory.full.of_comp_faithful_iso CategoryTheory.Functor.Full.ofCompFaithfulIso
 
 /-- Given a natural isomorphism between `F ⋙ H` and `G ⋙ H` for a fully faithful functor `H`, we
 can 'cancel' it to give a natural iso between `F` and `G`.
 -/
-def fullyFaithfulCancelRight {F G : C ⥤ D} (H : D ⥤ E) [Full H] [Faithful H]
+def fullyFaithfulCancelRight {F G : C ⥤ D} (H : D ⥤ E) [Full H] [H.Faithful]
     (comp_iso : F ⋙ H ≅ G ⋙ H) : F ≅ G :=
   NatIso.ofComponents (fun X => H.preimageIso (comp_iso.app X)) fun f =>
     H.map_injective (by simpa using comp_iso.hom.naturality f)
-#align category_theory.fully_faithful_cancel_right CategoryTheory.fullyFaithfulCancelRight
+#align category_theory.fully_faithful_cancel_right CategoryTheory.Functor.fullyFaithfulCancelRight
 
 @[simp]
-theorem fullyFaithfulCancelRight_hom_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [Faithful H]
+theorem fullyFaithfulCancelRight_hom_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [H.Faithful]
     (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
     (fullyFaithfulCancelRight H comp_iso).hom.app X = H.preimage (comp_iso.hom.app X) :=
   rfl
-#align category_theory.fully_faithful_cancel_right_hom_app CategoryTheory.fullyFaithfulCancelRight_hom_app
+#align category_theory.fully_faithful_cancel_right_hom_app CategoryTheory.Functor.fullyFaithfulCancelRight_hom_app
 
 @[simp]
-theorem fullyFaithfulCancelRight_inv_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [Faithful H]
+theorem fullyFaithfulCancelRight_inv_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [H.Faithful]
     (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
     (fullyFaithfulCancelRight H comp_iso).inv.app X = H.preimage (comp_iso.inv.app X) :=
   rfl
-#align category_theory.fully_faithful_cancel_right_inv_app CategoryTheory.fullyFaithfulCancelRight_inv_app
+#align category_theory.fully_faithful_cancel_right_inv_app CategoryTheory.Functor.fullyFaithfulCancelRight_inv_app
+
+end Functor
+
+-- deprecated on 2024-04-06
+@[deprecated] alias Full := Functor.Full
+@[deprecated] alias Faithful := Functor.Faithful
+@[deprecated] alias preimage_id := Functor.preimage_id
+@[deprecated] alias preimage_comp := Functor.preimage_comp
+@[deprecated] alias preimage_map := Functor.preimage_map
+@[deprecated] alias Faithful.of_comp := Functor.Faithful.of_comp
+@[deprecated] alias Full.ofIso := Functor.Full.ofIso
+@[deprecated] alias Faithful.of_iso := Functor.Faithful.of_iso
+@[deprecated] alias Faithful.of_comp_iso := Functor.Faithful.of_comp_iso
+@[deprecated] alias Faithful.of_comp_eq := Functor.Faithful.of_comp_eq
+@[deprecated] alias Faithful.div := Functor.Faithful.div
+@[deprecated] alias Faithful.div_comp := Functor.Faithful.div_comp
+@[deprecated] alias Faithful.div_faithful := Functor.Faithful.div_faithful
+@[deprecated] alias Full.ofCompFaithful := Functor.Full.ofCompFaithful
+@[deprecated] alias Full.ofCompFaithfulIso := Functor.Full.ofCompFaithfulIso
+@[deprecated] alias fullyFaithfulCancelRight := Functor.fullyFaithfulCancelRight
+@[deprecated] alias fullyFaithfulCancelRight_hom_app := Functor.fullyFaithfulCancelRight_hom_app
+@[deprecated] alias fullyFaithfulCancelRight_inv_app := Functor.fullyFaithfulCancelRight_inv_app
 
 end CategoryTheory

70d50ecf

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


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

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

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

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

75c86f04

Diff

@@ -272,7 +272,6 @@ instance Faithful.id : Faithful (𝟭 C) := { }
 #align category_theory.faithful.id CategoryTheory.Faithful.id
 
 variable {D : Type u₂} [Category.{v₂} D] {E : Type u₃} [Category.{v₃} E]
-
 variable (F F' : C ⥤ D) (G : D ⥤ E)
 
 instance Faithful.comp [Faithful F] [Faithful G] :

70d50ecf

chore: space after ← (#8178)

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

5fb9beab

Diff

@@ -292,7 +292,7 @@ variable {F F'}
 def Full.ofIso [Full F] (α : F ≅ F') :
     Full F' where
   preimage {X Y} f := F.preimage ((α.app X).hom ≫ f ≫ (α.app Y).inv)
-  witness f := by simp [←NatIso.naturality_1 α]
+  witness f := by simp [← NatIso.naturality_1 α]
 #align category_theory.full.of_iso CategoryTheory.Full.ofIso
 
 theorem Faithful.of_iso [Faithful F] (α : F ≅ F') : Faithful F' :=

70d50ecf

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -308,7 +308,7 @@ theorem Faithful.of_comp_iso {H : C ⥤ E} [Faithful H] (h : F ⋙ G ≅ H) : Fa
   @Faithful.of_comp _ _ _ _ _ _ F G (Faithful.of_iso h.symm)
 #align category_theory.faithful.of_comp_iso CategoryTheory.Faithful.of_comp_iso
 
-alias Faithful.of_comp_iso ← _root_.CategoryTheory.Iso.faithful_of_comp
+alias _root_.CategoryTheory.Iso.faithful_of_comp := Faithful.of_comp_iso
 #align category_theory.iso.faithful_of_comp CategoryTheory.Iso.faithful_of_comp
 
 -- We could prove this from `Faithful.of_comp_iso` using `eq_to_iso`,
@@ -317,7 +317,7 @@ theorem Faithful.of_comp_eq {H : C ⥤ E} [ℋ : Faithful H] (h : F ⋙ G = H) :
   @Faithful.of_comp _ _ _ _ _ _ F G (h.symm ▸ ℋ)
 #align category_theory.faithful.of_comp_eq CategoryTheory.Faithful.of_comp_eq
 
-alias Faithful.of_comp_eq ← _root_.Eq.faithful_of_comp
+alias _root_.Eq.faithful_of_comp := Faithful.of_comp_eq
 #align eq.faithful_of_comp Eq.faithful_of_comp
 
 variable (F G)

70d50ecf

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -192,7 +192,7 @@ end
 
 section
 
-variable {E : Type _} [Category E] {F G : C ⥤ D} (H : D ⥤ E) [Full H] [Faithful H]
+variable {E : Type*} [Category E] {F G : C ⥤ D} (H : D ⥤ E) [Full H] [Faithful H]
 
 /-- We can construct a natural transformation between functors by constructing a
 natural transformation between those functors composed with a fully faithful functor. -/

70d50ecf

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module category_theory.functor.fully_faithful
-! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.NatIso
 import Mathlib.Logic.Equiv.Defs
 
+#align_import category_theory.functor.fully_faithful from "leanprover-community/mathlib"@"70d50ecfd4900dd6d328da39ab7ebd516abe4025"
+
 /-!
 # Full and faithful functors

70d50ecf

feat: pp_dot attribute to replace pp_extended_field_notation command (#5632)

760b24bf

Diff

@@ -84,12 +84,11 @@ theorem mapIso_injective (F : C ⥤ D) [Faithful F] :
 #align category_theory.functor.map_iso_injective CategoryTheory.Functor.mapIso_injective
 
 /-- The specified preimage of a morphism under a full functor. -/
+@[pp_dot]
 def preimage (F : C ⥤ D) [Full F] (f : F.obj X ⟶ F.obj Y) : X ⟶ Y :=
   Full.preimage.{v₁, v₂} f
 #align category_theory.functor.preimage CategoryTheory.Functor.preimage
 
-pp_extended_field_notation preimage
-
 @[simp]
 theorem image_preimage (F : C ⥤ D) [Full F] {X Y : C} (f : F.obj X ⟶ F.obj Y) :
     F.map (preimage F f) = f := by unfold preimage; aesop_cat

70d50ecf

chore: remove occurrences of semicolon after space (#5713)

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

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

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

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

c795bd35

Diff

@@ -355,8 +355,8 @@ theorem Faithful.div_comp (F : C ⥤ E) [Faithful F] (G : D ⥤ E) [Faithful G]
     Faithful.div F G obj @h_obj @map @h_map ⋙ G = F := by
   -- Porting note: Have to unfold the structure twice because the first one recovers only the
   -- prefunctor `F_pre`
-  cases' F with F_pre _ _ ; cases' G with G_pre _ _
-  cases' F_pre with F_obj _ ; cases' G_pre with G_obj _
+  cases' F with F_pre _ _; cases' G with G_pre _ _
+  cases' F_pre with F_obj _; cases' G_pre with G_obj _
   unfold Faithful.div Functor.comp
   -- Porting note: unable to find the lean4 analogue to `unfold_projs`, works without it
   have : F_obj = G_obj ∘ obj := (funext h_obj).symm

70d50ecf

feat: add Mathlib.Tactic.Common, and import (#4056)

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

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

a4eaf1c4

Diff

@@ -10,7 +10,6 @@ Authors: Scott Morrison
 -/
 import Mathlib.CategoryTheory.NatIso
 import Mathlib.Logic.Equiv.Defs
-import Mathlib.Tactic.Choose
 
 /-!
 # Full and faithful functors

70d50ecf

feat: add unexpanders for preimage and op (#3959)

93b1c8e5

Diff

@@ -89,6 +89,8 @@ def preimage (F : C ⥤ D) [Full F] (f : F.obj X ⟶ F.obj Y) : X ⟶ Y :=
   Full.preimage.{v₁, v₂} f
 #align category_theory.functor.preimage CategoryTheory.Functor.preimage
 
+pp_extended_field_notation preimage
+
 @[simp]
 theorem image_preimage (F : C ⥤ D) [Full F] {X Y : C} (f : F.obj X ⟶ F.obj Y) :
     F.map (preimage F f) = f := by unfold preimage; aesop_cat

70d50ecf

feat: require @[simps!] if simps runs in expensive mode (#1885)

This does not change the behavior of simps, just raises a linter error if you run simps in a more expensive mode without writing !.
Fixed some incorrect occurrences of to_additive, simps. Will do that systematically in future PR.
Fix port of OmegaCompletePartialOrder.ContinuousHom.ofMono a bit

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

52c04a34

Diff

@@ -212,7 +212,7 @@ def natTransOfCompFullyFaithful (α : F ⋙ H ⟶ G ⋙ H) :
 
 /-- We can construct a natural isomorphism between functors by constructing a natural isomorphism
 between those functors composed with a fully faithful functor. -/
-@[simps]
+@[simps!]
 def natIsoOfCompFullyFaithful (i : F ⋙ H ≅ G ⋙ H) : F ≅ G :=
   NatIso.ofComponents (fun X => (isoEquivOfFullyFaithful H).symm (i.app X)) fun f => by
     dsimp

70d50ecf

chore: add missing #align statements (#1902)

This PR is the result of a slight variant on the following "algorithm"

take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
for pairs that do not have an align statement:
- use Lean 4 to lookup the file + position of the Lean 4 name
- add an #align statement just before the next empty line
manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

b72bb858

Diff

@@ -52,6 +52,7 @@ class Full (F : C ⥤ D) where
   /-- The property that `Full.preimage f` of maps to `f` via `F.map`. -/
   witness : ∀ {X Y : C} (f : F.obj X ⟶ F.obj Y), F.map (preimage f) = f := by aesop_cat
 #align category_theory.full CategoryTheory.Full
+#align category_theory.full.witness CategoryTheory.Full.witness
 
 attribute [simp] Full.witness
 
@@ -67,6 +68,7 @@ class Faithful (F : C ⥤ D) : Prop where
   map_injective : ∀ {X Y : C}, Function.Injective (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y)) := by
     aesop_cat
 #align category_theory.faithful CategoryTheory.Faithful
+#align category_theory.faithful.map_injective CategoryTheory.Faithful.map_injective
 
 namespace Functor
 
@@ -145,6 +147,8 @@ def preimageIso (f : F.obj X ≅ F.obj Y) :
   hom_inv_id := F.map_injective (by simp)
   inv_hom_id := F.map_injective (by simp)
 #align category_theory.functor.preimage_iso CategoryTheory.Functor.preimageIso
+#align category_theory.functor.preimage_iso_inv CategoryTheory.Functor.preimageIso_inv
+#align category_theory.functor.preimage_iso_hom CategoryTheory.Functor.preimageIso_hom
 
 @[simp]
 theorem preimageIso_mapIso (f : X ≅ Y) : F.preimageIso (F.mapIso f) = f := by
@@ -170,6 +174,8 @@ def equivOfFullyFaithful {X Y} :
   left_inv f := by simp
   right_inv f := by simp
 #align category_theory.equiv_of_fully_faithful CategoryTheory.equivOfFullyFaithful
+#align category_theory.equiv_of_fully_faithful_apply CategoryTheory.equivOfFullyFaithful_apply
+#align category_theory.equiv_of_fully_faithful_symm_apply CategoryTheory.equivOfFullyFaithful_symm_apply
 
 /-- If `F` is fully faithful, we have an equivalence of iso-sets `X ≅ Y` and `F X ≅ F Y`. -/
 @[simps]
@@ -182,6 +188,8 @@ def isoEquivOfFullyFaithful {X Y} :
     ext
     simp
 #align category_theory.iso_equiv_of_fully_faithful CategoryTheory.isoEquivOfFullyFaithful
+#align category_theory.iso_equiv_of_fully_faithful_symm_apply CategoryTheory.isoEquivOfFullyFaithful_symm_apply
+#align category_theory.iso_equiv_of_fully_faithful_apply CategoryTheory.isoEquivOfFullyFaithful_apply
 
 end
 
@@ -200,6 +208,7 @@ def natTransOfCompFullyFaithful (α : F ⋙ H ⟶ G ⋙ H) :
     apply H.map_injective
     simpa using α.naturality f
 #align category_theory.nat_trans_of_comp_fully_faithful CategoryTheory.natTransOfCompFullyFaithful
+#align category_theory.nat_trans_of_comp_fully_faithful_app CategoryTheory.natTransOfCompFullyFaithful_app
 
 /-- We can construct a natural isomorphism between functors by constructing a natural isomorphism
 between those functors composed with a fully faithful functor. -/
@@ -210,6 +219,8 @@ def natIsoOfCompFullyFaithful (i : F ⋙ H ≅ G ⋙ H) : F ≅ G :=
     apply H.map_injective
     simpa using i.hom.naturality f
 #align category_theory.nat_iso_of_comp_fully_faithful CategoryTheory.natIsoOfCompFullyFaithful
+#align category_theory.nat_iso_of_comp_fully_faithful_hom_app CategoryTheory.natIsoOfCompFullyFaithful_hom_app
+#align category_theory.nat_iso_of_comp_fully_faithful_inv_app CategoryTheory.natIsoOfCompFullyFaithful_inv_app
 
 theorem natIsoOfCompFullyFaithful_hom (i : F ⋙ H ≅ G ⋙ H) :
     (natIsoOfCompFullyFaithful H i).hom = natTransOfCompFullyFaithful H i.hom := by
@@ -233,6 +244,8 @@ def NatTrans.equivOfCompFullyFaithful :
   left_inv := by aesop_cat
   right_inv := by aesop_cat
 #align category_theory.nat_trans.equiv_of_comp_fully_faithful CategoryTheory.NatTrans.equivOfCompFullyFaithful
+#align category_theory.nat_trans.equiv_of_comp_fully_faithful_apply CategoryTheory.NatTrans.equivOfCompFullyFaithful_apply
+#align category_theory.nat_trans.equiv_of_comp_fully_faithful_symm_apply CategoryTheory.NatTrans.equivOfCompFullyFaithful_symm_apply
 
 /-- Horizontal composition with a fully faithful functor induces a bijection on
 natural isomorphisms. -/
@@ -244,6 +257,8 @@ def NatIso.equivOfCompFullyFaithful :
   left_inv := by aesop_cat
   right_inv := by aesop_cat
 #align category_theory.nat_iso.equiv_of_comp_fully_faithful CategoryTheory.NatIso.equivOfCompFullyFaithful
+#align category_theory.nat_iso.equiv_of_comp_fully_faithful_symm_apply CategoryTheory.NatIso.equivOfCompFullyFaithful_symm_apply
+#align category_theory.nat_iso.equiv_of_comp_fully_faithful_apply CategoryTheory.NatIso.equivOfCompFullyFaithful_apply
 
 end
 
@@ -297,6 +312,7 @@ theorem Faithful.of_comp_iso {H : C ⥤ E} [Faithful H] (h : F ⋙ G ≅ H) : Fa
 #align category_theory.faithful.of_comp_iso CategoryTheory.Faithful.of_comp_iso
 
 alias Faithful.of_comp_iso ← _root_.CategoryTheory.Iso.faithful_of_comp
+#align category_theory.iso.faithful_of_comp CategoryTheory.Iso.faithful_of_comp
 
 -- We could prove this from `Faithful.of_comp_iso` using `eq_to_iso`,
 -- but that would introduce a cyclic import.
@@ -305,6 +321,7 @@ theorem Faithful.of_comp_eq {H : C ⥤ E} [ℋ : Faithful H] (h : F ⋙ G = H) :
 #align category_theory.faithful.of_comp_eq CategoryTheory.Faithful.of_comp_eq
 
 alias Faithful.of_comp_eq ← _root_.Eq.faithful_of_comp
+#align eq.faithful_of_comp Eq.faithful_of_comp
 
 variable (F G)
 /-- “Divide” a functor by a faithful functor. -/

70d50ecf

chore: the style linter shouldn't complain about long #align lines (#1643)

54af0498

Diff

@@ -215,15 +215,13 @@ theorem natIsoOfCompFullyFaithful_hom (i : F ⋙ H ≅ G ⋙ H) :
     (natIsoOfCompFullyFaithful H i).hom = natTransOfCompFullyFaithful H i.hom := by
   ext
   simp [natIsoOfCompFullyFaithful]
-#align
-  category_theory.nat_iso_of_comp_fully_faithful_hom CategoryTheory.natIsoOfCompFullyFaithful_hom
+#align category_theory.nat_iso_of_comp_fully_faithful_hom CategoryTheory.natIsoOfCompFullyFaithful_hom
 
 theorem natIsoOfCompFullyFaithful_inv (i : F ⋙ H ≅ G ⋙ H) :
     (natIsoOfCompFullyFaithful H i).inv = natTransOfCompFullyFaithful H i.inv := by
   ext
   simp [← preimage_comp]
-#align
-  category_theory.nat_iso_of_comp_fully_faithful_inv CategoryTheory.natIsoOfCompFullyFaithful_inv
+#align category_theory.nat_iso_of_comp_fully_faithful_inv CategoryTheory.natIsoOfCompFullyFaithful_inv
 
 /-- Horizontal composition with a fully faithful functor induces a bijection on
 natural transformations. -/
@@ -234,9 +232,7 @@ def NatTrans.equivOfCompFullyFaithful :
   invFun := natTransOfCompFullyFaithful H
   left_inv := by aesop_cat
   right_inv := by aesop_cat
-#align
-  category_theory.nat_trans.equiv_of_comp_fully_faithful
-  CategoryTheory.NatTrans.equivOfCompFullyFaithful
+#align category_theory.nat_trans.equiv_of_comp_fully_faithful CategoryTheory.NatTrans.equivOfCompFullyFaithful
 
 /-- Horizontal composition with a fully faithful functor induces a bijection on
 natural isomorphisms. -/
@@ -247,9 +243,7 @@ def NatIso.equivOfCompFullyFaithful :
   invFun := natIsoOfCompFullyFaithful H
   left_inv := by aesop_cat
   right_inv := by aesop_cat
-#align
-  category_theory.nat_iso.equiv_of_comp_fully_faithful
-  CategoryTheory.NatIso.equivOfCompFullyFaithful
+#align category_theory.nat_iso.equiv_of_comp_fully_faithful CategoryTheory.NatIso.equivOfCompFullyFaithful
 
 end
 
@@ -393,17 +387,13 @@ theorem fullyFaithfulCancelRight_hom_app {F G : C ⥤ D} {H : D ⥤ E} [Full H]
     (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
     (fullyFaithfulCancelRight H comp_iso).hom.app X = H.preimage (comp_iso.hom.app X) :=
   rfl
-#align
-  category_theory.fully_faithful_cancel_right_hom_app
-  CategoryTheory.fullyFaithfulCancelRight_hom_app
+#align category_theory.fully_faithful_cancel_right_hom_app CategoryTheory.fullyFaithfulCancelRight_hom_app
 
 @[simp]
 theorem fullyFaithfulCancelRight_inv_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [Faithful H]
     (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
     (fullyFaithfulCancelRight H comp_iso).inv.app X = H.preimage (comp_iso.inv.app X) :=
   rfl
-#align
-  category_theory.fully_faithful_cancel_right_inv_app
-  CategoryTheory.fullyFaithfulCancelRight_inv_app
+#align category_theory.fully_faithful_cancel_right_inv_app CategoryTheory.fullyFaithfulCancelRight_inv_app
 
 end CategoryTheory

70d50ecf

chore: tidy various files (#1145)

2a588a7d

Diff

@@ -323,8 +323,8 @@ protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C →
       apply G.map_injective
       apply eq_of_heq
       trans F.map (𝟙 X)
-      exact h_map
-      rw [F.map_id, G.map_id, h_obj X]
+      · exact h_map
+      · rw [F.map_id, G.map_id, h_obj X]
     map_comp := by
       intros X Y Z f g
       refine G.map_injective <| eq_of_heq <| h_map.trans ?_

70d50ecf

fix: improved transitivity, handles HEq.trans (#1125)

Transitivity handles heterogeneous cases and premutations of parameters. Fixes #1119

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

047ae09b

Diff

@@ -320,17 +320,11 @@ protected def Faithful.div (F : C ⥤ E) (G : D ⥤ E) [Faithful G] (obj : C →
   { obj, map := @map,
     map_id := by
       intros X
-      -- Porting note: The mathlib3 proof uses the `trans` tactic, which didn't work.
-      -- See https://github.com/leanprover-community/mathlib4/issues/1119
-      -- apply G.map_injective
-      -- apply eq_of_heq
-      -- trans F.map (𝟙 X)
-      -- exact h_map
-      -- rw [F.map_id, G.map_id, h_obj X]
-      refine G.map_injective <| eq_of_heq <| h_map.trans ?_
-      simp only [Functor.map_id]
-      convert HEq.refl (𝟙 (F.obj X))
-      all_goals { apply h_obj }
+      apply G.map_injective
+      apply eq_of_heq
+      trans F.map (𝟙 X)
+      exact h_map
+      rw [F.map_id, G.map_id, h_obj X]
     map_comp := by
       intros X Y Z f g
       refine G.map_injective <| eq_of_heq <| h_map.trans ?_

70d50ecf

feat: port CategoryTheory.Functor.FullyFaithful (#846)

mathlib SHA: 70d50ecf

Porting notes:

~~aesop_cat was unable to close goals that tidy was able to. I left an example proof of what tidy emits (with some cleanup).~~
unfold_projs is not ported. Is it an easy tactic to port over or is there a better "lean4" way? (ed: not needed)
trans doesn't seem to work with HEq (see https://github.com/leanprover-community/mathlib4/issues/1119)
Some documentation is needed for Full and Faithful. Please feel free to fill it in if you wish.

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

bf9d2899

`category_theory.functor.fully_faithful` ⟷ `Mathlib.CategoryTheory.Functor.FullyFaithful`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 5

category_theory.functor.fully_faithful ⟷ Mathlib.CategoryTheory.Functor.FullyFaithful

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 5

`category_theory.functor.fully_faithful` ⟷ `Mathlib.CategoryTheory.Functor.FullyFaithful`