ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.ProjectiveResolution.isoLeftDerivedObj_inv_naturality
@[reassoc]
lemma ProjectiveResolution.isoLeftDerivedObj_inv_naturality
    {X Y : C} (f : X ⟶ Y) (P : ProjectiveResolution X) (Q : ProjectiveResolution Y)
    (φ : P.complex ⟶ Q.complex) (comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f)
    (F : C ⥤ D) [F.Additive] (n : ℕ) :
    (P.isoLeftDerivedObj F n).inv ≫ (F.leftDerived n).map f =
        (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map φ ≫
          (Q.isoLeftDerivedObj F n).inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (P : CategoryTheory.ProjectiveResolution X) (Q : CategoryTheory.ProjectiveResolution Y) (φ : P.complex ⟶ Q.complex) (comm : CategoryTheory.CategoryStruct.comp (φ.f 0) (Q.π.f 0) = CategoryTheory.CategoryStruct.comp (P.π.f 0) f) (F : CategoryTheory.Functor C D) [F.Additive] (n : ℕ)
Goal: CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedObj F n).inv ((F.leftDerived n).map f) =
  CategoryTheory.CategoryStruct.comp
    (((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp
          (HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n)).map
      φ)
    (Q.isoLeftDerivedObj F n).inv
-- CategoryTheory.Functor.isZero_leftDerived_obj_projective_succ
lemma Functor.isZero_leftDerived_obj_projective_succ
    (F : C ⥤ D) [F.Additive] (n : ℕ) (X : C) [Projective X] :
    IsZero ((F.leftDerived (n + 1)).obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [F.Additive] (n : ℕ) (X : C) [CategoryTheory.Projective X]
Goal: CategoryTheory.Limits.IsZero ((F.leftDerived (n + 1)).obj X)
-- CategoryTheory.Functor.leftDerived_map_eq
theorem Functor.leftDerived_map_eq (F : C ⥤ D) [F.Additive] (n : ℕ) {X Y : C} (f : X ⟶ Y)
    {P : ProjectiveResolution X} {Q : ProjectiveResolution Y} (g : P.complex ⟶ Q.complex)
    (w : g ≫ Q.π = P.π ≫ (ChainComplex.single₀ C).map f) :
    (F.leftDerived n).map f =
      (P.isoLeftDerivedObj F n).hom ≫
        (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map g ≫
          (Q.isoLeftDerivedObj F n).inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [F.Additive] (n : ℕ) {X Y : C} (f : X ⟶ Y) {P : CategoryTheory.ProjectiveResolution X} {Q : CategoryTheory.ProjectiveResolution Y} (g : P.complex ⟶ Q.complex) (w : CategoryTheory.CategoryStruct.comp g Q.π = CategoryTheory.CategoryStruct.comp P.π ((ChainComplex.single₀ C).map f))
Goal: (F.leftDerived n).map f =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedObj F n).hom
    (CategoryTheory.CategoryStruct.comp
      (((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp
            (HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n)).map
        g)
      (Q.isoLeftDerivedObj F n).inv)
-- CategoryTheory.ProjectiveResolution.leftDerivedToHomotopyCategory_app_eq
lemma ProjectiveResolution.leftDerivedToHomotopyCategory_app_eq
    {F G : C ⥤ D} [F.Additive] [G.Additive] (α : F ⟶ G) {X : C} (P : ProjectiveResolution X) :
    (NatTrans.leftDerivedToHomotopyCategory α).app X =
      (P.isoLeftDerivedToHomotopyCategoryObj F).hom ≫
        (HomotopyCategory.quotient _ _).map
          ((NatTrans.mapHomologicalComplex α _).app P.complex) ≫
          (P.isoLeftDerivedToHomotopyCategoryObj G).inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] {F G : CategoryTheory.Functor C D} [F.Additive] [G.Additive] (α : F ⟶ G) {X : C} (P : CategoryTheory.ProjectiveResolution X)
Goal: (CategoryTheory.NatTrans.leftDerivedToHomotopyCategory α).app X =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedToHomotopyCategoryObj F).hom
    (CategoryTheory.CategoryStruct.comp
      ((HomotopyCategory.quotient D (ComplexShape.down ℕ)).map
        ((CategoryTheory.NatTrans.mapHomologicalComplex α (ComplexShape.down ℕ)).app P.complex))
      (P.isoLeftDerivedToHomotopyCategoryObj G).inv)
-- CategoryTheory.NatTrans.leftDerivedToHomotopyCategory_id
@[simp]
lemma NatTrans.leftDerivedToHomotopyCategory_id (F : C ⥤ D) [F.Additive] :
    NatTrans.leftDerivedToHomotopyCategory (𝟙 F) = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [F.Additive]
Goal: CategoryTheory.NatTrans.leftDerivedToHomotopyCategory (CategoryTheory.CategoryStruct.id F) =
  CategoryTheory.CategoryStruct.id F.leftDerivedToHomotopyCategory
-- CategoryTheory.NatTrans.leftDerivedToHomotopyCategory_comp
@[simp, reassoc]
lemma NatTrans.leftDerivedToHomotopyCategory_comp {F G H : C ⥤ D} (α : F ⟶ G) (β : G ⟶ H)
    [F.Additive] [G.Additive] [H.Additive] :
    NatTrans.leftDerivedToHomotopyCategory (α ≫ β) =
      NatTrans.leftDerivedToHomotopyCategory α ≫
        NatTrans.leftDerivedToHomotopyCategory β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] {F G H : CategoryTheory.Functor C D} (α : F ⟶ G) (β : G ⟶ H) [F.Additive] [G.Additive] [H.Additive]
