Bundled exact functors

We say that a functor F is left exact if it preserves finite limits, it is right exact if it preserves finite colimits, and it is exact if it is both left exact and right exact.

In this file, we define the categories of bundled left exact, right exact and exact functors.

def CategoryTheory.leftExactFunctor (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : ObjectProperty (Functor C D)

Left-exactness, as a property of objects in C ⥤ D.

@[simp]

theorem CategoryTheory.leftExactFunctor_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) : leftExactFunctor C D F ↔ Limits.PreservesFiniteLimits F

@[reducible, inline]

abbrev CategoryTheory.LeftExactFunctor (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : Type (max (max (max u₁ u₂) v₁) v₂)

Bundled left-exact functors.

def CategoryTheory.«term_⥤ₗ_» : Lean.TrailingParserDescr

C ⥤ₗ D denotes left exact functors C ⥤ D

@[reducible, inline]

abbrev CategoryTheory.LeftExactFunctor.forget (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : Functor (C ⥤ₗ D) (Functor C D)

A left exact functor is in particular a functor.

@[reducible, inline]

abbrev CategoryTheory.LeftExactFunctor.fullyFaithful (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : (forget C D).FullyFaithful

The inclusion of left exact functors into functors is fully faithful.

def CategoryTheory.rightExactFunctor (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : ObjectProperty (Functor C D)

Right-exactness, as a property of objects in C ⥤ D.

@[simp]

theorem CategoryTheory.rightExactFunctor_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) : rightExactFunctor C D F ↔ Limits.PreservesFiniteColimits F

@[reducible, inline]

abbrev CategoryTheory.RightExactFunctor (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : Type (max (max (max u₁ u₂) v₁) v₂)

Bundled right-exact functors.

def CategoryTheory.«term_⥤ᵣ_» : Lean.TrailingParserDescr

C ⥤ᵣ D denotes right exact functors C ⥤ D

@[reducible, inline]

abbrev CategoryTheory.RightExactFunctor.forget (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : Functor (C ⥤ᵣ D) (Functor C D)

A right exact functor is in particular a functor.

@[reducible, inline]

abbrev CategoryTheory.RightExactFunctor.fullyFaithful (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : (forget C D).FullyFaithful

The inclusion of right exact functors into functors is fully faithful.

def CategoryTheory.exactFunctor (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : ObjectProperty (Functor C D)

Exactness, as a property of objects in C ⥤ D.

@[simp]

theorem CategoryTheory.exactFunctor_iff {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) : exactFunctor C D F ↔ Limits.PreservesFiniteLimits F ∧ Limits.PreservesFiniteColimits F

@[reducible, inline]

abbrev CategoryTheory.ExactFunctor (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : Type (max (max (max u₁ u₂) v₁) v₂)

Bundled exact functors.

def CategoryTheory.«term_⥤ₑ_» : Lean.TrailingParserDescr

C ⥤ₑ D denotes exact functors C ⥤ D

@[reducible, inline]

abbrev CategoryTheory.ExactFunctor.forget (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : Functor (C ⥤ₑ D) (Functor C D)

An exact functor is in particular a functor.

theorem CategoryTheory.exactFunctor_le_leftExactFunctor (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : exactFunctor C D ≤ leftExactFunctor C D

theorem CategoryTheory.exactFunctor_le_rightExactFunctor (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : exactFunctor C D ≤ rightExactFunctor C D

@[reducible, inline]

abbrev CategoryTheory.LeftExactFunctor.ofExact (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : Functor (C ⥤ₑ D) (C ⥤ₗ D)

Turn an exact functor into a left exact functor.

@[reducible, inline]

abbrev CategoryTheory.RightExactFunctor.ofExact (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] : Functor (C ⥤ₑ D) (C ⥤ᵣ D)

Turn an exact functor into a left exact functor.

@[simp]

theorem CategoryTheory.LeftExactFunctor.ofExact_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : C ⥤ₑ D) : (ofExact C D).obj F = { obj := F.obj, property := ⋯ }

@[simp]

theorem CategoryTheory.RightExactFunctor.ofExact_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : C ⥤ₑ D) : (ofExact C D).obj F = { obj := F.obj, property := ⋯ }

@[simp]

theorem CategoryTheory.LeftExactFunctor.ofExact_map_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G : C ⥤ₑ D} (α : F ⟶ G) : ((ofExact C D).map α).hom = α.hom

@[simp]

theorem CategoryTheory.RightExactFunctor.ofExact_map_hom {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G : C ⥤ₑ D} (α : F ⟶ G) : ((ofExact C D).map α).hom = α.hom

@[simp]

theorem CategoryTheory.LeftExactFunctor.forget_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : C ⥤ₗ D) : (forget C D).obj F = F.obj

@[simp]

theorem CategoryTheory.RightExactFunctor.forget_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : C ⥤ᵣ D) : (forget C D).obj F = F.obj

@[simp]

theorem CategoryTheory.ExactFunctor.forget_obj {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : C ⥤ₑ D) : (forget C D).obj F = F.obj

@[simp]

theorem CategoryTheory.LeftExactFunctor.forget_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G : C ⥤ₗ D} (α : F ⟶ G) : (forget C D).map α = α.hom

@[simp]

theorem CategoryTheory.RightExactFunctor.forget_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G : C ⥤ᵣ D} (α : F ⟶ G) : (forget C D).map α = α.hom

@[simp]

theorem CategoryTheory.ExactFunctor.forget_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G : C ⥤ₑ D} (α : F ⟶ G) : (forget C D).map α = α.hom

def CategoryTheory.LeftExactFunctor.of {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) [Limits.PreservesFiniteLimits F] : C ⥤ₗ D

Turn a left exact functor into an object of the category LeftExactFunctor C D.

def CategoryTheory.RightExactFunctor.of {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) [Limits.PreservesFiniteColimits F] : C ⥤ᵣ D

Turn a right exact functor into an object of the category RightExactFunctor C D.

def CategoryTheory.ExactFunctor.of {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) [Limits.PreservesFiniteLimits F] [Limits.PreservesFiniteColimits F] : C ⥤ₑ D

Turn an exact functor into an object of the category ExactFunctor C D.

@[simp]

theorem CategoryTheory.LeftExactFunctor.of_fst {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) [Limits.PreservesFiniteLimits F] : (of F).obj = F

@[simp]

theorem CategoryTheory.RightExactFunctor.of_fst {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) [Limits.PreservesFiniteColimits F] : (of F).obj = F

@[simp]

theorem CategoryTheory.ExactFunctor.of_fst {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) [Limits.PreservesFiniteLimits F] [Limits.PreservesFiniteColimits F] : (of F).obj = F

theorem CategoryTheory.LeftExactFunctor.forget_obj_of {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) [Limits.PreservesFiniteLimits F] : (forget C D).obj (of F) = F

theorem CategoryTheory.RightExactFunctor.forget_obj_of {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) [Limits.PreservesFiniteColimits F] : (forget C D).obj (of F) = F

theorem CategoryTheory.ExactFunctor.forget_obj_of {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) [Limits.PreservesFiniteLimits F] [Limits.PreservesFiniteColimits F] : (forget C D).obj (of F) = F

instance CategoryTheory.instPreservesFiniteLimitsObjFunctorLeftExactFunctor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : C ⥤ₗ D) : Limits.PreservesFiniteLimits F.obj

instance CategoryTheory.instPreservesFiniteColimitsObjFunctorRightExactFunctor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : C ⥤ᵣ D) : Limits.PreservesFiniteColimits F.obj

instance CategoryTheory.instPreservesFiniteLimitsObjFunctorExactFunctor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : C ⥤ₑ D) : Limits.PreservesFiniteLimits F.obj

instance CategoryTheory.instPreservesFiniteColimitsObjFunctorExactFunctor {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : C ⥤ₑ D) : Limits.PreservesFiniteColimits F.obj

def CategoryTheory.LeftExactFunctor.whiskeringLeft (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] : Functor (C ⥤ₗ D) (Functor (D ⥤ₗ E) (C ⥤ₗ E))

Whiskering a left exact functor by a left exact functor yields a left exact functor.

@[simp]

theorem CategoryTheory.LeftExactFunctor.whiskeringLeft_obj_obj_obj (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : C ⥤ₗ D) (X : D ⥤ₗ E) : (((whiskeringLeft C D E).obj F).obj X).obj = F.obj.comp X.obj

@[simp]

theorem CategoryTheory.LeftExactFunctor.whiskeringLeft_map_app (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] {F G : C ⥤ₗ D} (η : F ⟶ G) (H : D ⥤ₗ E) : ((whiskeringLeft C D E).map η).app H = ObjectProperty.homMk (((Functor.whiskeringLeft C D E).map η.hom).app H.obj)

@[simp]

theorem CategoryTheory.LeftExactFunctor.whiskeringLeft_obj_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : C ⥤ₗ D) {X✝ Y✝ : D ⥤ₗ E} (f : X✝ ⟶ Y✝) : ((whiskeringLeft C D E).obj F).map f = ObjectProperty.homMk (F.obj.whiskerLeft f.hom)

