ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Adjunction.functorialityUnit_app_hom
@[simps]
def functorialityUnit :
    𝟭 (Cocone K) ⟶ Cocones.functoriality _ F ⋙ functorialityRightAdjoint adj K 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) (c : CategoryTheory.Limits.Cocone K)
Goal: ((adj.functorialityUnit K).app c).hom = adj.unit.app c.pt
-- CategoryTheory.Adjunction.functorialityCounit_app_hom
@[simps]
def functorialityCounit :
    functorialityRightAdjoint adj K ⋙ Cocones.functoriality _ F ⟶ 𝟭 (Cocone (K ⋙ F)) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) (c : CategoryTheory.Limits.Cocone (K.comp F))
Goal: ((adj.functorialityCounit K).app c).hom = adj.counit.app c.pt
-- CategoryTheory.Adjunction.hasColimit_comp_equivalence
theorem hasColimit_comp_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimit K] :
    HasColimit (K ⋙ E) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) (E : CategoryTheory.Functor C D) [E.IsEquivalence] [CategoryTheory.Limits.HasColimit K]
Goal: CategoryTheory.Limits.HasColimit (K.comp E)
-- CategoryTheory.Adjunction.hasColimit_of_comp_equivalence
theorem hasColimit_of_comp_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimit (K ⋙ E)] :
    HasColimit K 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) (E : CategoryTheory.Functor C D) [E.IsEquivalence] [CategoryTheory.Limits.HasColimit (K.comp E)]
Goal: CategoryTheory.Limits.HasColimit K
-- CategoryTheory.Adjunction.hasColimitsOfShape_of_equivalence
theorem hasColimitsOfShape_of_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimitsOfShape J D] :
    HasColimitsOfShape J C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (E : CategoryTheory.Functor C D) [E.IsEquivalence] [CategoryTheory.Limits.HasColimitsOfShape J D]
Goal: CategoryTheory.Limits.HasColimitsOfShape J C
-- CategoryTheory.Adjunction.has_colimits_of_equivalence
theorem has_colimits_of_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimitsOfSize.{v, u} D] :
    HasColimitsOfSize.{v, u} C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (E : CategoryTheory.Functor C D) [E.IsEquivalence] [CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₂, u₂} D]
Goal: CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₁, u₁} C
-- CategoryTheory.Adjunction.functorialityUnit'_app_hom
@[simps]
def functorialityUnit' :
    𝟭 (Cone (K ⋙ G)) ⟶ functorialityLeftAdjoint adj K ⋙ Cones.functoriality _ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) (c : CategoryTheory.Limits.Cone (K.comp G))
Goal: ((adj.functorialityUnit' K).app c).hom = adj.unit.app c.pt
-- CategoryTheory.Adjunction.functorialityCounit'_app_hom
@[simps]
def functorialityCounit' :
    Cones.functoriality _ G ⋙ functorialityLeftAdjoint adj K ⟶ 𝟭 (Cone K) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) (c : CategoryTheory.Limits.Cone K)
Goal: ((adj.functorialityCounit' K).app c).hom = adj.counit.app c.pt
-- CategoryTheory.Adjunction.hasLimit_comp_equivalence
theorem hasLimit_comp_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimit K] : HasLimit (K ⋙ E) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) (E : CategoryTheory.Functor D C) [E.IsEquivalence] [CategoryTheory.Limits.HasLimit K]
Goal: CategoryTheory.Limits.HasLimit (K.comp E)
-- CategoryTheory.Adjunction.hasLimit_of_comp_equivalence
theorem hasLimit_of_comp_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimit (K ⋙ E)] :
    HasLimit K 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) (E : CategoryTheory.Functor D C) [E.IsEquivalence] [CategoryTheory.Limits.HasLimit (K.comp E)]
Goal: CategoryTheory.Limits.HasLimit K
-- CategoryTheory.Adjunction.hasLimitsOfShape_of_equivalence
theorem hasLimitsOfShape_of_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimitsOfShape J C] :
    HasLimitsOfShape J D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (E : CategoryTheory.Functor D C) [E.IsEquivalence] [CategoryTheory.Limits.HasLimitsOfShape J C]
