ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/CategoryTheory/Limits/Preserves/FunctorCategory.lean

full_name: CategoryTheory.FunctorCategory.prodPreservesColimits
code: /-- If `X × -` preserves colimits in `D` for any `X : D`, then the product functor `F ⨯ -` for
`F : C ⥤ D` also preserves colimits.

Note this is (mathematically) a special case of the statement that
"if limits commute with colimits in `D`, then they do as well in `C ⥤ D`"
but the story in Lean is a bit more complex, and this statement isn't directly a special case.
That is, even with a formalised proof of the general statement, there would still need to be some
work to convert to this version: namely, the natural isomorphism
`(evaluation C D).obj k ⋙ prod.functor.obj (F.obj k) ≅
  prod.functor.obj F ⋙ (evaluation C D).obj k`
-/
def FunctorCategory.prodPreservesColimits [HasBinaryProducts D] [HasColimits D]
    [∀ X : D, PreservesColimits (prod.functor.obj X)] (F : C ⥤ D) :
    PreservesColimits (prod.functor.obj F) 
goal: CategoryTheory.Limits.PreservesColimits (CategoryTheory.Limits.prod.functor.obj F)

full_name: CategoryTheory.whiskeringLeftPreservesLimits
code: instance whiskeringLeftPreservesLimits [HasLimits D] (F : C ⥤ E) :
    PreservesLimits ((whiskeringLeft C E D).obj F) 
goal: CategoryTheory.Limits.PreservesLimits ((CategoryTheory.whiskeringLeft C E D).obj F)

full_name: CategoryTheory.whiskeringRightPreservesLimitsOfShape
code: instance whiskeringRightPreservesLimitsOfShape {C : Type*} [Category C] {D : Type*}
    [Category D] {E : Type*} [Category E] {J : Type*} [Category J]
    [HasLimitsOfShape J D] (F : D ⥤ E) [PreservesLimitsOfShape J F] :
    PreservesLimitsOfShape J ((whiskeringRight C D E).obj F) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J ((CategoryTheory.whiskeringRight C D E).obj F)