def CategoryTheory.LeftExactFunctor.whiskeringRight (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] : Functor (D ⥤ₗ E) (Functor (C ⥤ₗ D) (C ⥤ₗ E))

Whiskering a left exact functor by a left exact functor yields a left exact functor.

@[simp]

theorem CategoryTheory.LeftExactFunctor.whiskeringRight_obj_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : D ⥤ₗ E) {X✝ Y✝ : C ⥤ₗ D} (f : X✝ ⟶ Y✝) : ((whiskeringRight C D E).obj F).map f = ObjectProperty.homMk (Functor.whiskerRight f.hom F.obj)

@[simp]

theorem CategoryTheory.LeftExactFunctor.whiskeringRight_map_app (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] {F G : D ⥤ₗ E} (η : F ⟶ G) (H : C ⥤ₗ D) : ((whiskeringRight C D E).map η).app H = ObjectProperty.homMk (((Functor.whiskeringRight C D E).map η.hom).app H.obj)

@[simp]

theorem CategoryTheory.LeftExactFunctor.whiskeringRight_obj_obj_obj (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : D ⥤ₗ E) (X : C ⥤ₗ D) : (((whiskeringRight C D E).obj F).obj X).obj = X.obj.comp F.obj

def CategoryTheory.RightExactFunctor.whiskeringLeft (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] : Functor (C ⥤ᵣ D) (Functor (D ⥤ᵣ E) (C ⥤ᵣ E))