Goal: CategoryTheory.Limits.HasLimitsOfShape J D
-- CategoryTheory.Adjunction.has_limits_of_equivalence
theorem has_limits_of_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimitsOfSize.{v, u} C] :
    HasLimitsOfSize.{v, u} D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (E : CategoryTheory.Functor D C) [E.IsEquivalence] [CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₁, u₁} C]
Goal: CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₂, u₂} D
-- CategoryTheory.Groupoid.isIsomorphic_iff_nonempty_hom
theorem Groupoid.isIsomorphic_iff_nonempty_hom {C : Type u} [Groupoid.{v} C] {X Y : C} :
    IsIsomorphic X Y ↔ Nonempty (X ⟶ Y) 
Arguments: {C : Type u} [CategoryTheory.Groupoid C] {X Y : C}
Goal: CategoryTheory.IsIsomorphic X Y ↔ Nonempty (X ⟶ Y)
-- CategoryTheory.Abelian.has_kernels
class Abelian extends Preadditive C, NormalMonoCategory C, NormalEpiCategory C where
  [has_finite_products : HasFiniteProducts C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Abelian C]
Goal: CategoryTheory.Limits.HasKernels C
-- CategoryTheory.Abelian.has_cokernels
class Abelian extends Preadditive C, NormalMonoCategory C, NormalEpiCategory C where
  [has_finite_products : HasFiniteProducts C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Abelian C]
Goal: CategoryTheory.Limits.HasCokernels C
-- CategoryTheory.Abelian.has_finite_products
class Abelian extends Preadditive C, NormalMonoCategory C, NormalEpiCategory C where
  [has_finite_products : HasFiniteProducts C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Abelian C]
Goal: CategoryTheory.Limits.HasFiniteProducts C
-- CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation_e
@[simps]
def imageMonoFactorisation {X Y : C} (f : X ⟶ Y) : MonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation f).e =
  CategoryTheory.Limits.kernel.lift (CategoryTheory.Limits.cokernel.π f) f ⋯
-- CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation_m
@[simps]
def imageMonoFactorisation {X Y : C} (f : X ⟶ Y) : MonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation f).m =
  CategoryTheory.Limits.kernel.ι (CategoryTheory.Limits.cokernel.π f)
-- CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation_I
@[simps]
def imageMonoFactorisation {X Y : C} (f : X ⟶ Y) : MonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation f).I = CategoryTheory.Abelian.image f
-- CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation_e'
theorem imageMonoFactorisation_e' {X Y : C} (f : X ⟶ Y) :
    (imageMonoFactorisation f).e = cokernel.π _ ≫ Abelian.coimageImageComparison f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation f).e =
  CategoryTheory.Limits.cokernel.π (CategoryTheory.Limits.kernel.ι f) ≫ CategoryTheory.Abelian.coimageImageComparison f
-- CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.hasImages
theorem hasImages : HasImages C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C] [∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.IsIso (CategoryTheory.Abelian.coimageImageComparison f)]
Goal: CategoryTheory.Limits.HasImages C
-- CategoryTheory.Abelian.hasFiniteBiproducts
theorem hasFiniteBiproducts : HasFiniteBiproducts C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C]
Goal: CategoryTheory.Limits.HasFiniteBiproducts C
-- CategoryTheory.Abelian.mono_of_kernel_ι_eq_zero
theorem mono_of_kernel_ι_eq_zero (h : kernel.ι f = 0) : Mono f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q) (h : CategoryTheory.Limits.kernel.ι f = 0)
Goal: CategoryTheory.Mono f
-- CategoryTheory.Abelian.epi_of_cokernel_π_eq_zero
theorem epi_of_cokernel_π_eq_zero (h : cokernel.π f = 0) : Epi f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q) (h : CategoryTheory.Limits.cokernel.π f = 0)
Goal: CategoryTheory.Epi f
-- CategoryTheory.Abelian.image_ι_comp_eq_zero
theorem image_ι_comp_eq_zero {R : C} {g : Q ⟶ R} (h : f ≫ g = 0) : Abelian.image.ι f ≫ g = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} {f : P ⟶ Q} {R : C} {g : Q ⟶ R} (h : f ≫ g = 0)
Goal: CategoryTheory.Abelian.image.ι f ≫ g = 0
-- CategoryTheory.Abelian.comp_coimage_π_eq_zero
theorem comp_coimage_π_eq_zero {R : C} {g : Q ⟶ R} (h : f ≫ g = 0) : f ≫ Abelian.coimage.π g = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} {f : P ⟶ Q} {R : C} {g : Q ⟶ R} (h : f ≫ g = 0)
Goal: f ≫ CategoryTheory.Abelian.coimage.π g = 0
-- CategoryTheory.Abelian.imageStrongEpiMonoFactorisation_I
@[simps]
def imageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: (CategoryTheory.Abelian.imageStrongEpiMonoFactorisation f).I = CategoryTheory.Abelian.image f
-- CategoryTheory.Abelian.imageStrongEpiMonoFactorisation_e
@[simps]
def imageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: (CategoryTheory.Abelian.imageStrongEpiMonoFactorisation f).e = CategoryTheory.Abelian.factorThruImage f
-- CategoryTheory.Abelian.imageStrongEpiMonoFactorisation_m
@[simps]
def imageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: (CategoryTheory.Abelian.imageStrongEpiMonoFactorisation f).m = CategoryTheory.Abelian.image.ι f
-- CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation_m
@[simps]
def coimageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: (CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation f).m = CategoryTheory.Abelian.factorThruCoimage f
-- CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation_I
@[simps]
def coimageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: (CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation f).I = CategoryTheory.Abelian.coimage f
-- CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation_e
@[simps]
def coimageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: (CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation f).e = CategoryTheory.Abelian.coimage.π f
-- CategoryTheory.Abelian.coimageIsoImage'_hom
theorem coimageIsoImage'_hom :
    (coimageIsoImage' f).hom =
      cokernel.desc _ (factorThruImage f) (by simp [← cancel_mono (Limits.image.ι f)]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Abelian.coimageIsoImage' f).hom =
  CategoryTheory.Limits.cokernel.desc (CategoryTheory.Limits.kernel.ι f) (CategoryTheory.Limits.factorThruImage f) ⋯
-- CategoryTheory.Abelian.factorThruImage_comp_coimageIsoImage'_inv
theorem factorThruImage_comp_coimageIsoImage'_inv :
    factorThruImage f ≫ (coimageIsoImage' f).inv = cokernel.π _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Limits.factorThruImage f ≫ (CategoryTheory.Abelian.coimageIsoImage' f).inv =
  CategoryTheory.Limits.cokernel.π (CategoryTheory.Limits.kernel.ι f)
-- CategoryTheory.Abelian.imageIsoImage_hom_comp_image_ι
theorem imageIsoImage_hom_comp_image_ι : (imageIsoImage f).hom ≫ Limits.image.ι _ = kernel.ι _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Abelian.imageIsoImage f).hom ≫ CategoryTheory.Limits.image.ι f =
  CategoryTheory.Limits.kernel.ι (CategoryTheory.Limits.cokernel.π f)
-- CategoryTheory.Abelian.imageIsoImage_inv
theorem imageIsoImage_inv :
    (imageIsoImage f).inv =
      kernel.lift _ (Limits.image.ι f) (by simp [← cancel_epi (factorThruImage f)]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.Abelian.imageIsoImage f).inv =
  CategoryTheory.Limits.kernel.lift (CategoryTheory.Limits.cokernel.π f) (CategoryTheory.Limits.image.ι f) ⋯
-- CategoryTheory.Abelian.comp_epiDesc
@[reassoc (attr := simp)]
theorem comp_epiDesc [Epi f] {T : C} (g : X ⟶ T) (hg : kernel.ι f ≫ g = 0) :
    f ≫ epiDesc f g hg = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f] {T : C} (g : X ⟶ T) (hg : CategoryTheory.Limits.kernel.ι f ≫ g = 0)
Goal: f ≫ CategoryTheory.Abelian.epiDesc f g hg = g
-- CategoryTheory.Abelian.monoLift_comp
@[reassoc (attr := simp)]
theorem monoLift_comp [Mono f] {T : C} (g : T ⟶ Y) (hg : g ≫ cokernel.π f = 0) :
    monoLift f g hg ≫ f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f] {T : C} (g : T ⟶ Y) (hg : g ≫ CategoryTheory.Limits.cokernel.π f = 0)