Goal: CategoryTheory.NatTrans.leftDerivedToHomotopyCategory (CategoryTheory.CategoryStruct.comp α β) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.leftDerivedToHomotopyCategory α)
    (CategoryTheory.NatTrans.leftDerivedToHomotopyCategory β)
-- CategoryTheory.NatTrans.leftDerived_id
@[simp]
theorem NatTrans.leftDerived_id (F : C ⥤ D) [F.Additive] (n : ℕ) :
    NatTrans.leftDerived (𝟙 F) n = 𝟙 (F.leftDerived n) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [F.Additive] (n : ℕ)
Goal: CategoryTheory.NatTrans.leftDerived (CategoryTheory.CategoryStruct.id F) n =
  CategoryTheory.CategoryStruct.id (F.leftDerived n)
-- CategoryTheory.NatTrans.leftDerived_comp
@[simp, reassoc]
theorem NatTrans.leftDerived_comp {F G H : C ⥤ D} [F.Additive] [G.Additive] [H.Additive]
    (α : F ⟶ G) (β : G ⟶ H) (n : ℕ) :
    NatTrans.leftDerived (α ≫ β) n = NatTrans.leftDerived α n ≫ NatTrans.leftDerived β n 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] {F G H : CategoryTheory.Functor C D} [F.Additive] [G.Additive] [H.Additive] (α : F ⟶ G) (β : G ⟶ H) (n : ℕ)
Goal: CategoryTheory.NatTrans.leftDerived (CategoryTheory.CategoryStruct.comp α β) n =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.leftDerived α n) (CategoryTheory.NatTrans.leftDerived β n)
-- CategoryTheory.ProjectiveResolution.leftDerived_app_eq
lemma leftDerived_app_eq
    {F G : C ⥤ D} [F.Additive] [G.Additive] (α : F ⟶ G) {X : C} (P : ProjectiveResolution X)
    (n : ℕ) : (NatTrans.leftDerived α n).app X =
      (P.isoLeftDerivedObj F n).hom ≫
        (HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n).map
        ((NatTrans.mapHomologicalComplex α _).app P.complex) ≫
        (P.isoLeftDerivedObj G n).inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] {F G : CategoryTheory.Functor C D} [F.Additive] [G.Additive] (α : F ⟶ G) {X : C} (P : CategoryTheory.ProjectiveResolution X) (n : ℕ)
