ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Abelian.coimageImageComparison_eq_coimageImageComparison'
theorem coimageImageComparison_eq_coimageImageComparison' :
    coimageImageComparison f = coimageImageComparison' f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C] {P Q : C} (f : P ⟶ Q)
Goal: CategoryTheory.Abelian.coimageImageComparison f = CategoryTheory.Abelian.coimageImageComparison' f
-- CategoryTheory.Abelian.coimage_image_factorisation
@[reassoc (attr := simp)]
theorem coimage_image_factorisation : coimage.π f ≫ coimageImageComparison f ≫ image.ι f = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C] {P Q : C} (f : P ⟶ Q)
Goal: CategoryTheory.Abelian.coimage.π f ≫
    CategoryTheory.Abelian.coimageImageComparison f ≫ CategoryTheory.Abelian.image.ι f =
  f
-- CategoryTheory.epi_iff_surjective_up_to_refinements
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 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Epi f ↔
  ∀ ⦃A : C⦄ (y : A ⟶ Y),
    ∃ A' π,
      ∃ (_ : CategoryTheory.Epi π), ∃ x, CategoryTheory.CategoryStruct.comp π y = CategoryTheory.CategoryStruct.comp x f
-- CategoryTheory.surjective_up_to_refinements_of_epi
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 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f] {A : C} (y : A ⟶ Y)
Goal: ∃ A' π,
  ∃ (_ : CategoryTheory.Epi π), ∃ x, CategoryTheory.CategoryStruct.comp π y = CategoryTheory.CategoryStruct.comp x f
-- CategoryTheory.ShortComplex.exact_iff_exact_up_to_refinements
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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C)
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
-- CategoryTheory.ShortComplex.Exact.exact_up_to_refinements
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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {S : CategoryTheory.ShortComplex C} (hS : S.Exact) {A : C} (x₂ : A ⟶ S.X₂) (hx₂ : CategoryTheory.CategoryStruct.comp x₂ S.g = 0)
Goal: ∃ A' π,
  ∃ (_ : CategoryTheory.Epi π),
    ∃ x₁, CategoryTheory.CategoryStruct.comp π x₂ = CategoryTheory.CategoryStruct.comp x₁ S.f
-- CategoryTheory.ShortComplex.eq_liftCycles_homologyπ_up_to_refinements
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π 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Abelian C] {S : CategoryTheory.ShortComplex C} {A : C} (γ : A ⟶ 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π
-- CategoryTheory.Abelian.epiWithInjectiveKernel_iff
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 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (g : X ⟶ Y)
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
-- CategoryTheory.Abelian.epiWithInjectiveKernel_of_iso
lemma epiWithInjectiveKernel_of_iso {X Y : C} (f : X ⟶ Y) [IsIso f] :
    epiWithInjectiveKernel f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.IsIso f]
Goal: CategoryTheory.Abelian.epiWithInjectiveKernel f
-- CategoryTheory.solutionSetCondition_of_isRightAdjoint
theorem solutionSetCondition_of_isRightAdjoint [G.IsRightAdjoint] : SolutionSetCondition G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u} [CategoryTheory.Category.{v, u} D] (G : CategoryTheory.Functor D C) [G.IsRightAdjoint]
Goal: CategoryTheory.SolutionSetCondition G
-- CategoryTheory.isRightAdjoint_of_preservesLimits_of_solutionSetCondition
lemma isRightAdjoint_of_preservesLimits_of_solutionSetCondition [HasLimits D]
    [PreservesLimits G] (hG : SolutionSetCondition G) : G.IsRightAdjoint 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u} [CategoryTheory.Category.{v, u} D] (G : CategoryTheory.Functor D C) [CategoryTheory.Limits.HasLimits D] [CategoryTheory.Limits.PreservesLimits G] (hG : CategoryTheory.SolutionSetCondition G)