Goal: CategoryTheory.Abelian.monoLift f g hg ≫ f = g
-- CategoryTheory.Abelian.epi_snd_of_isLimit
theorem epi_snd_of_isLimit [Epi f] {s : PullbackCone f g} (hs : IsLimit s) : Epi s.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.Limits.HasPullbacks C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Epi f] {s : CategoryTheory.Limits.PullbackCone f g} (hs : CategoryTheory.Limits.IsLimit s)
Goal: CategoryTheory.Epi s.snd
-- CategoryTheory.Abelian.epi_fst_of_isLimit
theorem epi_fst_of_isLimit [Epi g] {s : PullbackCone f g} (hs : IsLimit s) : Epi s.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.Limits.HasPullbacks C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Epi g] {s : CategoryTheory.Limits.PullbackCone f g} (hs : CategoryTheory.Limits.IsLimit s)
Goal: CategoryTheory.Epi s.fst
-- CategoryTheory.Abelian.epi_fst_of_factor_thru_epi_mono_factorization
theorem epi_fst_of_factor_thru_epi_mono_factorization (g₁ : Y ⟶ W) [Epi g₁] (g₂ : W ⟶ Z) [Mono g₂]
    (hg : g₁ ≫ g₂ = g) (f' : X ⟶ W) (hf : f' ≫ g₂ = f) (t : PullbackCone f g) (ht : IsLimit t) :
    Epi t.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.Limits.HasPullbacks C] {W X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (g₁ : Y ⟶ W) [CategoryTheory.Epi g₁] (g₂ : W ⟶ Z) [CategoryTheory.Mono g₂] (hg : g₁ ≫ g₂ = g) (f' : X ⟶ W) (hf : f' ≫ g₂ = f) (t : CategoryTheory.Limits.PullbackCone f g) (ht : CategoryTheory.Limits.IsLimit t)
Goal: CategoryTheory.Epi t.fst
-- CategoryTheory.Abelian.mono_inr_of_isColimit
theorem mono_inr_of_isColimit [Mono f] {s : PushoutCocone f g} (hs : IsColimit s) : Mono s.inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.Limits.HasPushouts C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Mono f] {s : CategoryTheory.Limits.PushoutCocone f g} (hs : CategoryTheory.Limits.IsColimit s)
Goal: CategoryTheory.Mono s.inr
-- CategoryTheory.Abelian.mono_inl_of_isColimit
theorem mono_inl_of_isColimit [Mono g] {s : PushoutCocone f g} (hs : IsColimit s) : Mono s.inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.Limits.HasPushouts C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Mono g] {s : CategoryTheory.Limits.PushoutCocone f g} (hs : CategoryTheory.Limits.IsColimit s)
Goal: CategoryTheory.Mono s.inl
-- CategoryTheory.Abelian.mono_inl_of_factor_thru_epi_mono_factorization
theorem mono_inl_of_factor_thru_epi_mono_factorization (f : X ⟶ Y) (g : X ⟶ Z) (g₁ : X ⟶ W) [Epi g₁]
    (g₂ : W ⟶ Z) [Mono g₂] (hg : g₁ ≫ g₂ = g) (f' : W ⟶ Y) (hf : g₁ ≫ f' = f)
    (t : PushoutCocone f g) (ht : IsColimit t) : Mono t.inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.Limits.HasPushouts C] {W X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) (g₁ : X ⟶ W) [CategoryTheory.Epi g₁] (g₂ : W ⟶ Z) [CategoryTheory.Mono g₂] (hg : g₁ ≫ g₂ = g) (f' : W ⟶ Y) (hf : g₁ ≫ f' = f) (t : CategoryTheory.Limits.PushoutCocone f g) (ht : CategoryTheory.Limits.IsColimit t)