full_name: CategoryTheory.whiskeringRightPreservesLimits
code: instance whiskeringRightPreservesLimits {C : Type*} [Category C] {D : Type*} [Category D]
    {E : Type*} [Category E] (F : D ⥤ E) [HasLimitsOfSize.{w, w'} D]
    [PreservesLimitsOfSize.{w, w'} F] :
    PreservesLimitsOfSize.{w, w'} ((whiskeringRight C D E).obj F) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, w', max u_1 u_5, max u_1 u_6, max (max (max u_1 u_2) u_4) u_5,
    max (max (max u_1 u_3) u_4) u_6}
  ((CategoryTheory.whiskeringRight C D E).obj F)

full_name: CategoryTheory.preservesLimitOfLanPreservesLimit
code: /-- If `Lan F.op : (Cᵒᵖ ⥤ Type*) ⥤ (Dᵒᵖ ⥤ Type*)` preserves limits of shape `J`, so will `F`. -/
noncomputable def preservesLimitOfLanPreservesLimit {C D : Type u} [SmallCategory C]
    [SmallCategory D] (F : C ⥤ D) (J : Type u) [SmallCategory J]
    [PreservesLimitsOfShape J (F.op.lan : _ ⥤ Dᵒᵖ ⥤ Type u)] : PreservesLimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J F
File: Mathlib/CategoryTheory/Limits/TypesFiltered.lean

full_name: CategoryTheory.Limits.Types.FilteredColimit.Rel
code: /-- An alternative relation on `Σ j, F.obj j`,
which generates the same equivalence relation as we use to define the colimit in `Type` above,
but that is more convenient when working with filtered colimits.

Elements in `F.obj j` and `F.obj j'` are equivalent if there is some `k : J` to the right
where their images are equal.
-/
protected def Rel (x y : Σ j, F.obj j) : Prop 
goal: Prop

full_name: CategoryTheory.Limits.Types.FilteredColimit.rel_of_quot_rel
code: theorem rel_of_quot_rel (x y : Σ j, F.obj j) :
    Quot.Rel F x y → FilteredColimit.Rel.{v, u} F x y 
goal: CategoryTheory.Limits.Types.Quot.Rel F x y → CategoryTheory.Limits.Types.FilteredColimit.Rel F x y

full_name: CategoryTheory.Limits.Types.FilteredColimit.eqvGen_quot_rel_of_rel
code: theorem eqvGen_quot_rel_of_rel (x y : Σ j, F.obj j) :
    FilteredColimit.Rel.{v, u} F x y → EqvGen (Quot.Rel F) x y 
goal: CategoryTheory.Limits.Types.FilteredColimit.Rel F x y → EqvGen (CategoryTheory.Limits.Types.Quot.Rel F) x y

full_name: CategoryTheory.Limits.Types.FilteredColimit.isColimitOf
code: /-- Recognizing filtered colimits of types. -/
noncomputable def isColimitOf (t : Cocone F) (hsurj : ∀ x : t.pt, ∃ i xi, x = t.ι.app i xi)
    (hinj :
      ∀ i j xi xj,
        t.ι.app i xi = t.ι.app j xj → ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f xi = F.map g xj) :
    IsColimit t 
goal: CategoryTheory.Limits.IsColimit t

full_name: CategoryTheory.Limits.Types.FilteredColimit.rel_equiv
code: protected theorem rel_equiv : _root_.Equivalence (FilteredColimit.Rel.{v, u} F) 
goal: Equivalence (CategoryTheory.Limits.Types.FilteredColimit.Rel F)

full_name: CategoryTheory.Limits.Types.FilteredColimit.rel_eq_eqvGen_quot_rel
code: protected theorem rel_eq_eqvGen_quot_rel :
    FilteredColimit.Rel.{v, u} F = EqvGen (Quot.Rel F) 
goal: CategoryTheory.Limits.Types.FilteredColimit.Rel F = EqvGen (CategoryTheory.Limits.Types.Quot.Rel F)

full_name: CategoryTheory.Limits.Types.FilteredColimit.colimit_eq_iff_aux
code: theorem colimit_eq_iff_aux {i j : J} {xi : F.obj i} {xj : F.obj j} :
    (colimitCocone F).ι.app i xi = (colimitCocone F).ι.app j xj ↔
      FilteredColimit.Rel.{v, u} F ⟨i, xi⟩ ⟨j, xj⟩ 
goal: (CategoryTheory.Limits.Types.colimitCocone F).ι.app i xi = (CategoryTheory.Limits.Types.colimitCocone F).ι.app j xj ↔
  CategoryTheory.Limits.Types.FilteredColimit.Rel F ⟨i, xi⟩ ⟨j, xj⟩

full_name: CategoryTheory.Limits.Types.FilteredColimit.isColimit_eq_iff
code: theorem isColimit_eq_iff {t : Cocone F} (ht : IsColimit t) {i j : J} {xi : F.obj i} {xj : F.obj j} :
    t.ι.app i xi = t.ι.app j xj ↔ ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f xi = F.map g xj 
goal: t.ι.app i xi = t.ι.app j xj ↔ ∃ k f g, F.map f xi = F.map g xj

full_name: CategoryTheory.Limits.Types.FilteredColimit.colimit_eq_iff
code: theorem colimit_eq_iff {i j : J} {xi : F.obj i} {xj : F.obj j} :
    colimit.ι F i xi = colimit.ι F j xj ↔
      ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f xi = F.map g xj 
goal: CategoryTheory.Limits.colimit.ι F i xi = CategoryTheory.Limits.colimit.ι F j xj ↔ ∃ k f g, F.map f xi = F.map g xj
File: Mathlib/CategoryTheory/Limits/EssentiallySmall.lean

full_name: CategoryTheory.Limits.hasLimitsOfShape_of_essentiallySmall
code: theorem hasLimitsOfShape_of_essentiallySmall [EssentiallySmall.{w₁} J]
    [HasLimitsOfSize.{w₁, w₁} C] : HasLimitsOfShape J C 
goal: CategoryTheory.Limits.HasLimitsOfShape J C

full_name: CategoryTheory.Limits.hasColimitsOfShape_of_essentiallySmall
code: theorem hasColimitsOfShape_of_essentiallySmall [EssentiallySmall.{w₁} J]
    [HasColimitsOfSize.{w₁, w₁} C] : HasColimitsOfShape J C 
goal: CategoryTheory.Limits.HasColimitsOfShape J C

full_name: CategoryTheory.Limits.hasProductsOfShape_of_small
code: theorem hasProductsOfShape_of_small (β : Type w₂) [Small.{w₁} β] [HasProducts.{w₁} C] :
    HasProductsOfShape β C 
goal: CategoryTheory.Limits.HasProductsOfShape β C

full_name: CategoryTheory.Limits.hasCoproductsOfShape_of_small
code: theorem hasCoproductsOfShape_of_small (β : Type w₂) [Small.{w₁} β] [HasCoproducts.{w₁} C] :
    HasCoproductsOfShape β C 
goal: CategoryTheory.Limits.HasCoproductsOfShape β C
File: Mathlib/CategoryTheory/Abelian/Projective.lean

full_name: CategoryTheory.preservesHomologyPreadditiveCoyonedaObjOfProjective
code: /-- The preadditive Co-Yoneda functor on `P` preserves homology if `P` is projective. -/
noncomputable instance preservesHomologyPreadditiveCoyonedaObjOfProjective
    (P : C) [hP : Projective P] :
    (preadditiveCoyonedaObj (op P)).PreservesHomology 
goal: (CategoryTheory.preadditiveCoyonedaObj (Opposite.op P)).PreservesHomology

full_name: CategoryTheory.preservesFiniteColimitsPreadditiveCoyonedaObjOfProjective
code: /-- The preadditive Co-Yoneda functor on `P` preserves finite colimits if `P` is projective. -/
noncomputable instance preservesFiniteColimitsPreadditiveCoyonedaObjOfProjective
    (P : C) [hP : Projective P] :
    PreservesFiniteColimits (preadditiveCoyonedaObj (op P)) 
goal: CategoryTheory.Limits.PreservesFiniteColimits (CategoryTheory.preadditiveCoyonedaObj (Opposite.op P))

full_name: CategoryTheory.projective_of_preservesFiniteColimits_preadditiveCoyonedaObj
code: /-- An object is projective if its preadditive Co-Yoneda functor preserves finite colimits. -/
theorem projective_of_preservesFiniteColimits_preadditiveCoyonedaObj (P : C)
    [hP : PreservesFiniteColimits (preadditiveCoyonedaObj (op P))] : Projective P 
goal: CategoryTheory.Projective P
File: Mathlib/CategoryTheory/Abelian/Subobject.lean

full_name: CategoryTheory.Abelian.subobjectIsoSubobjectOp_apply
code: /-- In an abelian category, the subobjects and quotient objects of an object `X` are
    order-isomorphic via taking kernels and cokernels.
    Implemented here using subobjects in the opposite category,
    since mathlib does not have a notion of quotient objects at the time of writing. -/
@[simps!]
def subobjectIsoSubobjectOp [Abelian C] (X : C) : Subobject X ≃o (Subobject (op X))ᵒᵈ 
goal: (CategoryTheory.Abelian.subobjectIsoSubobjectOp X) a =
  CategoryTheory.Subobject.lift (fun A f x => CategoryTheory.Subobject.mk (CategoryTheory.Limits.cokernel.π f).op) ⋯ a

full_name: CategoryTheory.Abelian.subobjectIsoSubobjectOp
code: /-- In an abelian category, the subobjects and quotient objects of an object `X` are
    order-isomorphic via taking kernels and cokernels.
    Implemented here using subobjects in the opposite category,
    since mathlib does not have a notion of quotient objects at the time of writing. -/
@[simps!]
def subobjectIsoSubobjectOp [Abelian C] (X : C) : Subobject X ≃o (Subobject (op X))ᵒᵈ 
goal: CategoryTheory.Subobject X ≃o (CategoryTheory.Subobject (Opposite.op X))ᵒᵈ

full_name: CategoryTheory.Abelian.subobjectIsoSubobjectOp_symm_apply
code: /-- In an abelian category, the subobjects and quotient objects of an object `X` are
    order-isomorphic via taking kernels and cokernels.
    Implemented here using subobjects in the opposite category,
    since mathlib does not have a notion of quotient objects at the time of writing. -/
@[simps!]
def subobjectIsoSubobjectOp [Abelian C] (X : C) : Subobject X ≃o (Subobject (op X))ᵒᵈ 
goal: (RelIso.symm (CategoryTheory.Abelian.subobjectIsoSubobjectOp X)) a =
  CategoryTheory.Subobject.lift (fun A f x => CategoryTheory.Subobject.mk (CategoryTheory.Limits.kernel.ι f.unop)) ⋯ a

full_name: CategoryTheory.Abelian.wellPowered_opposite
code: /-- A well-powered abelian category is also well-copowered. -/
instance wellPowered_opposite [Abelian C] [WellPowered C] : WellPowered Cᵒᵖ 
goal: CategoryTheory.WellPowered Cᵒᵖ
File: Mathlib/CategoryTheory/Abelian/Ext.lean

full_name: Ext
code: /-- `Ext R C n` is defined by deriving in the first argument of `(X, Y) ↦ Module.of R (unop X ⟶ Y)`
(which is the second argument of `linearYoneda`).
-/

-- Porting note: the lemmas `Ext_obj` and `Ext_map` generated by `@[simps]` were
-- being rejected by the type-checking linter; it's unclear exactly why.
-- In any case, these lemmas were not actually used downstream in mathlib3,
-- and seem unlikely to be directly useful (rather than lemmas in terms of resolutions),
-- and so have been removed during porting:
-- @[simps! obj map]

-- Porting note: the mathlib3 proofs of `map_id` and `map_comp` were timing out,
-- but `aesop_cat` is fast if we leave them out.
def Ext (n : ℕ) : Cᵒᵖ ⥤ C ⥤ ModuleCat R 
goal: Cᵒᵖ ⥤ C ⥤ ModuleCat R

full_name: ChainComplex.linearYonedaObj_d
code: /-- Given a chain complex `X` and an object `Y`, this is the cochain complex
which in degree `i` consists of the module of morphisms `X.X i ⟶ Y`. -/
@[simps! X d]
def ChainComplex.linearYonedaObj {α : Type*} [AddRightCancelSemigroup α] [One α]
    (X : ChainComplex C α) (A : Type*) [Ring A] [Linear A C] (Y : C) :
    CochainComplex (ModuleCat A) α 
goal: (X.linearYonedaObj A Y).d i j = ModuleCat.ofHom (CategoryTheory.Linear.leftComp A Y (X.d j i))

full_name: ChainComplex.linearYonedaObj_X
code: /-- Given a chain complex `X` and an object `Y`, this is the cochain complex
which in degree `i` consists of the module of morphisms `X.X i ⟶ Y`. -/
@[simps! X d]
def ChainComplex.linearYonedaObj {α : Type*} [AddRightCancelSemigroup α] [One α]
    (X : ChainComplex C α) (A : Type*) [Ring A] [Linear A C] (Y : C) :
    CochainComplex (ModuleCat A) α 
goal: (X.linearYonedaObj A Y).X i = ModuleCat.of A (X.X i ⟶ Y)

full_name: ChainComplex.linearYonedaObj
code: /-- Given a chain complex `X` and an object `Y`, this is the cochain complex
which in degree `i` consists of the module of morphisms `X.X i ⟶ Y`. -/
@[simps! X d]
def ChainComplex.linearYonedaObj {α : Type*} [AddRightCancelSemigroup α] [One α]
    (X : ChainComplex C α) (A : Type*) [Ring A] [Linear A C] (Y : C) :
    CochainComplex (ModuleCat A) α 
goal: CochainComplex (ModuleCat A) α

full_name: CategoryTheory.ProjectiveResolution.isoExt
code: /-- `Ext` can be computed using a projective resolution. -/
def isoExt (n : ℕ) (Y : C) : ((Ext R C n).obj (Opposite.op X)).obj Y ≅
    (P.complex.linearYonedaObj R Y).homology n 
goal: ((Ext R C n).obj (Opposite.op X)).obj Y ≅ HomologicalComplex.homology (P.complex.linearYonedaObj R Y) n

full_name: isZero_Ext_succ_of_projective
code: /-- If `X : C` is projective and `n : ℕ`, then `Ext^(n + 1) X Y ≅ 0` for any `Y`. -/
lemma isZero_Ext_succ_of_projective (X Y : C) [Projective X] (n : ℕ) :
    IsZero (((Ext R C (n + 1)).obj (Opposite.op X)).obj Y) 
goal: CategoryTheory.Limits.IsZero (((Ext R C (n + 1)).obj (Opposite.op X)).obj Y)
File: Mathlib/CategoryTheory/Abelian/Injective.lean

full_name: CategoryTheory.preservesHomologyPreadditiveYonedaObjOfInjective
code: /-- The preadditive Yoneda functor on `J` preserves homology if `J` is injective. -/
instance preservesHomologyPreadditiveYonedaObjOfInjective (J : C) [hJ : Injective J] :
    (preadditiveYonedaObj J).PreservesHomology  
goal: (CategoryTheory.preadditiveYonedaObj J).PreservesHomology

full_name: CategoryTheory.preservesFiniteColimitsPreadditiveYonedaObjOfInjective
code: /-- The preadditive Yoneda functor on `J` preserves colimits if `J` is injective. -/
instance preservesFiniteColimitsPreadditiveYonedaObjOfInjective (J : C) [hP : Injective J] :
    PreservesFiniteColimits (preadditiveYonedaObj J) 
goal: CategoryTheory.Limits.PreservesFiniteColimits (CategoryTheory.preadditiveYonedaObj J)

full_name: CategoryTheory.injective_of_preservesFiniteColimits_preadditiveYonedaObj
code: /-- An object is injective if its preadditive Yoneda functor preserves finite colimits. -/
theorem injective_of_preservesFiniteColimits_preadditiveYonedaObj (J : C)
    [hP : PreservesFiniteColimits (preadditiveYonedaObj J)] : Injective J 
goal: CategoryTheory.Injective J
File: Mathlib/CategoryTheory/Abelian/Generator.lean

full_name: CategoryTheory.Abelian.has_injective_coseparator
code: theorem has_injective_coseparator [HasLimits C] [EnoughInjectives C] (G : C) (hG : IsSeparator G) :
    ∃ G : C, Injective G ∧ IsCoseparator G 
goal: ∃ G, CategoryTheory.Injective G ∧ CategoryTheory.IsCoseparator G

full_name: CategoryTheory.Abelian.has_projective_separator
code: theorem has_projective_separator [HasColimits C] [EnoughProjectives C] (G : C)
    (hG : IsCoseparator G) : ∃ G : C, Projective G ∧ IsSeparator G 
goal: ∃ G, CategoryTheory.Projective G ∧ CategoryTheory.IsSeparator G
File: Mathlib/CategoryTheory/Abelian/Refinements.lean

full_name: CategoryTheory.epi_iff_surjective_up_to_refinements
code: lemma epi_iff_surjective_up_to_refinements (f : X ⟶ Y) :
    Epi f ↔ ∀ ⦃A : C⦄ (y : A ⟶ Y),
      ∃ (A' : C) (π : A' ⟶ A) (_ : Epi π) (x : A' ⟶ X), π ≫ y = x ≫ f 
goal: CategoryTheory.Epi f ↔
  ∀ ⦃A : C⦄ (y : A ⟶ Y),
    ∃ A' π,
      ∃ (_ : CategoryTheory.Epi π), ∃ x, CategoryTheory.CategoryStruct.comp π y = CategoryTheory.CategoryStruct.comp x f

full_name: CategoryTheory.surjective_up_to_refinements_of_epi
code: lemma surjective_up_to_refinements_of_epi (f : X ⟶ Y) [Epi f] {A : C} (y : A ⟶ Y) :
    ∃ (A' : C) (π : A' ⟶ A) (_ : Epi π) (x : A' ⟶ X), π ≫ y = x ≫ f 
goal: ∃ A' π,
  ∃ (_ : CategoryTheory.Epi π), ∃ x, CategoryTheory.CategoryStruct.comp π y = CategoryTheory.CategoryStruct.comp x f

full_name: CategoryTheory.ShortComplex.exact_iff_exact_up_to_refinements
code: lemma ShortComplex.exact_iff_exact_up_to_refinements :
    S.Exact ↔ ∀ ⦃A : C⦄ (x₂ : A ⟶ S.X₂) (_ : x₂ ≫ S.g = 0),
      ∃ (A' : C) (π : A' ⟶ A) (_ : Epi π) (x₁ : A' ⟶ S.X₁), π ≫ x₂ = x₁ ≫ S.f 
goal: S.Exact ↔
  ∀ ⦃A : C⦄ (x₂ : A ⟶ S.X₂),
    CategoryTheory.CategoryStruct.comp x₂ S.g = 0 →
      ∃ A' π,
        ∃ (_ : CategoryTheory.Epi π),
          ∃ x₁, CategoryTheory.CategoryStruct.comp π x₂ = CategoryTheory.CategoryStruct.comp x₁ S.f

full_name: CategoryTheory.ShortComplex.Exact.exact_up_to_refinements
code: lemma ShortComplex.Exact.exact_up_to_refinements
    (hS : S.Exact) {A : C} (x₂ : A ⟶ S.X₂) (hx₂ : x₂ ≫ S.g = 0) :
    ∃ (A' : C) (π : A' ⟶ A) (_ : Epi π) (x₁ : A' ⟶ S.X₁), π ≫ x₂ = x₁ ≫ S.f 
goal: ∃ A' π,
  ∃ (_ : CategoryTheory.Epi π),
    ∃ x₁, CategoryTheory.CategoryStruct.comp π x₂ = CategoryTheory.CategoryStruct.comp x₁ S.f

full_name: CategoryTheory.ShortComplex.eq_liftCycles_homologyπ_up_to_refinements
code: lemma ShortComplex.eq_liftCycles_homologyπ_up_to_refinements {A : C} (γ : A ⟶ S.homology) :
    ∃ (A' : C) (π : A' ⟶ A) (_ : Epi π) (z : A' ⟶ S.X₂) (hz : z ≫ S.g = 0),
      π ≫ γ = S.liftCycles z hz ≫ S.homologyπ 
goal: ∃ A' π,
  ∃ (_ : CategoryTheory.Epi π),
    ∃ z,
      ∃ (hz : CategoryTheory.CategoryStruct.comp z S.g = 0),
        CategoryTheory.CategoryStruct.comp π γ = CategoryTheory.CategoryStruct.comp (S.liftCycles z hz) S.homologyπ
File: Mathlib/CategoryTheory/Abelian/EpiWithInjectiveKernel.lean

full_name: CategoryTheory.Abelian.epiWithInjectiveKernel
code: /-- The class of morphisms in an abelian category that are epimorphisms
and have an injective kernel. -/
def epiWithInjectiveKernel : MorphismProperty C 
goal: CategoryTheory.MorphismProperty C

full_name: CategoryTheory.Abelian.epiWithInjectiveKernel_iff
code: /-- A morphism `g : X ⟶ Y` is epi with an injective kernel iff there exists a morphism
`f : I ⟶ X` with `I` injective such that `f ≫ g = 0` and
the short complex `I ⟶ X ⟶ Y` has a splitting. -/
lemma epiWithInjectiveKernel_iff {X Y : C} (g : X ⟶ Y) :
    epiWithInjectiveKernel g ↔ ∃ (I : C) (_ : Injective I) (f : I ⟶ X) (w : f ≫ g = 0),
      Nonempty (ShortComplex.mk f g w).Splitting 
goal: CategoryTheory.Abelian.epiWithInjectiveKernel g ↔
  ∃ I,
    ∃ (_ : CategoryTheory.Injective I),
      ∃ f, ∃ (w : CategoryTheory.CategoryStruct.comp f g = 0), Nonempty (CategoryTheory.ShortComplex.mk f g w).Splitting

full_name: CategoryTheory.Abelian.epiWithInjectiveKernel_of_iso
code: lemma epiWithInjectiveKernel_of_iso {X Y : C} (f : X ⟶ Y) [IsIso f] :
    epiWithInjectiveKernel f 
goal: CategoryTheory.Abelian.epiWithInjectiveKernel f

full_name: CategoryTheory.Abelian.instIsMultiplicativeEpiWithInjectiveKernel
code: instance : (epiWithInjectiveKernel : MorphismProperty C).IsMultiplicative 
goal: CategoryTheory.Abelian.epiWithInjectiveKernel.IsMultiplicative
File: Mathlib/CategoryTheory/Abelian/Transfer.lean

full_name: CategoryTheory.AbelianOfAdjunction.hasKernels
code: /-- No point making this an instance, as it requires `i`. -/
theorem hasKernels [PreservesFiniteLimits G] : HasKernels C 
goal: CategoryTheory.Limits.HasKernels C

full_name: CategoryTheory.AbelianOfAdjunction.hasCokernels
code: /-- No point making this an instance, as it requires `i` and `adj`. -/
theorem hasCokernels : HasCokernels C 
goal: CategoryTheory.Limits.HasCokernels C

full_name: CategoryTheory.AbelianOfAdjunction.cokernelIso
code: /-- Auxiliary construction for `coimageIsoImage` -/
def cokernelIso {X Y : C} (f : X ⟶ Y) : G.obj (cokernel (F.map f)) ≅ cokernel f 
goal: G.obj (CategoryTheory.Limits.cokernel (F.map f)) ≅ CategoryTheory.Limits.cokernel f

full_name: CategoryTheory.AbelianOfAdjunction.coimageIsoImageAux
code: /-- Auxiliary construction for `coimageIsoImage` -/
def coimageIsoImageAux {X Y : C} (f : X ⟶ Y) :
    kernel (G.map (cokernel.π (F.map f))) ≅ kernel (cokernel.π f) 
goal: CategoryTheory.Limits.kernel (G.map (CategoryTheory.Limits.cokernel.π (F.map f))) ≅
  CategoryTheory.Limits.kernel (CategoryTheory.Limits.cokernel.π f)

full_name: CategoryTheory.AbelianOfAdjunction.coimageIsoImage
code: /-- Auxiliary definition: the abelian coimage and abelian image agree.
We still need to check that this agrees with the canonical morphism.
-/
def coimageIsoImage {X Y : C} (f : X ⟶ Y) : Abelian.coimage f ≅ Abelian.image f 
goal: CategoryTheory.Abelian.coimage f ≅ CategoryTheory.Abelian.image f

full_name: CategoryTheory.AbelianOfAdjunction.coimageIsoImage_hom
code: theorem coimageIsoImage_hom {X Y : C} (f : X ⟶ Y) :
    (coimageIsoImage F G i adj f).hom = Abelian.coimageImageComparison f 
goal: (CategoryTheory.AbelianOfAdjunction.coimageIsoImage F G i adj f).hom = CategoryTheory.Abelian.coimageImageComparison f

full_name: CategoryTheory.abelianOfAdjunction
code: /-- If `C` is an additive category, `D` is an abelian category,
we have `F : C ⥤ D` `G : D ⥤ C` (both preserving zero morphisms),
`G` is left exact (that is, preserves finite limits),
and further we have `adj : G ⊣ F` and `i : F ⋙ G ≅ 𝟭 C`,
then `C` is also abelian.

See <https://stacks.math.columbia.edu/tag/03A3>
-/
def abelianOfAdjunction {C : Type u₁} [Category.{v} C] [Preadditive C] [HasFiniteProducts C]
    {D : Type u₂} [Category.{v} D] [Abelian D] (F : C ⥤ D) [Functor.PreservesZeroMorphisms F]
    (G : D ⥤ C) [Functor.PreservesZeroMorphisms G] [PreservesFiniteLimits G] (i : F ⋙ G ≅ 𝟭 C)
    (adj : G ⊣ F) : Abelian C 
goal: CategoryTheory.Abelian C

full_name: CategoryTheory.abelianOfEquivalence
code: /-- If `C` is an additive category equivalent to an abelian category `D`
via a functor that preserves zero morphisms,
then `C` is also abelian.
-/
def abelianOfEquivalence {C : Type u₁} [Category.{v} C] [Preadditive C] [HasFiniteProducts C]
    {D : Type u₂} [Category.{v} D] [Abelian D] (F : C ⥤ D) [Functor.PreservesZeroMorphisms F]
    [F.IsEquivalence] : Abelian C 
goal: CategoryTheory.Abelian C