Goal: G.IsRightAdjoint
-- CategoryTheory.isRightAdjoint_of_preservesLimits_of_isCoseparating
lemma isRightAdjoint_of_preservesLimits_of_isCoseparating [HasLimits D] [WellPowered D]
    {𝒢 : Set D} [Small.{v} 𝒢] (h𝒢 : IsCoseparating 𝒢) (G : D ⥤ C) [PreservesLimits G] :
    G.IsRightAdjoint 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v, u'} D] [CategoryTheory.Limits.HasLimits D] [CategoryTheory.WellPowered D] {𝒢 : Set D} [Small.{v, u'} ↑𝒢] (h𝒢 : CategoryTheory.IsCoseparating 𝒢) (G : CategoryTheory.Functor D C) [CategoryTheory.Limits.PreservesLimits G]
Goal: G.IsRightAdjoint
-- CategoryTheory.isLeftAdjoint_of_preservesColimits_of_isSeparating
lemma isLeftAdjoint_of_preservesColimits_of_isSeparating [HasColimits C] [WellPowered Cᵒᵖ]
    {𝒢 : Set C} [Small.{v} 𝒢] (h𝒢 : IsSeparating 𝒢) (F : C ⥤ D) [PreservesColimits F] :
    F.IsLeftAdjoint 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v, u'} D] [CategoryTheory.Limits.HasColimits C] [CategoryTheory.WellPowered Cᵒᵖ] {𝒢 : Set C} [Small.{v, u} ↑𝒢] (h𝒢 : CategoryTheory.IsSeparating 𝒢) (F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesColimits F]
Goal: F.IsLeftAdjoint
-- CategoryTheory.Limits.hasColimits_of_hasLimits_of_isCoseparating
theorem hasColimits_of_hasLimits_of_isCoseparating [HasLimits C] [WellPowered C] {𝒢 : Set C}
    [Small.{v} 𝒢] (h𝒢 : IsCoseparating 𝒢) : HasColimits C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.WellPowered C] {𝒢 : Set C} [Small.{v, u} ↑𝒢] (h𝒢 : CategoryTheory.IsCoseparating 𝒢)
Goal: CategoryTheory.Limits.HasColimits C
-- CategoryTheory.Limits.hasLimits_of_hasColimits_of_isSeparating
theorem hasLimits_of_hasColimits_of_isSeparating [HasColimits C] [WellPowered Cᵒᵖ] {𝒢 : Set C}
    [Small.{v} 𝒢] (h𝒢 : IsSeparating 𝒢) : HasLimits C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] [CategoryTheory.WellPowered Cᵒᵖ] {𝒢 : Set C} [Small.{v, u} ↑𝒢] (h𝒢 : CategoryTheory.IsSeparating 𝒢)
Goal: CategoryTheory.Limits.HasLimits C
-- CategoryTheory.Abelian.FunctorCategory.coimageObjIso_inv
@[simps!]
def coimageObjIso : (Abelian.coimage α).obj X ≅ Abelian.coimage (α.app X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type w} [CategoryTheory.Category.{z, w} D] [CategoryTheory.Abelian D] {F G : CategoryTheory.Functor C D} (α : F ⟶ G) (X : C)
Goal: (CategoryTheory.Abelian.FunctorCategory.coimageObjIso α X).inv =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.cokernel.map (CategoryTheory.Limits.kernel.ι (α.app X))
      ((CategoryTheory.Limits.kernel.ι α).app X)
      (CategoryTheory.Limits.PreservesKernel.iso ((CategoryTheory.evaluation C D).obj X) α).inv
      (CategoryTheory.CategoryStruct.id (F.obj X)) ⋯)
    (CategoryTheory.Limits.cokernelComparison (CategoryTheory.Limits.kernel.ι α)
      ((CategoryTheory.evaluation C D).obj X))
-- CategoryTheory.Abelian.FunctorCategory.coimageObjIso_hom
@[simps!]
def coimageObjIso : (Abelian.coimage α).obj X ≅ Abelian.coimage (α.app X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type w} [CategoryTheory.Category.{z, w} D] [CategoryTheory.Abelian D] {F G : CategoryTheory.Functor C D} (α : F ⟶ G) (X : C)
Goal: (CategoryTheory.Abelian.FunctorCategory.coimageObjIso α X).hom =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.PreservesCokernel.iso ((CategoryTheory.evaluation C D).obj X)
        (CategoryTheory.Limits.kernel.ι α)).hom
    (CategoryTheory.Limits.cokernel.map ((CategoryTheory.Limits.kernel.ι α).app X)
      (CategoryTheory.Limits.kernel.ι (α.app X))
      (CategoryTheory.Limits.kernelComparison α ((CategoryTheory.evaluation C D).obj X))
      (CategoryTheory.CategoryStruct.id (F.obj X)) ⋯)
