ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.ChosenFiniteProducts.associator_hom_snd_snd
@[reassoc (attr := simp)]
lemma associator_hom_snd_snd (X Y Z : C) :
    (α_ X Y Z).hom ≫ snd _ _ ≫ snd _ _ = snd _ _  
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ChosenFiniteProducts C] (X Y Z : C)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).hom
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.ChosenFiniteProducts.snd X (CategoryTheory.MonoidalCategory.tensorObj Y Z))
      (CategoryTheory.ChosenFiniteProducts.snd Y Z)) =
  CategoryTheory.ChosenFiniteProducts.snd (CategoryTheory.MonoidalCategory.tensorObj X Y) Z
-- CategoryTheory.ChosenFiniteProducts.associator_inv_fst
@[reassoc (attr := simp)]
lemma associator_inv_fst (X Y Z : C) :
    (α_ X Y Z).inv ≫ fst _ _ ≫ fst _ _ = fst _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ChosenFiniteProducts C] (X Y Z : C)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).inv
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.ChosenFiniteProducts.fst (CategoryTheory.MonoidalCategory.tensorObj X Y) Z)
      (CategoryTheory.ChosenFiniteProducts.fst X Y)) =
  CategoryTheory.ChosenFiniteProducts.fst X (CategoryTheory.MonoidalCategory.tensorObj Y Z)
-- CategoryTheory.ChosenFiniteProducts.associator_inv_fst_snd
@[reassoc (attr := simp)]
lemma associator_inv_fst_snd (X Y Z : C) :
    (α_ X Y Z).inv ≫ fst _ _ ≫ snd _ _ = snd _ _ ≫ fst _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ChosenFiniteProducts C] (X Y Z : C)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).inv
    (CategoryTheory.CategoryStruct.comp
      (CategoryTheory.ChosenFiniteProducts.fst (CategoryTheory.MonoidalCategory.tensorObj X Y) Z)
      (CategoryTheory.ChosenFiniteProducts.snd X Y)) =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.ChosenFiniteProducts.snd X (CategoryTheory.MonoidalCategory.tensorObj Y Z))
    (CategoryTheory.ChosenFiniteProducts.fst Y Z)
-- CategoryTheory.ChosenFiniteProducts.associator_inv_snd
@[reassoc (attr := simp)]
lemma associator_inv_snd (X Y Z : C) :
    (α_ X Y Z).inv ≫ snd _ _ = snd _ _ ≫ snd _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ChosenFiniteProducts C] (X Y Z : C)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator X Y Z).inv
    (CategoryTheory.ChosenFiniteProducts.snd (CategoryTheory.MonoidalCategory.tensorObj X Y) Z) =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.ChosenFiniteProducts.snd X (CategoryTheory.MonoidalCategory.tensorObj Y Z))
    (CategoryTheory.ChosenFiniteProducts.snd Y Z)
-- CategoryTheory.Component.ι_map
@[simps!]
def Component.ι (j : ConnectedComponents J) : Component j ⥤ J 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] (j : CategoryTheory.ConnectedComponents J)
Goal: ∀ {X Y : CategoryTheory.InducedCategory J CategoryTheory.FullSubcategory.obj} (f : X ⟶ Y),
  (CategoryTheory.Component.ι j).map f = f
-- CategoryTheory.Component.ι_obj
@[simps!]
def Component.ι (j : ConnectedComponents J) : Component j ⥤ J 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] (j : CategoryTheory.ConnectedComponents J) (self : CategoryTheory.FullSubcategory fun k => Quotient.mk'' k = j)
Goal: (CategoryTheory.Component.ι j).obj self = self.obj
-- CategoryTheory.decomposedTo_map
@[simps!]
def decomposedTo (J : Type u₁) [Category.{v₁} J] : Decomposed J ⥤ J 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J]
Goal: ∀ {X Y : (i : CategoryTheory.ConnectedComponents J) × CategoryTheory.Component i} (g : X ⟶ Y),
  (CategoryTheory.decomposedTo J).map g = CategoryTheory.Sigma.descMap CategoryTheory.Component.ι X Y g
