ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.InjectivePresentation.injective
structure InjectivePresentation (X : C) where
  J : C
  injective : Injective J := by infer_instance
  f : X ⟶ J
  mono : Mono f := by infer_instance
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X : C} (self : CategoryTheory.InjectivePresentation X)
Goal: CategoryTheory.Injective self.J
-- CategoryTheory.EnoughInjectives.presentation
class EnoughInjectives : Prop where
  presentation : ∀ X : C, Nonempty (InjectivePresentation X)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [self : CategoryTheory.EnoughInjectives C] (X : C)
Goal: Nonempty (CategoryTheory.InjectivePresentation X)
-- CategoryTheory.Injective.comp_factorThru
@[simp]
theorem comp_factorThru {J X Y : C} [Injective J] (g : X ⟶ J) (f : X ⟶ Y) [Mono f] :
    f ≫ factorThru g f = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J X Y : C} [CategoryTheory.Injective J] (g : X ⟶ J) (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: f ≫ CategoryTheory.Injective.factorThru g f = g
-- CategoryTheory.Injective.of_iso
theorem of_iso {P Q : C} (i : P ≅ Q) (hP : Injective P) : Injective Q 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P Q : C} (i : P ≅ Q) (hP : CategoryTheory.Injective P)
Goal: CategoryTheory.Injective Q
-- CategoryTheory.Injective.iso_iff
theorem iso_iff {P Q : C} (i : P ≅ Q) : Injective P ↔ Injective Q 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P Q : C} (i : P ≅ Q)
Goal: CategoryTheory.Injective P ↔ CategoryTheory.Injective Q
-- CategoryTheory.Injective.injective_iff_projective_op
theorem injective_iff_projective_op {J : C} : Injective J ↔ Projective (op J) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : C}
Goal: CategoryTheory.Injective J ↔ CategoryTheory.Projective (Opposite.op J)
-- CategoryTheory.Injective.projective_iff_injective_op
theorem projective_iff_injective_op {P : C} : Projective P ↔ Injective (op P) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : C}
Goal: CategoryTheory.Projective P ↔ CategoryTheory.Injective (Opposite.op P)
-- CategoryTheory.Injective.injective_iff_preservesEpimorphisms_yoneda_obj
theorem injective_iff_preservesEpimorphisms_yoneda_obj (J : C) :
    Injective J ↔ (yoneda.obj J).PreservesEpimorphisms 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : C)
Goal: CategoryTheory.Injective J ↔ (CategoryTheory.yoneda.obj J).PreservesEpimorphisms
-- CategoryTheory.Injective.injective_of_adjoint
theorem injective_of_adjoint (adj : L ⊣ R) (J : D) [Injective J] : Injective <| R.obj J 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} [L.PreservesMonomorphisms] (adj : L ⊣ R) (J : D) [CategoryTheory.Injective J]
Goal: CategoryTheory.Injective (R.obj J)
-- CategoryTheory.Injective.enoughProjectives_of_enoughInjectives_op
theorem enoughProjectives_of_enoughInjectives_op [EnoughInjectives Cᵒᵖ] : EnoughProjectives C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.EnoughInjectives Cᵒᵖ]
Goal: CategoryTheory.EnoughProjectives C
-- CategoryTheory.Injective.enoughInjectives_of_enoughProjectives_op
theorem enoughInjectives_of_enoughProjectives_op [EnoughProjectives Cᵒᵖ] : EnoughInjectives C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.EnoughProjectives Cᵒᵖ]
Goal: CategoryTheory.EnoughInjectives C
-- CategoryTheory.Adjunction.map_injective
theorem map_injective (adj : F ⊣ G) [F.PreservesMonomorphisms] (I : D) (hI : Injective I) :
    Injective (G.obj I) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {F : C ⥤ D} {G : D ⥤ C} (adj : F ⊣ G) [F.PreservesMonomorphisms] (I : D) (hI : CategoryTheory.Injective I)
