# Documentation

A functor between two preadditive categories is called additive provided that the induced map on hom types is a morphism of abelian groups.

An additive functor between preadditive categories creates and preserves biproducts. Conversely, if F : C ⥤ D is a functor between preadditive categories, where C has binary biproducts, and if F preserves binary biproducts, then F is additive.

We also define the category of bundled additive functors.

# Implementation details #

Functor.Additive is a Prop-valued class, defined by saying that for every two objects X and Y, the map F.map : (X ⟶ Y) → (F.obj X ⟶ F.obj Y) is a morphism of abelian groups.

class CategoryTheory.Functor.Additive {C : Type u_1} {D : Type u_2} [] [] (F : ) :
• map_add : ∀ {X Y : C} {f g : X Y}, F.map (f + g) = F.map f + F.map g

the addition of two morphisms is mapped to the sum of their images

A functor F is additive provided F.map is an additive homomorphism.

Instances
@[simp]
theorem CategoryTheory.Functor.map_add {C : Type u_1} {D : Type u_2} [] [] (F : ) {X : C} {Y : C} {f : X Y} {g : X Y} :
F.map (f + g) = F.map f + F.map g
@[simp]
theorem CategoryTheory.Functor.mapAddHom_apply {C : Type u_1} {D : Type u_2} [] [] (F : ) {X : C} {Y : C} (f : X Y) :
= F.map f
def CategoryTheory.Functor.mapAddHom {C : Type u_1} {D : Type u_2} [] [] (F : ) {X : C} {Y : C} :
(X Y) →+ (F.obj X F.obj Y)

F.mapAddHom is an additive homomorphism whose underlying function is F.map.

Instances For
theorem CategoryTheory.Functor.coe_mapAddHom {C : Type u_1} {D : Type u_2} [] [] (F : ) {X : C} {Y : C} :
= F.map
instance CategoryTheory.Functor.instAdditiveComp {C : Type u_1} {D : Type u_2} [] [] (F : ) {E : Type u_3} [] (G : ) :
@[simp]
theorem CategoryTheory.Functor.map_neg {C : Type u_1} {D : Type u_2} [] [] (F : ) {X : C} {Y : C} {f : X Y} :
F.map (-f) = -F.map f
@[simp]
theorem CategoryTheory.Functor.map_sub {C : Type u_1} {D : Type u_2} [] [] (F : ) {X : C} {Y : C} {f : X Y} {g : X Y} :
F.map (f - g) = F.map f - F.map g
theorem CategoryTheory.Functor.map_nsmul {C : Type u_1} {D : Type u_2} [] [] (F : ) {X : C} {Y : C} {f : X Y} {n : } :
F.map (n f) = n F.map f
theorem CategoryTheory.Functor.map_zsmul {C : Type u_1} {D : Type u_2} [] [] (F : ) {X : C} {Y : C} {f : X Y} {r : } :
F.map (r f) = r F.map f
@[simp]
theorem CategoryTheory.Functor.map_sum {C : Type u_1} {D : Type u_2} [] [] (F : ) {X : C} {Y : C} {α : Type u_3} (f : α → (X Y)) (s : ) :
F.map (Finset.sum s fun a => f a) = Finset.sum s fun a => F.map (f a)
instance CategoryTheory.Functor.inducedFunctor_additive {C : Type u_1} {D : Type u_2} [] (F : CD) :
def CategoryTheory.AdditiveFunctor (C : Type u_1) (D : Type u_2) [] [] :
Type (max (max (max u_1 u_2) u_3) u_4)

Instances For
instance CategoryTheory.instCategoryAdditiveFunctor (C : Type u_1) (D : Type u_2) [] [] :

the category of additive functors is denoted C ⥤+ D

Instances For

An additive functor is in particular a functor.

Instances For
def CategoryTheory.AdditiveFunctor.of {C : Type u_1} {D : Type u_2} [] [] (F : ) :
C ⥤+ D

Turn an additive functor into an object of the category AdditiveFunctor C D.

Instances For
@[simp]
theorem CategoryTheory.AdditiveFunctor.of_fst {C : Type u_1} {D : Type u_2} [] [] (F : ) :
= F
@[simp]
theorem CategoryTheory.AdditiveFunctor.forget_obj {C : Type u_1} {D : Type u_2} [] [] (F : C ⥤+ D) :
().obj F = F.obj
theorem CategoryTheory.AdditiveFunctor.forget_obj_of {C : Type u_1} {D : Type u_2} [] [] (F : ) :
@[simp]
theorem CategoryTheory.AdditiveFunctor.forget_map {C : Type u_1} {D : Type u_2} [] [] (F : C ⥤+ D) (G : C ⥤+ D) (α : F G) :
().map α = α
instance CategoryTheory.instAdditiveObjFunctor {C : Type u_1} {D : Type u_2} [] [] (F : C ⥤+ D) :

Turn a left exact functor into an additive functor.

Instances For

Turn a right exact functor into an additive functor.

Instances For

Turn an exact functor into an additive functor.

Instances For
@[simp]
theorem CategoryTheory.AdditiveFunctor.ofLeftExact_obj_fst {C : Type u₁} {D : Type u₂} [] [] (F : C ⥤ₗ D) :
(().obj F).obj = F.obj
@[simp]
theorem CategoryTheory.AdditiveFunctor.ofRightExact_obj_fst {C : Type u₁} {D : Type u₂} [] [] (F : C ⥤ᵣ D) :
(().obj F).obj = F.obj
@[simp]
theorem CategoryTheory.AdditiveFunctor.ofExact_obj_fst {C : Type u₁} {D : Type u₂} [] [] (F : C ⥤ₑ D) :
(().obj F).obj = F.obj
@[simp]
theorem CategoryTheory.AdditiveFunctor.ofLeftExact_map {C : Type u₁} {D : Type u₂} [] [] {F : C ⥤ₗ D} {G : C ⥤ₗ D} (α : F G) :
().map α = α
@[simp]
theorem CategoryTheory.AdditiveFunctor.ofRightExact_map {C : Type u₁} {D : Type u₂} [] [] {F : C ⥤ᵣ D} {G : C ⥤ᵣ D} (α : F G) :
().map α = α
@[simp]
theorem CategoryTheory.AdditiveFunctor.ofExact_map {C : Type u₁} {D : Type u₂} [] [] {F : C ⥤ₑ D} {G : C ⥤ₑ D} (α : F G) :
().map α = α