-- CategoryTheory.decomposedTo_obj
@[simps!]
def decomposedTo (J : Type u₁) [Category.{v₁} J] : Decomposed J ⥤ J 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] (X : (i : CategoryTheory.ConnectedComponents J) × CategoryTheory.Component i)
Goal: (CategoryTheory.decomposedTo J).obj X = X.snd.obj
-- CategoryTheory.inclusion_comp_decomposedTo
@[simp]
theorem inclusion_comp_decomposedTo (j : ConnectedComponents J) :
    inclusion j ⋙ decomposedTo J = Component.ι j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] (j : CategoryTheory.ConnectedComponents J)
Goal: (CategoryTheory.inclusion j).comp (CategoryTheory.decomposedTo J) = CategoryTheory.Component.ι j
-- CategoryTheory.decomposedEquiv_functor
@[simps! functor]
def decomposedEquiv : Decomposed J ≌ J 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J]
Goal: CategoryTheory.decomposedEquiv.functor = CategoryTheory.decomposedTo J
-- CategoryTheory.Functor.Full.map_surjective
class Full (F : C ⥤ D) : Prop where
  map_surjective {X Y : C} : Function.Surjective (F.map (X := X) (Y := Y))
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [self : F.Full] {X Y : C}
Goal: Function.Surjective F.map
-- CategoryTheory.Functor.Faithful.map_injective
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
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} [self : F.Faithful] {X Y : C}
Goal: Function.Injective F.map
-- CategoryTheory.Functor.map_injective
theorem map_injective (F : C ⥤ D) [Faithful F] :
    Function.Injective <| (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X Y : C} (F : CategoryTheory.Functor C D) [F.Faithful]
Goal: Function.Injective F.map
-- CategoryTheory.Functor.map_injective_iff
lemma map_injective_iff (F : C ⥤ D) [Faithful F] {X Y : C} (f g : X ⟶ Y) :
    F.map f = F.map g ↔ f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Faithful] {X Y : C} (f g : X ⟶ Y)
Goal: F.map f = F.map g ↔ f = g
-- CategoryTheory.Functor.mapIso_injective
theorem mapIso_injective (F : C ⥤ D) [Faithful F] :
    Function.Injective <| (F.mapIso : (X ≅ Y) → (F.obj X ≅ F.obj Y))  
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X Y : C} (F : CategoryTheory.Functor C D) [F.Faithful]
Goal: Function.Injective F.mapIso
-- CategoryTheory.Functor.map_surjective
theorem map_surjective (F : C ⥤ D) [Full F] :
    Function.Surjective (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X Y : C} (F : CategoryTheory.Functor C D) [F.Full]
Goal: Function.Surjective F.map
-- CategoryTheory.Functor.map_preimage
@[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 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Full] {X Y : C} (f : F.obj X ⟶ F.obj Y)
Goal: F.map (F.preimage f) = f
-- CategoryTheory.Functor.preimage_id
@[simp]
theorem preimage_id : F.preimage (𝟙 (F.obj X)) = 𝟙 X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {X : C} [F.Full] [F.Faithful]
Goal: F.preimage (CategoryTheory.CategoryStruct.id (F.obj X)) = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Functor.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 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {X Y Z : C} [F.Full] [F.Faithful] (f : F.obj X ⟶ F.obj Y) (g : F.obj Y ⟶ F.obj Z)
Goal: F.preimage (CategoryTheory.CategoryStruct.comp f g) = CategoryTheory.CategoryStruct.comp (F.preimage f) (F.preimage g)
-- CategoryTheory.Functor.preimage_map
@[simp]
theorem preimage_map (f : X ⟶ Y) : F.preimage (F.map f) = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {X Y : C} [F.Full] [F.Faithful] (f : X ⟶ Y)
Goal: F.preimage (F.map f) = f
-- CategoryTheory.Functor.preimageIso_inv
@[simps]
noncomputable def preimageIso (f : F.obj X ≅ F.obj Y) :
    X ≅ Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} [F.Full] [F.Faithful] (f : F.obj X ≅ F.obj Y)