Whiskering a right exact functor by a right exact functor yields a right exact functor.

@[simp]

theorem CategoryTheory.RightExactFunctor.whiskeringLeft_map_app (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] {F G : C ⥤ᵣ D} (η : F ⟶ G) (H : D ⥤ᵣ E) : ((whiskeringLeft C D E).map η).app H = ObjectProperty.homMk (((Functor.whiskeringLeft C D E).map η.hom).app H.obj)

@[simp]

theorem CategoryTheory.RightExactFunctor.whiskeringLeft_obj_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : C ⥤ᵣ D) {X✝ Y✝ : D ⥤ᵣ E} (f : X✝ ⟶ Y✝) : ((whiskeringLeft C D E).obj F).map f = ObjectProperty.homMk (F.obj.whiskerLeft f.hom)

@[simp]

theorem CategoryTheory.RightExactFunctor.whiskeringLeft_obj_obj_obj (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : C ⥤ᵣ D) (X : D ⥤ᵣ E) : (((whiskeringLeft C D E).obj F).obj X).obj = F.obj.comp X.obj

def CategoryTheory.RightExactFunctor.whiskeringRight (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] : Functor (D ⥤ᵣ E) (Functor (C ⥤ᵣ D) (C ⥤ᵣ E))

Whiskering a right exact functor by a right exact functor yields a right exact functor.

@[simp]

theorem CategoryTheory.RightExactFunctor.whiskeringRight_map_app (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] {F G : D ⥤ᵣ E} (η : F ⟶ G) (H : C ⥤ᵣ D) : ((whiskeringRight C D E).map η).app H = ObjectProperty.homMk (((Functor.whiskeringRight C D E).map η.hom).app H.obj)