Goal: CategoryTheory.Mono t.inl
-- CategoryTheory.Adjunction.homEquiv_counit
structure Adjunction (F : C ⥤ D) (G : D ⥤ C) where
    homEquiv : ∀ X Y, (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
    unit : 𝟭 C ⟶ F.comp G
    counit : G.comp F ⟶ 𝟭 D
  -- Porting note: It's strange that this `Prop` is being flagged by the `docBlame` linter
    homEquiv_unit : ∀ {X Y f}, (homEquiv X Y) f = (unit : _ ⟶ _).app X ≫ G.map f := by aesop_cat
  -- Porting note: It's strange that this `Prop` is being flagged by the `docBlame` linter
    homEquiv_counit : ∀ {X Y g}, (homEquiv X Y).symm g = F.map g ≫ counit.app 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} {G : CategoryTheory.Functor D C} (self : F ⊣ G) {X : C} {Y : D} {g : X ⟶ G.obj Y}
Goal: (self.homEquiv X Y).symm g = CategoryTheory.CategoryStruct.comp (F.map g) (self.counit.app Y)
-- CategoryTheory.Adjunction.homEquiv_unit
structure Adjunction (F : C ⥤ D) (G : D ⥤ C) where
    homEquiv : ∀ X Y, (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
    unit : 𝟭 C ⟶ F.comp G
    counit : G.comp F ⟶ 𝟭 D
  -- Porting note: It's strange that this `Prop` is being flagged by the `docBlame` linter
    homEquiv_unit : ∀ {X Y f}, (homEquiv X Y) f = (unit : _ ⟶ _).app X ≫ G.map f := by aesop_cat
  -- Porting note: It's strange that this `Prop` is being flagged by the `docBlame` linter
    homEquiv_counit : ∀ {X Y g}, (homEquiv X Y).symm g = F.map g ≫ counit.app 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} {G : CategoryTheory.Functor D C} (self : F ⊣ G) {X : C} {Y : D} {f : F.obj X ⟶ Y}
Goal: (self.homEquiv X Y) f = CategoryTheory.CategoryStruct.comp (self.unit.app X) (G.map f)
-- CategoryTheory.Functor.IsLeftAdjoint.exists_rightAdjoint
class IsLeftAdjoint (left : C ⥤ D) : Prop where
  exists_rightAdjoint : ∃ (right : D ⥤ C), Nonempty (left ⊣ right)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {left : CategoryTheory.Functor C D} [self : left.IsLeftAdjoint]
Goal: ∃ right, Nonempty (left ⊣ right)
-- CategoryTheory.Functor.IsRightAdjoint.exists_leftAdjoint
class IsRightAdjoint (right : D ⥤ C) : Prop where
  exists_leftAdjoint : ∃ (left : C ⥤ D), Nonempty (left ⊣ right)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {right : CategoryTheory.Functor D C} [self : right.IsRightAdjoint]
Goal: ∃ left, Nonempty (left ⊣ right)
-- CategoryTheory.Adjunction.isLeftAdjoint
lemma isLeftAdjoint (adj : F ⊣ G) : F.IsLeftAdjoint 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G)
Goal: F.IsLeftAdjoint
-- CategoryTheory.Adjunction.isRightAdjoint
lemma isRightAdjoint (adj : F ⊣ G) : G.IsRightAdjoint 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G)
Goal: G.IsRightAdjoint
-- CategoryTheory.Adjunction.homEquiv_id
theorem homEquiv_id (X : C) : adj.homEquiv X _ (𝟙 _) = adj.unit.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (X : C)
Goal: (adj.homEquiv X (F.obj X)) (CategoryTheory.CategoryStruct.id (F.obj X)) = adj.unit.app X
-- CategoryTheory.Adjunction.homEquiv_symm_id
theorem homEquiv_symm_id (X : D) : (adj.homEquiv _ X).symm (𝟙 _) = adj.counit.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (X : D)
Goal: (adj.homEquiv (G.obj X) X).symm (CategoryTheory.CategoryStruct.id (G.obj X)) = adj.counit.app X
-- CategoryTheory.Adjunction.homEquiv_naturality_left_symm
@[simp, nolint simpNF]
theorem homEquiv_naturality_left_symm (f : X' ⟶ X) (g : X ⟶ G.obj Y) :
    (adj.homEquiv X' Y).symm (f ≫ g) = F.map f ≫ (adj.homEquiv X Y).symm g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X' X : C} {Y : D} (f : X' ⟶ X) (g : X ⟶ G.obj Y)
Goal: (adj.homEquiv X' Y).symm (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (F.map f) ((adj.homEquiv X Y).symm g)