Goal: (F.preimageIso f).inv = F.preimage f.inv
-- CategoryTheory.Functor.preimageIso_hom
@[simps]
noncomputable def preimageIso (f : F.obj X ≅ F.obj Y) :
    X ≅ Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} [F.Full] [F.Faithful] (f : F.obj X ≅ F.obj Y)
Goal: (F.preimageIso f).hom = F.preimage f.hom
-- CategoryTheory.Functor.preimageIso_mapIso
@[simp]
theorem preimageIso_mapIso (f : X ≅ Y) : F.preimageIso (F.mapIso f) = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) {X Y : C} [F.Full] [F.Faithful] (f : X ≅ Y)
Goal: F.preimageIso (F.mapIso f) = f
-- CategoryTheory.Functor.FullyFaithful.map_preimage
structure FullyFaithful where
    preimage {X Y : C} (f : F.obj X ⟶ F.obj Y) : X ⟶ Y
  map_preimage {X Y : C} (f : F.obj X ⟶ F.obj Y) : F.map (preimage f) = f := by aesop_cat
  preimage_map {X Y : C} (f : X ⟶ Y) : preimage (F.map f) = f := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (self : F.FullyFaithful) {X Y : C} (f : F.obj X ⟶ F.obj Y)
Goal: F.map (self.preimage f) = f
-- CategoryTheory.Functor.FullyFaithful.preimage_map
structure FullyFaithful where
    preimage {X Y : C} (f : F.obj X ⟶ F.obj Y) : X ⟶ Y
  map_preimage {X Y : C} (f : F.obj X ⟶ F.obj Y) : F.map (preimage f) = f := by aesop_cat
  preimage_map {X Y : C} (f : X ⟶ Y) : preimage (F.map f) = f := by aesop_cat
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (self : F.FullyFaithful) {X Y : C} (f : X ⟶ Y)
Goal: self.preimage (F.map f) = f
-- CategoryTheory.Functor.FullyFaithful.id_preimage
@[simps]
def id : (𝟭 C).FullyFaithful 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : C} (f : (CategoryTheory.Functor.id C).obj X ⟶ (CategoryTheory.Functor.id C).obj Y),
  (CategoryTheory.Functor.FullyFaithful.id C).preimage f = f
-- CategoryTheory.Functor.FullyFaithful.homEquiv_apply
@[simps]
def homEquiv {X Y : C} : (X ⟶ Y) ≃ (F.obj X ⟶ F.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C}
Goal: ∀ (a : X ⟶ Y), hF.homEquiv a = F.map a
-- CategoryTheory.Functor.FullyFaithful.homEquiv_symm_apply
@[simps]
def homEquiv {X Y : C} : (X ⟶ Y) ≃ (F.obj X ⟶ F.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C} (f : F.obj X ⟶ F.obj Y)
Goal: hF.homEquiv.symm f = hF.preimage f
-- CategoryTheory.Functor.FullyFaithful.map_injective
lemma map_injective {X Y : C} {f g : X ⟶ Y} (h : F.map f = F.map g) : f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C} {f g : X ⟶ Y} (h : F.map f = F.map g)
Goal: f = g
-- CategoryTheory.Functor.FullyFaithful.map_surjective
lemma map_surjective {X Y : C} :
    Function.Surjective (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C}
Goal: Function.Surjective F.map
-- CategoryTheory.Functor.FullyFaithful.map_bijective
lemma map_bijective (X Y : C) :
    Function.Bijective (F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (X Y : C)
Goal: Function.Bijective F.map
-- CategoryTheory.Functor.FullyFaithful.full
lemma full : F.Full 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful)
Goal: F.Full
-- CategoryTheory.Functor.FullyFaithful.faithful
lemma faithful : F.Faithful 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful)
Goal: F.Faithful
-- CategoryTheory.Functor.FullyFaithful.preimageIso_hom
@[simps]
def preimageIso {X Y : C} (e : F.obj X ≅ F.obj Y) : X ≅ Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C} (e : F.obj X ≅ F.obj Y)
Goal: (hF.preimageIso e).hom = hF.preimage e.hom
-- CategoryTheory.Functor.FullyFaithful.preimageIso_inv
@[simps]
def preimageIso {X Y : C} (e : F.obj X ≅ F.obj Y) : X ≅ Y 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C} (e : F.obj X ≅ F.obj Y)
Goal: (hF.preimageIso e).inv = hF.preimage e.inv
-- CategoryTheory.Functor.FullyFaithful.isIso_of_isIso_map
lemma isIso_of_isIso_map (hF : F.FullyFaithful) {X Y : C} (f : X ⟶ Y) [IsIso (F.map f)] :
    IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso (F.map f)]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Functor.FullyFaithful.isoEquiv_symm_apply