-- CategoryTheory.Abelian.FunctorCategory.imageObjIso_inv
@[simps!]
def imageObjIso : (Abelian.image α).obj X ≅ Abelian.image (α.app X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type w} [CategoryTheory.Category.{z, w} D] [CategoryTheory.Abelian D] {F G : CategoryTheory.Functor C D} (α : F ⟶ G) (X : C)
Goal: (CategoryTheory.Abelian.FunctorCategory.imageObjIso α X).inv =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.kernel.map (CategoryTheory.Limits.cokernel.π (α.app X))
      ((CategoryTheory.Limits.cokernel.π α).app X) (CategoryTheory.CategoryStruct.id (G.obj X))
      (CategoryTheory.Limits.cokernelComparison α ((CategoryTheory.evaluation C D).obj X)) ⋯)
    (CategoryTheory.Limits.PreservesKernel.iso ((CategoryTheory.evaluation C D).obj X)
        (CategoryTheory.Limits.cokernel.π α)).inv
-- CategoryTheory.Abelian.FunctorCategory.imageObjIso_hom
@[simps!]
def imageObjIso : (Abelian.image α).obj X ≅ Abelian.image (α.app X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type w} [CategoryTheory.Category.{z, w} D] [CategoryTheory.Abelian D] {F G : CategoryTheory.Functor C D} (α : F ⟶ G) (X : C)
Goal: (CategoryTheory.Abelian.FunctorCategory.imageObjIso α X).hom =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.kernelComparison (CategoryTheory.Limits.cokernel.π α)
      ((CategoryTheory.evaluation C D).obj X))
    (CategoryTheory.Limits.kernel.map ((CategoryTheory.Limits.cokernel.π α).app X)
      (CategoryTheory.Limits.cokernel.π (α.app X)) (CategoryTheory.CategoryStruct.id (G.obj X))
      (CategoryTheory.Limits.PreservesCokernel.iso ((CategoryTheory.evaluation C D).obj X) α).hom ⋯)
-- CategoryTheory.Abelian.FunctorCategory.coimageImageComparison_app
theorem coimageImageComparison_app :
    coimageImageComparison (α.app X) =
      (coimageObjIso α X).inv ≫ (coimageImageComparison α).app X ≫ (imageObjIso α X).hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type w} [CategoryTheory.Category.{z, w} D] [CategoryTheory.Abelian D] {F G : CategoryTheory.Functor C D} (α : F ⟶ G) (X : C)
Goal: CategoryTheory.Abelian.coimageImageComparison (α.app X) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Abelian.FunctorCategory.coimageObjIso α X).inv
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.Abelian.coimageImageComparison α).app X)
      (CategoryTheory.Abelian.FunctorCategory.imageObjIso α X).hom)
-- CategoryTheory.Abelian.FunctorCategory.coimageImageComparison_app'
theorem coimageImageComparison_app' :
    (coimageImageComparison α).app X =
      (coimageObjIso α X).hom ≫ coimageImageComparison (α.app X) ≫ (imageObjIso α X).inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type w} [CategoryTheory.Category.{z, w} D] [CategoryTheory.Abelian D] {F G : CategoryTheory.Functor C D} (α : F ⟶ G) (X : C)
Goal: (CategoryTheory.Abelian.coimageImageComparison α).app X =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Abelian.FunctorCategory.coimageObjIso α X).hom
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.Abelian.coimageImageComparison (α.app X))
      (CategoryTheory.Abelian.FunctorCategory.imageObjIso α X).inv)