Goal: CategoryTheory.Injective (G.obj I)
-- CategoryTheory.Adjunction.injective_of_map_injective
theorem injective_of_map_injective (adj : F ⊣ G) [G.Full] [G.Faithful] (I : D)
    (hI : Injective (G.obj I)) : Injective I 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] {F : C ⥤ D} {G : D ⥤ C} (adj : F ⊣ G) [G.Full] [G.Faithful] (I : D) (hI : CategoryTheory.Injective (G.obj I))
Goal: CategoryTheory.Injective I
-- CategoryTheory.EnoughInjectives.of_adjunction
lemma EnoughInjectives.of_adjunction {C : Type u₁} {D : Type u₂}
    [Category.{v₁} C] [Category.{v₂} D]
    {L : C ⥤ D} {R : D ⥤ C} (adj : L ⊣ R) [L.PreservesMonomorphisms] [L.ReflectsMonomorphisms]
    [EnoughInjectives D] : EnoughInjectives C 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] {L : C ⥤ D} {R : D ⥤ C} (adj : L ⊣ R) [L.PreservesMonomorphisms] [L.ReflectsMonomorphisms] [CategoryTheory.EnoughInjectives D]
Goal: CategoryTheory.EnoughInjectives C
-- CategoryTheory.EnoughInjectives.of_equivalence
lemma EnoughInjectives.of_equivalence {C : Type u₁} {D : Type u₂}
    [Category.{v₁} C] [Category.{v₂} D]
    (e : C ⥤ D) [e.IsEquivalence] [EnoughInjectives D] : EnoughInjectives C 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] (e : C ⥤ D) [e.IsEquivalence] [CategoryTheory.EnoughInjectives D]
Goal: CategoryTheory.EnoughInjectives C
-- CategoryTheory.Equivalence.map_injective_iff
theorem map_injective_iff (P : C) : Injective (F.functor.obj P) ↔ Injective P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (F : C ≌ D) (P : C)
Goal: CategoryTheory.Injective (F.functor.obj P) ↔ CategoryTheory.Injective P
-- CategoryTheory.Equivalence.enoughInjectives_iff
theorem enoughInjectives_iff (F : C ≌ D) : EnoughInjectives C ↔ EnoughInjectives D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u_1} [CategoryTheory.Category.{u_2, u_1} D] (F : C ≌ D)
Goal: CategoryTheory.EnoughInjectives C ↔ CategoryTheory.EnoughInjectives D
-- CategoryTheory.Presieve.factorsThruAlong_id
@[simp]
lemma factorsThruAlong_id {X : C} (S T : Presieve X) :
    S.FactorsThruAlong T (𝟙 X) ↔ S.FactorsThru T 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] {X : C} (S T : CategoryTheory.Presieve X)
Goal: S.FactorsThruAlong T (CategoryTheory.CategoryStruct.id X) ↔ S.FactorsThru T
-- CategoryTheory.Presieve.factorsThru_of_le
lemma factorsThru_of_le {X : C} (S T : Presieve X) (h : S ≤ T) :
    S.FactorsThru T 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] {X : C} (S T : CategoryTheory.Presieve X) (h : S ≤ T)
Goal: S.FactorsThru T
-- CategoryTheory.Presieve.le_of_factorsThru_sieve
lemma le_of_factorsThru_sieve {X : C} (S : Presieve X) (T : Sieve X) (h : S.FactorsThru T) :
    S ≤ T 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] {X : C} (S : CategoryTheory.Presieve X) (T : CategoryTheory.Sieve X) (h : S.FactorsThru T.arrows)
Goal: S ≤ T.arrows
-- CategoryTheory.Presieve.factorsThru_top
lemma factorsThru_top {X : C} (S : Presieve X) : S.FactorsThru ⊤ 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] {X : C} (S : CategoryTheory.Presieve X)
Goal: S.FactorsThru ⊤
-- CategoryTheory.Presieve.isSheafFor_of_factorsThru
lemma isSheafFor_of_factorsThru
    {X : C} {S T : Presieve X}
    (P : Cᵒᵖ ⥤ Type*)
    (H : S.FactorsThru T) (hS : S.IsSheafFor P)
    (h : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, T f → ∃ (R : Presieve Y),
      R.IsSeparatedFor P ∧ R.FactorsThruAlong S f) :
    T.IsSheafFor P 