@[simps]
def isoEquiv {X Y : C} : (X ≅ Y) ≃ (F.obj X ≅ F.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C} (e : F.obj X ≅ F.obj Y)
Goal: hF.isoEquiv.symm e = hF.preimageIso e
-- CategoryTheory.Functor.FullyFaithful.isoEquiv_apply
@[simps]
def isoEquiv {X Y : C} : (X ≅ Y) ≃ (F.obj X ≅ F.obj Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C} (i : X ≅ Y)
Goal: hF.isoEquiv i = F.mapIso i
-- CategoryTheory.Functor.FullyFaithful.comp_preimage
@[simps]
def comp {G : D ⥤ E} (hG : G.FullyFaithful) : (F ⋙ G).FullyFaithful 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {G : CategoryTheory.Functor D E} (hG : G.FullyFaithful)
Goal: ∀ {X Y : C} (f : (F.comp G).obj X ⟶ (F.comp G).obj Y), (hF.comp hG).preimage f = hF.preimage (hG.preimage f)
-- CategoryTheory.isIso_of_fully_faithful
theorem isIso_of_fully_faithful (f : X ⟶ Y) [IsIso (F.map f)] : IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) [F.Full] [F.Faithful] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso (F.map f)]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Functor.Faithful.of_comp
theorem Faithful.of_comp [(F ⋙ G).Faithful] : F.Faithful 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [(F.comp G).Faithful]
Goal: F.Faithful
-- CategoryTheory.Functor.Full.of_iso
lemma Full.of_iso [Full F] (α : F ≅ F') : Full F' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D} [F.Full] (α : F ≅ F')
Goal: F'.Full
-- CategoryTheory.Functor.Faithful.of_iso
theorem Faithful.of_iso [F.Faithful] (α : F ≅ F') : F'.Faithful 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F F' : CategoryTheory.Functor C D} [F.Faithful] (α : F ≅ F')
Goal: F'.Faithful
-- CategoryTheory.Functor.Faithful.of_comp_iso
theorem Faithful.of_comp_iso {H : C ⥤ E} [H.Faithful] (h : F ⋙ G ≅ H) : F.Faithful 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [H.Faithful] (h : F.comp G ≅ H)
Goal: F.Faithful
-- CategoryTheory.Functor.Faithful.of_comp_eq
theorem Faithful.of_comp_eq {H : C ⥤ E} [ℋ : H.Faithful] (h : F ⋙ G = H) : F.Faithful 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [ℋ : H.Faithful] (h : F.comp G = H)
Goal: F.Faithful
-- CategoryTheory.Functor.Faithful.div_comp
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 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C E) [F.Faithful] (G : CategoryTheory.Functor D E) [G.Faithful] (obj : C → D) (h_obj : ∀ (X : C), G.obj (obj X) = F.obj X) (map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)) (h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f))
Goal: (CategoryTheory.Functor.Faithful.div F G obj h_obj map h_map).comp G = F
-- CategoryTheory.Functor.Faithful.div_faithful
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)) :
    Functor.Faithful (Faithful.div F G obj @h_obj @map @h_map) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C E) [F.Faithful] (G : CategoryTheory.Functor D E) [G.Faithful] (obj : C → D) (h_obj : ∀ (X : C), G.obj (obj X) = F.obj X) (map : {X Y : C} → (X ⟶ Y) → (obj X ⟶ obj Y)) (h_map : ∀ {X Y : C} {f : X ⟶ Y}, HEq (G.map (map f)) (F.map f))