-- CategoryTheory.ShortComplex.exact_iff_epi_imageToKernel'
theorem exact_iff_epi_imageToKernel' : S.Exact ↔ Epi (imageToKernel' S.f S.g S.zero) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C)
Goal: S.Exact ↔ CategoryTheory.Epi (imageToKernel' S.f S.g ⋯)
-- CategoryTheory.ShortComplex.exact_iff_epi_imageToKernel
theorem exact_iff_epi_imageToKernel : S.Exact ↔ Epi (imageToKernel S.f S.g S.zero) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C)
Goal: S.Exact ↔ CategoryTheory.Epi (imageToKernel S.f S.g ⋯)
-- CategoryTheory.ShortComplex.exact_iff_isIso_imageToKernel
theorem exact_iff_isIso_imageToKernel : S.Exact ↔ IsIso (imageToKernel S.f S.g S.zero) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C)
Goal: S.Exact ↔ CategoryTheory.IsIso (imageToKernel S.f S.g ⋯)
-- CategoryTheory.ShortComplex.exact_iff_image_eq_kernel
theorem exact_iff_image_eq_kernel : S.Exact ↔ imageSubobject S.f = kernelSubobject S.g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C)
Goal: S.Exact ↔ CategoryTheory.Limits.imageSubobject S.f = CategoryTheory.Limits.kernelSubobject S.g
-- CategoryTheory.ShortComplex.exact_iff_of_forks
theorem exact_iff_of_forks {cg : KernelFork S.g} (hg : IsLimit cg) {cf : CokernelCofork S.f}
    (hf : IsColimit cf) : S.Exact ↔ cg.ι ≫ cf.π = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C) {cg : CategoryTheory.Limits.KernelFork S.g} (hg : CategoryTheory.Limits.IsLimit cg) {cf : CategoryTheory.Limits.CokernelCofork S.f} (hf : CategoryTheory.Limits.IsColimit cf)
Goal: S.Exact ↔ CategoryTheory.Limits.Fork.ι cg ≫ CategoryTheory.Limits.Cofork.π cf = 0
-- CategoryTheory.ShortComplex.exact_kernel
theorem exact_kernel {X Y : C} (f : X ⟶ Y) :
    (ShortComplex.mk (kernel.ι f) f (by simp)).Exact 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.ShortComplex.mk (CategoryTheory.Limits.kernel.ι f) f ⋯).Exact
-- CategoryTheory.ShortComplex.exact_cokernel
theorem exact_cokernel {X Y : C} (f : X ⟶ Y) :
    (ShortComplex.mk f (cokernel.π f) (by simp)).Exact 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.ShortComplex.mk f (CategoryTheory.Limits.cokernel.π f) ⋯).Exact
-- CategoryTheory.ShortComplex.exact_iff_exact_image_ι
theorem exact_iff_exact_image_ι :
    S.Exact ↔ (ShortComplex.mk (Abelian.image.ι S.f) S.g
      (Abelian.image_ι_comp_eq_zero S.zero)).Exact 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C)
Goal: S.Exact ↔ (CategoryTheory.ShortComplex.mk (CategoryTheory.Abelian.image.ι S.f) S.g ⋯).Exact
-- CategoryTheory.ShortComplex.exact_iff_exact_coimage_π
theorem exact_iff_exact_coimage_π :
    S.Exact ↔ (ShortComplex.mk S.f (Abelian.coimage.π S.g)
      (Abelian.comp_coimage_π_eq_zero S.zero)).Exact 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C)
Goal: S.Exact ↔ (CategoryTheory.ShortComplex.mk S.f (CategoryTheory.Abelian.coimage.π S.g) ⋯).Exact
-- CategoryTheory.Abelian.tfae_mono
theorem Abelian.tfae_mono {X Y : C} (f : X ⟶ Y) (Z : C) :
    TFAE [Mono f, kernel.ι f = 0, (ShortComplex.mk (0 : Z ⟶ X) f zero_comp).Exact] 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y) (Z : C)
Goal: [CategoryTheory.Mono f, CategoryTheory.Limits.kernel.ι f = 0, (CategoryTheory.ShortComplex.mk 0 f ⋯).Exact].TFAE
-- CategoryTheory.Abelian.tfae_epi
theorem Abelian.tfae_epi {X Y : C} (f : X ⟶ Y) (Z : C ) :
    TFAE [Epi f, cokernel.π f = 0, (ShortComplex.mk f (0 : Y ⟶ Z) comp_zero).Exact] 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y) (Z : C)