Arguments: {C : Type u_3} [CategoryTheory.Category.{u_2, u_3} C] {X : C} {S T : CategoryTheory.Presieve X} (P : CategoryTheory.Functor Cᵒᵖ (Type u_1)) (H : S.FactorsThru T) (hS : CategoryTheory.Presieve.IsSheafFor P S) (h : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, T f → ∃ R, CategoryTheory.Presieve.IsSeparatedFor P R ∧ R.FactorsThruAlong S f)
Goal: CategoryTheory.Presieve.IsSheafFor P T
-- CategoryTheory.Coverage.pullback
@[ext]
structure Coverage where
    covering : ∀ (X : C), Set (Presieve X)
    pullback : ∀ ⦃X Y : C⦄ (f : Y ⟶ X) (S : Presieve X) (_ : S ∈ covering X),
    ∃ (T : Presieve Y), T ∈ covering Y ∧ T.FactorsThruAlong S f
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (self : CategoryTheory.Coverage C) ⦃X Y : C⦄ (f : Y ⟶ X) (S : CategoryTheory.Presieve X)
Goal: S ∈ self.covering X → ∃ T ∈ self.covering Y, T.FactorsThruAlong S f
-- CategoryTheory.Coverage.ofGrothendieck_iff
lemma ofGrothendieck_iff {X : C} {S : Presieve X} (J : GrothendieckTopology C) :
    S ∈ ofGrothendieck _ J X ↔ Sieve.generate S ∈ J X 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] {X : C} {S : CategoryTheory.Presieve X} (J : CategoryTheory.GrothendieckTopology C)
Goal: S ∈ (CategoryTheory.Coverage.ofGrothendieck C J).covering X ↔ CategoryTheory.Sieve.generate S ∈ J.sieves X
-- CategoryTheory.Coverage.eq_top_pullback
lemma eq_top_pullback {X Y : C} {S T : Sieve X} (h : S ≤ T) (f : Y ⟶ X) (hf : S f) :
    T.pullback f = ⊤ 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {S T : CategoryTheory.Sieve X} (h : S ≤ T) (f : Y ⟶ X) (hf : S.arrows f)
Goal: CategoryTheory.Sieve.pullback f T = ⊤
-- CategoryTheory.Coverage.saturate_of_superset
lemma saturate_of_superset (K : Coverage C) {X : C} {S T : Sieve X} (h : S ≤ T)
    (hS : Saturate K X S) : Saturate K X T 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (K : CategoryTheory.Coverage C) {X : C} {S T : CategoryTheory.Sieve X} (h : S ≤ T) (hS : K.Saturate X S)
Goal: K.Saturate X T
-- CategoryTheory.Coverage.toGrothendieck_eq_sInf
theorem toGrothendieck_eq_sInf (K : Coverage C) : toGrothendieck _ K =
    sInf {J | K ≤ ofGrothendieck _ J } 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (K : CategoryTheory.Coverage C)
Goal: CategoryTheory.Coverage.toGrothendieck C K = sInf {J | K ≤ CategoryTheory.Coverage.ofGrothendieck C J}
-- CategoryTheory.Coverage.sup_covering
@[simp]
lemma sup_covering (x y : Coverage C) (B : C) :
    (x ⊔ y).covering B = x.covering B ∪ y.covering B 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (x y : CategoryTheory.Coverage C) (B : C)
Goal: (x ⊔ y).covering B = x.covering B ∪ y.covering B
-- CategoryTheory.Coverage.mem_toGrothendieck_sieves_of_superset
theorem mem_toGrothendieck_sieves_of_superset (K : Coverage C) {X : C} {S : Sieve X}
    {R : Presieve X} (h : R ≤ S) (hR : R ∈ K.covering X) : S ∈ (K.toGrothendieck C).sieves X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (K : CategoryTheory.Coverage C) {X : C} {S : CategoryTheory.Sieve X} {R : CategoryTheory.Presieve X} (h : R ≤ S.arrows) (hR : R ∈ K.covering X)