Goal: (CategoryTheory.NatTrans.leftDerived α n).app X =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedObj F n).hom
    (CategoryTheory.CategoryStruct.comp
      ((HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n).map
        ((CategoryTheory.NatTrans.mapHomologicalComplex α (ComplexShape.down ℕ)).app P.complex))
      (P.isoLeftDerivedObj G n).inv)
-- CategoryTheory.ProjectiveResolution.pOpcycles_comp_fromLeftDerivedZero'
@[reassoc (attr := simp)]
lemma pOpcycles_comp_fromLeftDerivedZero' {X : C}
    (P : ProjectiveResolution X) (F : C ⥤ D) [F.Additive] :
    HomologicalComplex.pOpcycles _ _ ≫ P.fromLeftDerivedZero' F = F.map (P.π.f 0) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.Abelian D] {X : C} (P : CategoryTheory.ProjectiveResolution X) (F : CategoryTheory.Functor C D) [F.Additive]
Goal: CategoryTheory.CategoryStruct.comp (((F.mapHomologicalComplex (ComplexShape.down ℕ)).obj P.complex).pOpcycles 0)
    (P.fromLeftDerivedZero' F) =
  F.map (P.π.f 0)
-- CategoryTheory.ProjectiveResolution.fromLeftDerivedZero'_naturality
@[reassoc]
lemma fromLeftDerivedZero'_naturality {X Y : C} (f : X ⟶ Y)
    (P : ProjectiveResolution X) (Q : ProjectiveResolution Y)
    (φ : P.complex ⟶ Q.complex) (comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f)
    (F : C ⥤ D) [F.Additive] :
    HomologicalComplex.opcyclesMap ((F.mapHomologicalComplex _).map φ) 0 ≫
        Q.fromLeftDerivedZero' F = P.fromLeftDerivedZero' F ≫ F.map f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (P : CategoryTheory.ProjectiveResolution X) (Q : CategoryTheory.ProjectiveResolution Y) (φ : P.complex ⟶ Q.complex) (comm : CategoryTheory.CategoryStruct.comp (φ.f 0) (Q.π.f 0) = CategoryTheory.CategoryStruct.comp (P.π.f 0) f) (F : CategoryTheory.Functor C D) [F.Additive]
Goal: CategoryTheory.CategoryStruct.comp
    (HomologicalComplex.opcyclesMap ((F.mapHomologicalComplex (ComplexShape.down ℕ)).map φ) 0)
    (Q.fromLeftDerivedZero' F) =
  CategoryTheory.CategoryStruct.comp (P.fromLeftDerivedZero' F) (F.map f)
-- CategoryTheory.ProjectiveResolution.fromLeftDerivedZero_eq
lemma ProjectiveResolution.fromLeftDerivedZero_eq
    {X : C} (P : ProjectiveResolution X) (F : C ⥤ D) [F.Additive] :
    F.fromLeftDerivedZero.app X = (P.isoLeftDerivedObj F 0).hom ≫
      (ChainComplex.isoHomologyι₀ _).hom ≫
        P.fromLeftDerivedZero' F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] {X : C} (P : CategoryTheory.ProjectiveResolution X) (F : CategoryTheory.Functor C D) [F.Additive]
Goal: F.fromLeftDerivedZero.app X =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedObj F 0).hom
    (CategoryTheory.CategoryStruct.comp
      (ChainComplex.isoHomologyι₀ ((F.mapHomologicalComplex (ComplexShape.down ℕ)).obj P.complex)).hom
      (P.fromLeftDerivedZero' F))
-- CategoryTheory.Functor.leftDerivedZeroIsoSelf_hom
@[simps! hom]
noncomputable def leftDerivedZeroIsoSelf : F.leftDerived 0 ≅ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [F.Additive] [CategoryTheory.Limits.PreservesFiniteColimits F]
Goal: F.leftDerivedZeroIsoSelf.hom = F.fromLeftDerivedZero
-- CategoryTheory.Functor.leftDerivedZeroIsoSelf_hom_inv_id
@[reassoc (attr := simp)]
lemma leftDerivedZeroIsoSelf_hom_inv_id :
    F.fromLeftDerivedZero ≫ F.leftDerivedZeroIsoSelf.inv = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [F.Additive] [CategoryTheory.Limits.PreservesFiniteColimits F]
Goal: CategoryTheory.CategoryStruct.comp F.fromLeftDerivedZero F.leftDerivedZeroIsoSelf.inv =
  CategoryTheory.CategoryStruct.id (F.leftDerived 0)
-- CategoryTheory.Functor.leftDerivedZeroIsoSelf_inv_hom_id
@[reassoc (attr := simp)]
lemma leftDerivedZeroIsoSelf_inv_hom_id :
    F.leftDerivedZeroIsoSelf.inv ≫ F.fromLeftDerivedZero =  𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [F.Additive] [CategoryTheory.Limits.PreservesFiniteColimits F]
Goal: CategoryTheory.CategoryStruct.comp F.leftDerivedZeroIsoSelf.inv F.fromLeftDerivedZero =
  CategoryTheory.CategoryStruct.id F
-- CategoryTheory.Functor.leftDerivedZeroIsoSelf_hom_inv_id_app
@[reassoc (attr := simp)]
lemma leftDerivedZeroIsoSelf_hom_inv_id_app (X : C) :
    F.fromLeftDerivedZero.app X ≫ F.leftDerivedZeroIsoSelf.inv.app X = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [F.Additive] [CategoryTheory.Limits.PreservesFiniteColimits F] (X : C)
Goal: CategoryTheory.CategoryStruct.comp (F.fromLeftDerivedZero.app X) (F.leftDerivedZeroIsoSelf.inv.app X) =
  CategoryTheory.CategoryStruct.id ((F.leftDerived 0).obj X)
-- CategoryTheory.Functor.leftDerivedZeroIsoSelf_inv_hom_id_app
@[reassoc (attr := simp)]
lemma leftDerivedZeroIsoSelf_inv_hom_id_app (X : C) :
    F.leftDerivedZeroIsoSelf.inv.app X ≫ F.fromLeftDerivedZero.app X = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [F.Additive] [CategoryTheory.Limits.PreservesFiniteColimits F] (X : C)
Goal: CategoryTheory.CategoryStruct.comp (F.leftDerivedZeroIsoSelf.inv.app X) (F.fromLeftDerivedZero.app X) =
  CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.NonPreadditiveAbelian.has_cokernels
class NonPreadditiveAbelian extends HasZeroMorphisms C, NormalMonoCategory C,
    NormalEpiCategory C where
  [has_zero_object : HasZeroObject C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
  [has_finite_products : HasFiniteProducts C]
  [has_finite_coproducts : HasFiniteCoproducts C]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.NonPreadditiveAbelian C]
Goal: CategoryTheory.Limits.HasCokernels C
-- CategoryTheory.NonPreadditiveAbelian.has_finite_coproducts
class NonPreadditiveAbelian extends HasZeroMorphisms C, NormalMonoCategory C,
    NormalEpiCategory C where
  [has_zero_object : HasZeroObject C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
  [has_finite_products : HasFiniteProducts C]
  [has_finite_coproducts : HasFiniteCoproducts C]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.NonPreadditiveAbelian C]
Goal: CategoryTheory.Limits.HasFiniteCoproducts C
-- CategoryTheory.NonPreadditiveAbelian.has_zero_object
class NonPreadditiveAbelian extends HasZeroMorphisms C, NormalMonoCategory C,
    NormalEpiCategory C where
  [has_zero_object : HasZeroObject C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
  [has_finite_products : HasFiniteProducts C]
  [has_finite_coproducts : HasFiniteCoproducts C]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.NonPreadditiveAbelian C]
Goal: CategoryTheory.Limits.HasZeroObject C
-- CategoryTheory.NonPreadditiveAbelian.has_kernels
class NonPreadditiveAbelian extends HasZeroMorphisms C, NormalMonoCategory C,
    NormalEpiCategory C where
  [has_zero_object : HasZeroObject C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
  [has_finite_products : HasFiniteProducts C]
  [has_finite_coproducts : HasFiniteCoproducts C]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.NonPreadditiveAbelian C]
Goal: CategoryTheory.Limits.HasKernels C
-- CategoryTheory.NonPreadditiveAbelian.has_finite_products
class NonPreadditiveAbelian extends HasZeroMorphisms C, NormalMonoCategory C,
    NormalEpiCategory C where
  [has_zero_object : HasZeroObject C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
  [has_finite_products : HasFiniteProducts C]
  [has_finite_coproducts : HasFiniteCoproducts C]
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.NonPreadditiveAbelian C]
Goal: CategoryTheory.Limits.HasFiniteProducts C
-- CategoryTheory.NonPreadditiveAbelian.diag_σ
@[reassoc]
theorem diag_σ {X : C} : diag X ≫ σ = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X : C}
Goal: CategoryTheory.Limits.diag X ≫ CategoryTheory.NonPreadditiveAbelian.σ = 0
-- CategoryTheory.NonPreadditiveAbelian.lift_σ
@[reassoc (attr := simp)]
theorem lift_σ {X : C} : prod.lift (𝟙 X) 0 ≫ σ = 𝟙 X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X : C}
Goal: CategoryTheory.Limits.prod.lift (𝟙 X) 0 ≫ CategoryTheory.NonPreadditiveAbelian.σ = 𝟙 X
-- CategoryTheory.NonPreadditiveAbelian.lift_map
@[reassoc]
theorem lift_map {X Y : C} (f : X ⟶ Y) :
    prod.lift (𝟙 X) 0 ≫ Limits.prod.map f f = f ≫ prod.lift (𝟙 Y) 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Limits.prod.lift (𝟙 X) 0 ≫ CategoryTheory.Limits.prod.map f f =
  f ≫ CategoryTheory.Limits.prod.lift (𝟙 Y) 0
-- CategoryTheory.NonPreadditiveAbelian.σ_comp
theorem σ_comp {X Y : C} (f : X ⟶ Y) : σ ≫ f = Limits.prod.map f f ≫ σ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.NonPreadditiveAbelian.σ ≫ f = CategoryTheory.Limits.prod.map f f ≫ CategoryTheory.NonPreadditiveAbelian.σ
-- CategoryTheory.NonPreadditiveAbelian.sub_def
theorem sub_def {X Y : C} (a b : X ⟶ Y) : a - b = prod.lift a b ≫ σ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b : X ⟶ Y)
Goal: a - b = CategoryTheory.Limits.prod.lift a b ≫ CategoryTheory.NonPreadditiveAbelian.σ
-- CategoryTheory.NonPreadditiveAbelian.add_def
theorem add_def {X Y : C} (a b : X ⟶ Y) : a + b = a - -b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b : X ⟶ Y)
Goal: a + b = a - -b
-- CategoryTheory.NonPreadditiveAbelian.neg_def
theorem neg_def {X Y : C} (a : X ⟶ Y) : -a = 0 - a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a : X ⟶ Y)
Goal: -a = 0 - a
-- CategoryTheory.NonPreadditiveAbelian.sub_zero
theorem sub_zero {X Y : C} (a : X ⟶ Y) : a - 0 = a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a : X ⟶ Y)
Goal: a - 0 = a
-- CategoryTheory.NonPreadditiveAbelian.sub_self
theorem sub_self {X Y : C} (a : X ⟶ Y) : a - a = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a : X ⟶ Y)
Goal: a - a = 0
-- CategoryTheory.NonPreadditiveAbelian.lift_sub_lift
theorem lift_sub_lift {X Y : C} (a b c d : X ⟶ Y) :
    prod.lift a b - prod.lift c d = prod.lift (a - c) (b - d) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b c d : X ⟶ Y)