Goal: [CategoryTheory.Epi f, CategoryTheory.Limits.cokernel.π f = 0, (CategoryTheory.ShortComplex.mk f 0 ⋯).Exact].TFAE
-- CategoryTheory.Functor.reflects_exact_of_faithful
lemma reflects_exact_of_faithful [F.Faithful] (S : ShortComplex C) (hS : (S.map F).Exact) :
    S.Exact 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Abelian C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Abelian D] (F : C ⥤ D) [F.PreservesZeroMorphisms] [F.Faithful] (S : CategoryTheory.ShortComplex C) (hS : (S.map F).Exact)
Goal: S.Exact
-- CategoryTheory.Functor.preservesMonomorphisms_of_map_exact
theorem preservesMonomorphisms_of_map_exact : L.PreservesMonomorphisms 
Arguments: {A : Type u₁} {B : Type u₂} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Abelian A] [CategoryTheory.Abelian B] (L : A ⥤ B) [L.PreservesZeroMorphisms] (hL : ∀ (S : CategoryTheory.ShortComplex A), S.Exact → (S.map L).Exact)
Goal: L.PreservesMonomorphisms
-- CategoryTheory.Functor.preservesEpimorphisms_of_map_exact
theorem preservesEpimorphisms_of_map_exact : L.PreservesEpimorphisms 
Arguments: {A : Type u₁} {B : Type u₂} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Abelian A] [CategoryTheory.Abelian B] (L : A ⥤ B) [L.PreservesZeroMorphisms] (hL : ∀ (S : CategoryTheory.ShortComplex A), S.Exact → (S.map L).Exact)
Goal: L.PreservesEpimorphisms
-- CategoryTheory.ProjectiveResolution.exact₀
lemma exact₀ {Z : C} (P : ProjectiveResolution Z) :
    (ShortComplex.mk _ _ P.complex_d_comp_π_f_zero).Exact 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z)
Goal: (CategoryTheory.ShortComplex.mk (P.complex.d 1 0) (P.π.f 0) ⋯).Exact
-- CategoryTheory.ProjectiveResolution.liftFOne_zero_comm
@[simp]
theorem liftFOne_zero_comm {Y Z : C} (f : Y ⟶ Z) (P : ProjectiveResolution Y)
    (Q : ProjectiveResolution Z) :
    liftFOne f P Q ≫ Q.complex.d 1 0 = P.complex.d 1 0 ≫ liftFZero f P Q 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} (f : Y ⟶ Z) (P : CategoryTheory.ProjectiveResolution Y) (Q : CategoryTheory.ProjectiveResolution Z)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.liftFOne f P Q) (Q.complex.d 1 0) =
  CategoryTheory.CategoryStruct.comp (P.complex.d 1 0) (CategoryTheory.ProjectiveResolution.liftFZero f P Q)
-- CategoryTheory.ProjectiveResolution.lift_commutes
@[reassoc (attr := simp)]
theorem lift_commutes {Y Z : C} (f : Y ⟶ Z) (P : ProjectiveResolution Y)
    (Q : ProjectiveResolution Z) : lift f P Q ≫ Q.π = P.π ≫ (ChainComplex.single₀ C).map f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} (f : Y ⟶ Z) (P : CategoryTheory.ProjectiveResolution Y) (Q : CategoryTheory.ProjectiveResolution Z)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.lift f P Q) Q.π =
  CategoryTheory.CategoryStruct.comp P.π ((ChainComplex.single₀ C).map f)
-- CategoryTheory.ProjectiveResolution.lift_commutes_zero
@[reassoc (attr := simp)]
lemma lift_commutes_zero {Y Z : C} (f : Y ⟶ Z)
    (P : ProjectiveResolution Y) (Q : ProjectiveResolution Z) :
    (lift f P Q).f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} (f : Y ⟶ Z) (P : CategoryTheory.ProjectiveResolution Y) (Q : CategoryTheory.ProjectiveResolution Z)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.ProjectiveResolution.lift f P Q).f 0) (Q.π.f 0) =
  CategoryTheory.CategoryStruct.comp (P.π.f 0) f