@[simp]

theorem CategoryTheory.RightExactFunctor.whiskeringRight_obj_obj_obj (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : D ⥤ᵣ E) (X : C ⥤ᵣ D) : (((whiskeringRight C D E).obj F).obj X).obj = X.obj.comp F.obj

@[simp]

theorem CategoryTheory.RightExactFunctor.whiskeringRight_obj_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : D ⥤ᵣ E) {X✝ Y✝ : C ⥤ᵣ D} (f : X✝ ⟶ Y✝) : ((whiskeringRight C D E).obj F).map f = ObjectProperty.homMk (Functor.whiskerRight f.hom F.obj)

def CategoryTheory.ExactFunctor.whiskeringLeft (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] : Functor (C ⥤ₑ D) (Functor (D ⥤ₑ E) (C ⥤ₑ E))

Whiskering an exact functor by an exact functor yields an exact functor.

@[simp]

theorem CategoryTheory.ExactFunctor.whiskeringLeft_map_app (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] {F G : C ⥤ₑ D} (η : F ⟶ G) (H : D ⥤ₑ E) : ((whiskeringLeft C D E).map η).app H = ObjectProperty.homMk (((Functor.whiskeringLeft C D E).map η.hom).app H.obj)

@[simp]

theorem CategoryTheory.ExactFunctor.whiskeringLeft_obj_obj_obj (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : C ⥤ₑ D) (X : D ⥤ₑ E) : (((whiskeringLeft C D E).obj F).obj X).obj = F.obj.comp X.obj

@[simp]

theorem CategoryTheory.ExactFunctor.whiskeringLeft_obj_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : C ⥤ₑ D) {X✝ Y✝ : D ⥤ₑ E} (f : X✝ ⟶ Y✝) : ((whiskeringLeft C D E).obj F).map f = ObjectProperty.homMk (F.obj.whiskerLeft f.hom)

def CategoryTheory.ExactFunctor.whiskeringRight (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] : Functor (D ⥤ₑ E) (Functor (C ⥤ₑ D) (C ⥤ₑ E))

Whiskering an exact functor by an exact functor yields an exact functor.

@[simp]

theorem CategoryTheory.ExactFunctor.whiskeringRight_map_app (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] {F G : D ⥤ₑ E} (η : F ⟶ G) (H : C ⥤ₑ D) : ((whiskeringRight C D E).map η).app H = ObjectProperty.homMk (((Functor.whiskeringRight C D E).map η.hom).app H.obj)

@[simp]

theorem CategoryTheory.ExactFunctor.whiskeringRight_obj_obj_obj (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : D ⥤ₑ E) (X : C ⥤ₑ D) : (((whiskeringRight C D E).obj F).obj X).obj = X.obj.comp F.obj

@[simp]

theorem CategoryTheory.ExactFunctor.whiskeringRight_obj_map (C : Type u₁) [Category.{v₁, u₁} C] (D : Type u₂) [Category.{v₂, u₂} D] (E : Type u₃) [Category.{v₃, u₃} E] (F : D ⥤ₑ E) {X✝ Y✝ : C ⥤ₑ D} (f : X✝ ⟶ Y✝) : ((whiskeringRight C D E).obj F).map f = ObjectProperty.homMk (Functor.whiskerRight f.hom F.obj)

@[deprecated CategoryTheory.LeftExactFunctor.ofExact_map_hom (since := "2025-12-18")]

theorem CategoryTheory.LeftExactFunctor.ofExact_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G : C ⥤ₑ D} (α : F ⟶ G) : ((ofExact C D).map α).hom = α.hom

Alias of CategoryTheory.LeftExactFunctor.ofExact_map_hom.

@[deprecated CategoryTheory.RightExactFunctor.ofExact_map_hom (since := "2025-12-18")]

theorem CategoryTheory.RightExactFunctor.ofExact_map {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G : C ⥤ₑ D} (α : F ⟶ G) : ((ofExact C D).map α).hom = α.hom

Alias of CategoryTheory.RightExactFunctor.ofExact_map_hom.