File: Mathlib/CategoryTheory/Preadditive/AdditiveFunctor.lean

full_name: CategoryTheory.Functor.Additive
code: /-- A functor `F` is additive provided `F.map` is an additive homomorphism. -/
class Functor.Additive {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
  (F : C ⥤ D) : Prop where
  /-- the addition of two morphisms is mapped to the sum of their images -/
  map_add : ∀ {X Y : C} {f g : X ⟶ Y}, F.map (f + g) = F.map f + F.map g := by aesop_cat
goal: Prop

full_name: CategoryTheory.Functor.Additive.map_add
code: /-- A functor `F` is additive provided `F.map` is an additive homomorphism. -/
class Functor.Additive {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
  (F : C ⥤ D) : Prop where
  /-- the addition of two morphisms is mapped to the sum of their images -/
  map_add : ∀ {X Y : C} {f g : X ⟶ Y}, F.map (f + g) = F.map f + F.map g := by aesop_cat
goal: F.map (f + g) = F.map f + F.map g

full_name: CategoryTheory.Functor.map_add
code: @[simp]
theorem map_add {X Y : C} {f g : X ⟶ Y} : F.map (f + g) = F.map f + F.map g 
goal: F.map (f + g) = F.map f + F.map g

full_name: CategoryTheory.Functor.mapAddHom_apply
code: /-- `F.mapAddHom` is an additive homomorphism whose underlying function is `F.map`. -/
@[simps!]
def mapAddHom {X Y : C} : (X ⟶ Y) →+ (F.obj X ⟶ F.obj Y) 
goal: F.mapAddHom f = F.map f

full_name: CategoryTheory.Functor.mapAddHom
code: /-- `F.mapAddHom` is an additive homomorphism whose underlying function is `F.map`. -/
@[simps!]
def mapAddHom {X Y : C} : (X ⟶ Y) →+ (F.obj X ⟶ F.obj Y) 
goal: (X ⟶ Y) →+ (F.obj X ⟶ F.obj Y)

full_name: CategoryTheory.Functor.coe_mapAddHom
code: theorem coe_mapAddHom {X Y : C} : ⇑(F.mapAddHom : (X ⟶ Y) →+ _) = F.map 
goal: ⇑F.mapAddHom = F.map

full_name: CategoryTheory.Functor.preservesZeroMorphisms_of_additive
code: instance (priority := 100) preservesZeroMorphisms_of_additive : PreservesZeroMorphisms F 
goal: F.PreservesZeroMorphisms

full_name: CategoryTheory.Functor.instAdditiveId
code: instance : Additive (𝟭 C) 
goal: (CategoryTheory.Functor.id C).Additive

full_name: CategoryTheory.Functor.instAdditiveComp
code: instance {E : Type*} [Category E] [Preadditive E] (G : D ⥤ E) [Functor.Additive G] :
    Additive (F ⋙ G) 
goal: (F.comp G).Additive

full_name: CategoryTheory.Functor.map_neg
code: @[simp]
theorem map_neg {X Y : C} {f : X ⟶ Y} : F.map (-f) = -F.map f 
goal: F.map (-f) = -F.map f

full_name: CategoryTheory.Functor.map_sub
code: @[simp]
theorem map_sub {X Y : C} {f g : X ⟶ Y} : F.map (f - g) = F.map f - F.map g 
goal: F.map (f - g) = F.map f - F.map g

full_name: CategoryTheory.Functor.map_nsmul
code: theorem map_nsmul {X Y : C} {f : X ⟶ Y} {n : ℕ} : F.map (n • f) = n • F.map f 
goal: F.map (n • f) = n • F.map f

full_name: CategoryTheory.Functor.map_zsmul
code: theorem map_zsmul {X Y : C} {f : X ⟶ Y} {r : ℤ} : F.map (r • f) = r • F.map f 
goal: F.map (r • f) = r • F.map f

full_name: CategoryTheory.Functor.map_sum
code: @[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) 
goal: F.map (∑ a ∈ s, f a) = ∑ a ∈ s, F.map (f a)

full_name: CategoryTheory.Functor.additive_of_iso
code: lemma additive_of_iso {G : C ⥤ D} (e : F ≅ G) : G.Additive 
goal: G.Additive

full_name: CategoryTheory.Functor.additive_of_full_essSurj_comp
code: lemma additive_of_full_essSurj_comp [Full F] [EssSurj F] (G : D ⥤ E)
    [(F ⋙ G).Additive] : G.Additive 
goal: G.Additive

full_name: CategoryTheory.Functor.additive_of_comp_faithful
code: lemma additive_of_comp_faithful
    (F : C ⥤ D) (G : D ⥤ E) [G.Additive] [(F ⋙ G).Additive] [Faithful G] :
    F.Additive 
goal: F.Additive

full_name: CategoryTheory.Functor.hasZeroObject_of_additive
code: lemma hasZeroObject_of_additive [HasZeroObject C] :
    HasZeroObject D 
goal: CategoryTheory.Limits.HasZeroObject D

full_name: CategoryTheory.Functor.inducedFunctor_additive
code: instance inducedFunctor_additive : Functor.Additive (inducedFunctor F) 
goal: (CategoryTheory.inducedFunctor F).Additive

full_name: CategoryTheory.Functor.fullSubcategoryInclusion_additive
code: instance fullSubcategoryInclusion_additive {C : Type*} [Category C] [Preadditive C]
    (Z : C → Prop) : (fullSubcategoryInclusion Z).Additive 
goal: (CategoryTheory.fullSubcategoryInclusion Z).Additive

full_name: CategoryTheory.Functor.preservesFiniteBiproductsOfAdditive
code: instance (priority := 100) preservesFiniteBiproductsOfAdditive [Additive F] :
    PreservesFiniteBiproducts F 
goal: CategoryTheory.Limits.PreservesFiniteBiproducts F

full_name: CategoryTheory.Functor.additive_of_preservesBinaryBiproducts
code: theorem additive_of_preservesBinaryBiproducts [HasBinaryBiproducts C] [PreservesZeroMorphisms F]
    [PreservesBinaryBiproducts F] : Additive F 
goal: F.Additive

full_name: CategoryTheory.Functor.additive_of_preserves_binary_products
code: lemma additive_of_preserves_binary_products
    [HasBinaryProducts C] [PreservesLimitsOfShape (Discrete WalkingPair) F]
    [F.PreservesZeroMorphisms] : F.Additive 
goal: F.Additive

full_name: CategoryTheory.Equivalence.inverse_additive
code: instance inverse_additive (e : C ≌ D) [e.functor.Additive] : e.inverse.Additive 
goal: e.inverse.Additive

full_name: CategoryTheory.AdditiveFunctor
code: /-- Bundled additive functors. -/
def AdditiveFunctor 
goal: Type (max (max (max u_1 u_2) u_3) u_4)

full_name: CategoryTheory.instCategoryAdditiveFunctor
code: instance : Category (AdditiveFunctor C D) 
goal: CategoryTheory.Category.{max u_1 u_4, max (max (max u_4 u_3) u_2) u_1} (C ⥤+ D)

full_name: CategoryTheory.«_aux_Mathlib_CategoryTheory_Preadditive_AdditiveFunctor___macroRules_CategoryTheory_term_⥤+__1»
code: /-- the category of additive functors is denoted `C ⥤+ D` -/
infixr:26 " ⥤+ " => AdditiveFunctor
goal: Lean.Macro

full_name: CategoryTheory._aux_Mathlib_CategoryTheory_Preadditive_AdditiveFunctor___unexpand_CategoryTheory_AdditiveFunctor_1
code: /-- the category of additive functors is denoted `C ⥤+ D` -/
infixr:26 " ⥤+ " => AdditiveFunctor
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.instPreadditiveAdditiveFunctor
code: instance : Preadditive (C ⥤+ D) 
goal: CategoryTheory.Preadditive (C ⥤+ D)

full_name: CategoryTheory.AdditiveFunctor.forget
code: /-- An additive functor is in particular a functor. -/
def AdditiveFunctor.forget : (C ⥤+ D) ⥤ C ⥤ D 
goal: CategoryTheory.Functor (C ⥤+ D) (CategoryTheory.Functor C D)

full_name: CategoryTheory.instFullAdditiveFunctorFunctorForget
code: instance : (AdditiveFunctor.forget C D).Full 
goal: (CategoryTheory.AdditiveFunctor.forget C D).Full

full_name: CategoryTheory.AdditiveFunctor.of
code: /-- Turn an additive functor into an object of the category `AdditiveFunctor C D`. -/
def AdditiveFunctor.of (F : C ⥤ D) [F.Additive] : C ⥤+ D 
goal: C ⥤+ D

full_name: CategoryTheory.AdditiveFunctor.of_fst
code: @[simp]
theorem AdditiveFunctor.of_fst (F : C ⥤ D) [F.Additive] : (AdditiveFunctor.of F).1 = F 
goal: (CategoryTheory.AdditiveFunctor.of F).obj = F

full_name: CategoryTheory.AdditiveFunctor.forget_obj
code: @[simp]
theorem AdditiveFunctor.forget_obj (F : C ⥤+ D) : (AdditiveFunctor.forget C D).obj F = F.1 
goal: (CategoryTheory.AdditiveFunctor.forget C D).obj F = F.obj

full_name: CategoryTheory.AdditiveFunctor.forget_obj_of
code: theorem AdditiveFunctor.forget_obj_of (F : C ⥤ D) [F.Additive] :
    (AdditiveFunctor.forget C D).obj (AdditiveFunctor.of F) = F 
goal: (CategoryTheory.AdditiveFunctor.forget C D).obj (CategoryTheory.AdditiveFunctor.of F) = F

full_name: CategoryTheory.AdditiveFunctor.forget_map
code: @[simp]
theorem AdditiveFunctor.forget_map (F G : C ⥤+ D) (α : F ⟶ G) :
    (AdditiveFunctor.forget C D).map α = α 
goal: (CategoryTheory.AdditiveFunctor.forget C D).map α = α

full_name: CategoryTheory.instAdditiveAdditiveFunctorFunctorForget
code: instance : Functor.Additive (AdditiveFunctor.forget C D) 
goal: (CategoryTheory.AdditiveFunctor.forget C D).Additive

full_name: CategoryTheory.instAdditiveObjFunctor
code: instance (F : C ⥤+ D) : Functor.Additive F.1 
goal: F.obj.Additive

full_name: CategoryTheory.AdditiveFunctor.ofLeftExact
code: /-- Turn a left exact functor into an additive functor. -/
def AdditiveFunctor.ofLeftExact : (C ⥤ₗ D) ⥤ C ⥤+ D 
goal: CategoryTheory.Functor (C ⥤ₗ D) (C ⥤+ D)

full_name: CategoryTheory.instFullLeftExactFunctorAdditiveFunctorOfLeftExact
code: instance : (AdditiveFunctor.ofLeftExact C D).Full 
goal: (CategoryTheory.AdditiveFunctor.ofLeftExact C D).Full

full_name: CategoryTheory.instFaithfulLeftExactFunctorAdditiveFunctorOfLeftExact
code: instance : (AdditiveFunctor.ofLeftExact C D).Faithful 
goal: (CategoryTheory.AdditiveFunctor.ofLeftExact C D).Faithful

full_name: CategoryTheory.AdditiveFunctor.ofRightExact
code: /-- Turn a right exact functor into an additive functor. -/
def AdditiveFunctor.ofRightExact : (C ⥤ᵣ D) ⥤ C ⥤+ D 
goal: CategoryTheory.Functor (C ⥤ᵣ D) (C ⥤+ D)

full_name: CategoryTheory.instFullRightExactFunctorAdditiveFunctorOfRightExact
code: instance : (AdditiveFunctor.ofRightExact C D).Full 
goal: (CategoryTheory.AdditiveFunctor.ofRightExact C D).Full

full_name: CategoryTheory.instFaithfulRightExactFunctorAdditiveFunctorOfRightExact
code: instance : (AdditiveFunctor.ofRightExact C D).Faithful 
goal: (CategoryTheory.AdditiveFunctor.ofRightExact C D).Faithful

full_name: CategoryTheory.AdditiveFunctor.ofExact
code: /-- Turn an exact functor into an additive functor. -/
def AdditiveFunctor.ofExact : (C ⥤ₑ D) ⥤ C ⥤+ D 
goal: CategoryTheory.Functor (C ⥤ₑ D) (C ⥤+ D)

full_name: CategoryTheory.instFullExactFunctorAdditiveFunctorOfExact
code: instance : (AdditiveFunctor.ofExact C D).Full 
goal: (CategoryTheory.AdditiveFunctor.ofExact C D).Full

full_name: CategoryTheory.instFaithfulExactFunctorAdditiveFunctorOfExact
code: instance : (AdditiveFunctor.ofExact C D).Faithful 
goal: (CategoryTheory.AdditiveFunctor.ofExact C D).Faithful

full_name: CategoryTheory.AdditiveFunctor.ofLeftExact_obj_fst
code: @[simp]
theorem AdditiveFunctor.ofLeftExact_obj_fst (F : C ⥤ₗ D) :
    ((AdditiveFunctor.ofLeftExact C D).obj F).obj = F.obj 
goal: ((CategoryTheory.AdditiveFunctor.ofLeftExact C D).obj F).obj = F.obj

full_name: CategoryTheory.AdditiveFunctor.ofRightExact_obj_fst
code: @[simp]
theorem AdditiveFunctor.ofRightExact_obj_fst (F : C ⥤ᵣ D) :
    ((AdditiveFunctor.ofRightExact C D).obj F).obj = F.obj 
goal: ((CategoryTheory.AdditiveFunctor.ofRightExact C D).obj F).obj = F.obj

full_name: CategoryTheory.AdditiveFunctor.ofExact_obj_fst
code: @[simp]
theorem AdditiveFunctor.ofExact_obj_fst (F : C ⥤ₑ D) :
    ((AdditiveFunctor.ofExact C D).obj F).obj = F.obj 
goal: ((CategoryTheory.AdditiveFunctor.ofExact C D).obj F).obj = F.obj

full_name: CategoryTheory.AdditiveFunctor.ofLeftExact_map
code: @[simp]
theorem AdditiveFunctor.ofLeftExact_map {F G : C ⥤ₗ D} (α : F ⟶ G) :
    (AdditiveFunctor.ofLeftExact C D).map α = α 
goal: (CategoryTheory.AdditiveFunctor.ofLeftExact C D).map α = α

full_name: CategoryTheory.AdditiveFunctor.ofRightExact_map
code: @[simp]
theorem AdditiveFunctor.ofRightExact_map {F G : C ⥤ᵣ D} (α : F ⟶ G) :
    (AdditiveFunctor.ofRightExact C D).map α = α 
goal: (CategoryTheory.AdditiveFunctor.ofRightExact C D).map α = α

full_name: CategoryTheory.AdditiveFunctor.ofExact_map
code: @[simp]
theorem AdditiveFunctor.ofExact_map {F G : C ⥤ₑ D} (α : F ⟶ G) :
    (AdditiveFunctor.ofExact C D).map α = α 
goal: (CategoryTheory.AdditiveFunctor.ofExact C D).map α = α