-- CategoryTheory.ProjectiveResolution.liftHomotopyZeroZero_comp
@[reassoc (attr := simp)]
lemma liftHomotopyZeroZero_comp {Y Z : C} {P : ProjectiveResolution Y} {Q : ProjectiveResolution Z}
    (f : P.complex ⟶ Q.complex) (comm : f ≫ Q.π = 0) :
    liftHomotopyZeroZero f comm ≫ Q.complex.d 1 0 = f.f 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} {P : CategoryTheory.ProjectiveResolution Y} {Q : CategoryTheory.ProjectiveResolution Z} (f : P.complex ⟶ Q.complex) (comm : CategoryTheory.CategoryStruct.comp f Q.π = 0)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.liftHomotopyZeroZero f comm) (Q.complex.d 1 0) =
  f.f 0
-- CategoryTheory.ProjectiveResolution.liftHomotopyZeroOne_comp
@[reassoc (attr := simp)]
lemma liftHomotopyZeroOne_comp {Y Z : C} {P : ProjectiveResolution Y} {Q : ProjectiveResolution Z}
    (f : P.complex ⟶ Q.complex) (comm : f ≫ Q.π = 0) :
    liftHomotopyZeroOne f comm ≫ Q.complex.d 2 1 =
      f.f 1 - P.complex.d 1 0 ≫ liftHomotopyZeroZero f comm 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} {P : CategoryTheory.ProjectiveResolution Y} {Q : CategoryTheory.ProjectiveResolution Z} (f : P.complex ⟶ Q.complex) (comm : CategoryTheory.CategoryStruct.comp f Q.π = 0)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.liftHomotopyZeroOne f comm) (Q.complex.d 2 1) =
  f.f 1 -
    CategoryTheory.CategoryStruct.comp (P.complex.d 1 0)
      (CategoryTheory.ProjectiveResolution.liftHomotopyZeroZero f comm)
-- CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc_comp
@[reassoc (attr := simp)]
lemma liftHomotopyZeroSucc_comp {Y Z : C} {P : ProjectiveResolution Y} {Q : ProjectiveResolution Z}
    (f : P.complex ⟶ Q.complex) (n : ℕ) (g : P.complex.X n ⟶ Q.complex.X (n + 1))
    (g' : P.complex.X (n + 1) ⟶ Q.complex.X (n + 2))
    (w : f.f (n + 1) = P.complex.d (n + 1) n ≫ g + g' ≫ Q.complex.d (n + 2) (n + 1)) :
    liftHomotopyZeroSucc f n g g' w ≫ Q.complex.d (n + 3) (n + 2) =
      f.f (n + 2) - P.complex.d _ _ ≫ g' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} {P : CategoryTheory.ProjectiveResolution Y} {Q : CategoryTheory.ProjectiveResolution Z} (f : P.complex ⟶ Q.complex) (n : ℕ) (g : P.complex.X n ⟶ Q.complex.X (n + 1)) (g' : P.complex.X (n + 1) ⟶ Q.complex.X (n + 2)) (w :
  f.f (n + 1) =
    CategoryTheory.CategoryStruct.comp (P.complex.d (n + 1) n) g +
      CategoryTheory.CategoryStruct.comp g' (Q.complex.d (n + 2) (n + 1)))
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc f n g g' w)
    (Q.complex.d (n + 3) (n + 2)) =
  f.f (n + 2) - CategoryTheory.CategoryStruct.comp (P.complex.d (n + 2) (n + 1)) g'
-- CategoryTheory.ProjectiveResolution.homotopyEquiv_hom_π
@[reassoc (attr := simp)]
theorem homotopyEquiv_hom_π {X : C} (P Q : ProjectiveResolution X) :
    (homotopyEquiv P Q).hom ≫ Q.π = P.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {X : C} (P Q : CategoryTheory.ProjectiveResolution X)
Goal: CategoryTheory.CategoryStruct.comp (P.homotopyEquiv Q).hom Q.π = P.π
-- CategoryTheory.ProjectiveResolution.homotopyEquiv_inv_π
@[reassoc (attr := simp)]
theorem homotopyEquiv_inv_π {X : C} (P Q : ProjectiveResolution X) :
    (homotopyEquiv P Q).inv ≫ P.π = Q.π 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {X : C} (P Q : CategoryTheory.ProjectiveResolution X)
Goal: CategoryTheory.CategoryStruct.comp (P.homotopyEquiv Q).inv P.π = Q.π