Goal: CategoryTheory.Limits.prod.lift a b - CategoryTheory.Limits.prod.lift c d =
  CategoryTheory.Limits.prod.lift (a - c) (b - d)
-- CategoryTheory.NonPreadditiveAbelian.sub_sub_sub
theorem sub_sub_sub {X Y : C} (a b c d : X ⟶ Y) : a - c - (b - d) = a - b - (c - d) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b c d : X ⟶ Y)
Goal: a - c - (b - d) = a - b - (c - d)
-- CategoryTheory.NonPreadditiveAbelian.neg_sub
theorem neg_sub {X Y : C} (a b : X ⟶ Y) : -a - b = -b - a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b : X ⟶ Y)
Goal: -a - b = -b - a
-- CategoryTheory.NonPreadditiveAbelian.neg_neg
theorem neg_neg {X Y : C} (a : X ⟶ Y) : - -a = a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a : X ⟶ Y)
Goal: - -a = a
-- CategoryTheory.NonPreadditiveAbelian.add_comm
theorem add_comm {X Y : C} (a b : X ⟶ Y) : a + b = b + a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b : X ⟶ Y)
Goal: a + b = b + a
-- CategoryTheory.NonPreadditiveAbelian.add_neg
theorem add_neg {X Y : C} (a b : X ⟶ Y) : a + -b = a - b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b : X ⟶ Y)
Goal: a + -b = a - b
-- CategoryTheory.NonPreadditiveAbelian.add_neg_self
theorem add_neg_self {X Y : C} (a : X ⟶ Y) : a + -a = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a : X ⟶ Y)
Goal: a + -a = 0
-- CategoryTheory.NonPreadditiveAbelian.neg_add_self
theorem neg_add_self {X Y : C} (a : X ⟶ Y) : -a + a = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a : X ⟶ Y)
Goal: -a + a = 0
-- CategoryTheory.NonPreadditiveAbelian.neg_sub'
theorem neg_sub' {X Y : C} (a b : X ⟶ Y) : -(a - b) = -a + b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b : X ⟶ Y)
Goal: -(a - b) = -a + b
-- CategoryTheory.NonPreadditiveAbelian.neg_add
theorem neg_add {X Y : C} (a b : X ⟶ Y) : -(a + b) = -a - b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b : X ⟶ Y)
Goal: -(a + b) = -a - b
-- CategoryTheory.NonPreadditiveAbelian.sub_add
theorem sub_add {X Y : C} (a b c : X ⟶ Y) : a - b + c = a - (b - c) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b c : X ⟶ Y)
Goal: a - b + c = a - (b - c)
-- CategoryTheory.NonPreadditiveAbelian.add_assoc
theorem add_assoc {X Y : C} (a b c : X ⟶ Y) : a + b + c = a + (b + c) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a b c : X ⟶ Y)
Goal: a + b + c = a + (b + c)
-- CategoryTheory.NonPreadditiveAbelian.add_zero
theorem add_zero {X Y : C} (a : X ⟶ Y) : a + 0 = a 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y : C} (a : X ⟶ Y)
Goal: a + 0 = a
-- CategoryTheory.NonPreadditiveAbelian.comp_sub
theorem comp_sub {X Y Z : C} (f : X ⟶ Y) (g h : Y ⟶ Z) : f ≫ (g - h) = f ≫ g - f ≫ h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y Z : C} (f : X ⟶ Y) (g h : Y ⟶ Z)
Goal: f ≫ (g - h) = f ≫ g - f ≫ h
-- CategoryTheory.NonPreadditiveAbelian.sub_comp
theorem sub_comp {X Y Z : C} (f g : X ⟶ Y) (h : Y ⟶ Z) : (f - g) ≫ h = f ≫ h - g ≫ h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] {X Y Z : C} (f g : X ⟶ Y) (h : Y ⟶ Z)
Goal: (f - g) ≫ h = f ≫ h - g ≫ h
-- CategoryTheory.NonPreadditiveAbelian.comp_add
theorem comp_add (X Y Z : C) (f : X ⟶ Y) (g h : Y ⟶ Z) : f ≫ (g + h) = f ≫ g + f ≫ h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.NonPreadditiveAbelian C] (X Y Z : C) (f : X ⟶ Y) (g h : Y ⟶ Z)
Goal: f ≫ (g + h) = f ≫ g + f ≫ h