Goal: (CategoryTheory.Functor.Faithful.div F G obj h_obj map h_map).Faithful
-- CategoryTheory.Functor.Full.of_comp_faithful
lemma Full.of_comp_faithful [Full <| F ⋙ G] [G.Faithful] : Full F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [(F.comp G).Full] [G.Faithful]
Goal: F.Full
-- CategoryTheory.Functor.Full.of_comp_faithful_iso
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 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [H.Full] [G.Faithful] (h : F.comp G ≅ H)
Goal: F.Full
-- CategoryTheory.Functor.fullyFaithfulCancelRight_hom_app
@[simp]
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) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F G : CategoryTheory.Functor C D} {H : CategoryTheory.Functor D E} [H.Full] [H.Faithful] (comp_iso : F.comp H ≅ G.comp H) (X : C)
Goal: (CategoryTheory.Functor.fullyFaithfulCancelRight H comp_iso).hom.app X = H.preimage (comp_iso.hom.app X)
-- CategoryTheory.Functor.fullyFaithfulCancelRight_inv_app
@[simp]
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) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {E : Type u₃} [CategoryTheory.Category.{v₃, u₃} E] {F G : CategoryTheory.Functor C D} {H : CategoryTheory.Functor D E} [H.Full] [H.Faithful] (comp_iso : F.comp H ≅ G.comp H) (X : C)
Goal: (CategoryTheory.Functor.fullyFaithfulCancelRight H comp_iso).inv.app X = H.preimage (comp_iso.inv.app X)
-- CategoryTheory.EssentiallySmall.equiv_smallCategory
@[pp_with_univ]
class EssentiallySmall (C : Type u) [Category.{v} C] : Prop where
    equiv_smallCategory : ∃ (S : Type w) (_ : SmallCategory S), Nonempty (C ≌ S)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.EssentiallySmall.{w, v, u} C]
Goal: ∃ S x, Nonempty (C ≌ S)
-- CategoryTheory.EssentiallySmall.mk'
theorem EssentiallySmall.mk' {C : Type u} [Category.{v} C] {S : Type w} [SmallCategory S]
    (e : C ≌ S) : EssentiallySmall.{w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {S : Type w} [CategoryTheory.SmallCategory S] (e : C ≌ S)
Goal: CategoryTheory.EssentiallySmall.{w, v, u} C
-- CategoryTheory.essentiallySmall_congr
theorem essentiallySmall_congr {C : Type u} [Category.{v} C] {D : Type u'} [Category.{v'} D]
    (e : C ≌ D) : EssentiallySmall.{w} C ↔ EssentiallySmall.{w} D 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (e : C ≌ D)
Goal: CategoryTheory.EssentiallySmall.{w, v, u} C ↔ CategoryTheory.EssentiallySmall.{w, v', u'} D
-- CategoryTheory.Discrete.essentiallySmallOfSmall
theorem Discrete.essentiallySmallOfSmall {α : Type u} [Small.{w} α] :
    EssentiallySmall.{w} (Discrete α) 
Arguments: {α : Type u} [Small.{w, u} α]
Goal: CategoryTheory.EssentiallySmall.{w, u, u} (CategoryTheory.Discrete α)
-- CategoryTheory.essentiallySmallSelf
theorem essentiallySmallSelf : EssentiallySmall.{max w v u} C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C]
Goal: CategoryTheory.EssentiallySmall.{max w v u, v, u} C
-- CategoryTheory.LocallySmall.hom_small
@[pp_with_univ]
class LocallySmall (C : Type u) [Category.{v} C] : Prop where
    hom_small : ∀ X Y : C, Small.{w} (X ⟶ Y) := by infer_instance
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.LocallySmall.{w, v, u} C] (X Y : C)
Goal: Small.{w, v} (X ⟶ Y)
-- CategoryTheory.locallySmall_of_faithful
theorem locallySmall_of_faithful {C : Type u} [Category.{v} C] {D : Type u'} [Category.{v'} D]
    (F : C ⥤ D) [F.Faithful] [LocallySmall.{w} D] : LocallySmall.{w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : C ⥤ D) [F.Faithful] [CategoryTheory.LocallySmall.{w, v', u'} D]
Goal: CategoryTheory.LocallySmall.{w, v, u} C