Goal: S ∈ (CategoryTheory.Coverage.toGrothendieck C K).sieves X
-- CategoryTheory.Presieve.isSheaf_coverage
theorem isSheaf_coverage (K : Coverage C) (P : Cᵒᵖ ⥤ Type*) :
    Presieve.IsSheaf (toGrothendieck _ K) P ↔
    (∀ {X : C} (R : Presieve X), R ∈ K X → Presieve.IsSheafFor P R) 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_3, u_2} C] (K : CategoryTheory.Coverage C) (P : CategoryTheory.Functor Cᵒᵖ (Type u_1))
Goal: CategoryTheory.Presieve.IsSheaf (CategoryTheory.Coverage.toGrothendieck C K) P ↔
  ∀ {X : C}, ∀ R ∈ K.covering X, CategoryTheory.Presieve.IsSheafFor P R
-- CategoryTheory.Presieve.isSheaf_sup
theorem isSheaf_sup (K L : Coverage C) (P : Cᵒᵖ ⥤ Type*) :
    (Presieve.IsSheaf ((K ⊔ L).toGrothendieck C)) P ↔
    (Presieve.IsSheaf (K.toGrothendieck C)) P ∧ (Presieve.IsSheaf (L.toGrothendieck C)) P 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_3, u_2} C] (K L : CategoryTheory.Coverage C) (P : CategoryTheory.Functor Cᵒᵖ (Type u_1))
Goal: CategoryTheory.Presieve.IsSheaf (CategoryTheory.Coverage.toGrothendieck C (K ⊔ L)) P ↔
  CategoryTheory.Presieve.IsSheaf (CategoryTheory.Coverage.toGrothendieck C K) P ∧
    CategoryTheory.Presieve.IsSheaf (CategoryTheory.Coverage.toGrothendieck C L) P
-- CategoryTheory.Presheaf.isSheaf_iff_isLimit_coverage
theorem isSheaf_iff_isLimit_coverage (K : Coverage C) (P : Cᵒᵖ ⥤ D) :
    Presheaf.IsSheaf (toGrothendieck _ K) P ↔ ∀ ⦃X : C⦄ (R : Presieve X),
      R ∈ K.covering X →
        Nonempty (IsLimit (P.mapCone (Sieve.generate R).arrows.cocone.op)) 
Arguments: {C : Type u_1} {D : Type u_4} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Category.{u_3, u_4} D] (K : CategoryTheory.Coverage C) (P : CategoryTheory.Functor Cᵒᵖ D)
Goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.Coverage.toGrothendieck C K) P ↔
  ∀ ⦃X : C⦄,
    ∀ R ∈ K.covering X,
      Nonempty (CategoryTheory.Limits.IsLimit (P.mapCone (CategoryTheory.Sieve.generate R).arrows.cocone.op))
-- CategoryTheory.Presheaf.isSheaf_sup
theorem isSheaf_sup (K L : Coverage C) (P : Cᵒᵖ ⥤ D) :
    (IsSheaf ((K ⊔ L).toGrothendieck C)) P ↔
    (IsSheaf (K.toGrothendieck C)) P ∧ (IsSheaf (L.toGrothendieck C)) P 
Arguments: {C : Type u_1} {D : Type u_4} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Category.{u_3, u_4} D] (K L : CategoryTheory.Coverage C) (P : CategoryTheory.Functor Cᵒᵖ D)
Goal: CategoryTheory.Presheaf.IsSheaf (CategoryTheory.Coverage.toGrothendieck C (K ⊔ L)) P ↔
  CategoryTheory.Presheaf.IsSheaf (CategoryTheory.Coverage.toGrothendieck C K) P ∧
    CategoryTheory.Presheaf.IsSheaf (CategoryTheory.Coverage.toGrothendieck C L) P
-- CategoryTheory.Functor.Additive.map_add
class Functor.Additive {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
  (F : C ⥤ D) : Prop where
    map_add : ∀ {X Y : C} {f g : X ⟶ Y}, F.map (f + g) = F.map f + F.map g := by aesop_cat
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] {F : CategoryTheory.Functor C D} [self : F.Additive] {X Y : C} {f g : X ⟶ Y}
Goal: F.map (f + g) = F.map f + F.map g
-- CategoryTheory.Functor.map_add
@[simp]
theorem map_add {X Y : C} {f g : X ⟶ Y} : F.map (f + g) = F.map f + F.map g 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive] {X Y : C} {f g : X ⟶ Y}
Goal: F.map (f + g) = F.map f + F.map g
-- CategoryTheory.Functor.mapAddHom_apply
@[simps!]
def mapAddHom {X Y : C} : (X ⟶ Y) →+ (F.obj X ⟶ F.obj Y) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive] {X Y : C} (f : X ⟶ Y)
Goal: F.mapAddHom f = F.map f
-- CategoryTheory.Functor.coe_mapAddHom
theorem coe_mapAddHom {X Y : C} : ⇑(F.mapAddHom : (X ⟶ Y) →+ _) = F.map 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive] {X Y : C}
Goal: ⇑F.mapAddHom = F.map
-- CategoryTheory.Functor.map_neg
@[simp]
theorem map_neg {X Y : C} {f : X ⟶ Y} : F.map (-f) = -F.map f 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive] {X Y : C} {f : X ⟶ Y}
Goal: F.map (-f) = -F.map f
-- CategoryTheory.Functor.map_sub
@[simp]
theorem map_sub {X Y : C} {f g : X ⟶ Y} : F.map (f - g) = F.map f - F.map g 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive] {X Y : C} {f g : X ⟶ Y}
Goal: F.map (f - g) = F.map f - F.map g
-- CategoryTheory.Functor.map_nsmul
theorem map_nsmul {X Y : C} {f : X ⟶ Y} {n : ℕ} : F.map (n • f) = n • F.map f 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive] {X Y : C} {f : X ⟶ Y} {n : ℕ}
Goal: F.map (n • f) = n • F.map f
-- CategoryTheory.Functor.map_zsmul
theorem map_zsmul {X Y : C} {f : X ⟶ Y} {r : ℤ} : F.map (r • f) = r • F.map f 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive] {X Y : C} {f : X ⟶ Y} {r : ℤ}
Goal: F.map (r • f) = r • F.map f
-- CategoryTheory.Functor.map_sum
@[simp]
nonrec theorem map_sum {X Y : C} {α : Type*} (f : α → (X ⟶ Y)) (s : Finset α) :
    F.map (∑ a ∈ s, f a) = ∑ a ∈ s, F.map (f a) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive] {X Y : C} {α : Type u_4} (f : α → (X ⟶ Y)) (s : Finset α)
Goal: F.map (∑ a ∈ s, f a) = ∑ a ∈ s, F.map (f a)
-- CategoryTheory.Functor.additive_of_iso
lemma additive_of_iso {G : C ⥤ D} (e : F ≅ G) : G.Additive 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] {F : CategoryTheory.Functor C D} [F.Additive] {G : CategoryTheory.Functor C D} (e : F ≅ G)
Goal: G.Additive
-- CategoryTheory.Functor.additive_of_full_essSurj_comp
lemma additive_of_full_essSurj_comp [Full F] [EssSurj F] (G : D ⥤ E)
    [(F ⋙ G).Additive] : G.Additive 
Arguments: {C : Type u_1} {D : Type u_2} {E : Type u_3} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Category.{u_6, u_3} E] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Preadditive E] (F : CategoryTheory.Functor C D) [F.Additive] [F.Full] [F.EssSurj] (G : CategoryTheory.Functor D E) [(F.comp G).Additive]
Goal: G.Additive
-- CategoryTheory.Functor.additive_of_comp_faithful
lemma additive_of_comp_faithful
    (F : C ⥤ D) (G : D ⥤ E) [G.Additive] [(F ⋙ G).Additive] [Faithful G] :
    F.Additive 
Arguments: {C : Type u_1} {D : Type u_2} {E : Type u_3} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Category.{u_6, u_3} E] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Preadditive E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [G.Additive] [(F.comp G).Additive] [G.Faithful]
Goal: F.Additive
-- CategoryTheory.Functor.hasZeroObject_of_additive
lemma hasZeroObject_of_additive [HasZeroObject C] :
    HasZeroObject D 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_5, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive] [CategoryTheory.Limits.HasZeroObject C]
Goal: CategoryTheory.Limits.HasZeroObject D
-- CategoryTheory.Functor.additive_of_preservesBinaryBiproducts
theorem additive_of_preservesBinaryBiproducts [HasBinaryBiproducts C] [PreservesZeroMorphisms F]
    [PreservesBinaryBiproducts F] : Additive F 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasBinaryBiproducts C] [F.PreservesZeroMorphisms] [CategoryTheory.Limits.PreservesBinaryBiproducts F]
Goal: F.Additive
-- CategoryTheory.Functor.additive_of_preserves_binary_products
lemma additive_of_preserves_binary_products
    [HasBinaryProducts C] [PreservesLimitsOfShape (Discrete WalkingPair) F]
    [F.PreservesZeroMorphisms] : F.Additive 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasBinaryProducts C] [CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F] [F.PreservesZeroMorphisms]
Goal: F.Additive
-- CategoryTheory.AdditiveFunctor.of_fst
@[simp]
theorem AdditiveFunctor.of_fst (F : C ⥤ D) [F.Additive] : (AdditiveFunctor.of F).1 = F 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive]
Goal: (CategoryTheory.AdditiveFunctor.of F).obj = F
-- CategoryTheory.AdditiveFunctor.forget_obj
@[simp]
theorem AdditiveFunctor.forget_obj (F : C ⥤+ D) : (AdditiveFunctor.forget C D).obj F = F.1 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : C ⥤+ D)
Goal: (CategoryTheory.AdditiveFunctor.forget C D).obj F = F.obj
-- CategoryTheory.AdditiveFunctor.forget_obj_of
theorem AdditiveFunctor.forget_obj_of (F : C ⥤ D) [F.Additive] :
    (AdditiveFunctor.forget C D).obj (AdditiveFunctor.of F) = F 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [F.Additive]
Goal: (CategoryTheory.AdditiveFunctor.forget C D).obj (CategoryTheory.AdditiveFunctor.of F) = F
-- CategoryTheory.AdditiveFunctor.forget_map
@[simp]
theorem AdditiveFunctor.forget_map (F G : C ⥤+ D) (α : F ⟶ G) :
    (AdditiveFunctor.forget C D).map α = α 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] (F G : C ⥤+ D) (α : F ⟶ G)
Goal: (CategoryTheory.AdditiveFunctor.forget C D).map α = α
-- CategoryTheory.AdditiveFunctor.ofLeftExact_obj_fst
@[simp]
theorem AdditiveFunctor.ofLeftExact_obj_fst (F : C ⥤ₗ D) :
    ((AdditiveFunctor.ofLeftExact C D).obj F).obj = F.obj 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasBinaryBiproducts C] (F : C ⥤ₗ D)
Goal: ((CategoryTheory.AdditiveFunctor.ofLeftExact C D).obj F).obj = F.obj
-- CategoryTheory.AdditiveFunctor.ofRightExact_obj_fst
@[simp]
theorem AdditiveFunctor.ofRightExact_obj_fst (F : C ⥤ᵣ D) :
    ((AdditiveFunctor.ofRightExact C D).obj F).obj = F.obj 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasBinaryBiproducts C] (F : C ⥤ᵣ D)
Goal: ((CategoryTheory.AdditiveFunctor.ofRightExact C D).obj F).obj = F.obj
-- CategoryTheory.AdditiveFunctor.ofExact_obj_fst
@[simp]
theorem AdditiveFunctor.ofExact_obj_fst (F : C ⥤ₑ D) :
    ((AdditiveFunctor.ofExact C D).obj F).obj = F.obj 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasBinaryBiproducts C] (F : C ⥤ₑ D)
Goal: ((CategoryTheory.AdditiveFunctor.ofExact C D).obj F).obj = F.obj
-- CategoryTheory.AdditiveFunctor.ofLeftExact_map
@[simp]
theorem AdditiveFunctor.ofLeftExact_map {F G : C ⥤ₗ D} (α : F ⟶ G) :
    (AdditiveFunctor.ofLeftExact C D).map α = α 
Arguments: {C : Type u₁} {D : Type u₂} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasBinaryBiproducts C] {F G : C ⥤ₗ D} (α : F ⟶ G)
Goal: (CategoryTheory.AdditiveFunctor.ofLeftExact C D).map α = α