File: Mathlib/CategoryTheory/Limits/ExactFunctor.lean

full_name: CategoryTheory.LeftExactFunctor
code: /-- Bundled left-exact functors. -/
def LeftExactFunctor 
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.instCategoryLeftExactFunctor
code: instance : Category (LeftExactFunctor C D) 
goal: CategoryTheory.Category.{max u₁ v₂, max (max (max u₂ u₁) v₂) v₁} (C ⥤ₗ D)

full_name: CategoryTheory.«_aux_Mathlib_CategoryTheory_Limits_ExactFunctor___macroRules_CategoryTheory_term_⥤ₗ__1»
code: /-- `C ⥤ₗ D` denotes left exact functors `C ⥤ D` -/
infixr:26 " ⥤ₗ " => LeftExactFunctor
goal: Lean.Macro

full_name: CategoryTheory._aux_Mathlib_CategoryTheory_Limits_ExactFunctor___unexpand_CategoryTheory_LeftExactFunctor_1
code: /-- `C ⥤ₗ D` denotes left exact functors `C ⥤ D` -/
infixr:26 " ⥤ₗ " => LeftExactFunctor
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.LeftExactFunctor.forget
code: /-- A left exact functor is in particular a functor. -/
def LeftExactFunctor.forget : (C ⥤ₗ D) ⥤ C ⥤ D 
goal: CategoryTheory.Functor (C ⥤ₗ D) (CategoryTheory.Functor C D)

full_name: CategoryTheory.instFullLeftExactFunctorFunctorForget
code: instance : (LeftExactFunctor.forget C D).Full 
goal: (CategoryTheory.LeftExactFunctor.forget C D).Full

full_name: CategoryTheory.instFaithfulLeftExactFunctorFunctorForget
code: instance : (LeftExactFunctor.forget C D).Faithful 
goal: (CategoryTheory.LeftExactFunctor.forget C D).Faithful

full_name: CategoryTheory.RightExactFunctor
code: /-- Bundled right-exact functors. -/
def RightExactFunctor 
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.instCategoryRightExactFunctor
code: instance : Category (RightExactFunctor C D) 
goal: CategoryTheory.Category.{max u₁ v₂, max (max (max u₂ u₁) v₂) v₁} (C ⥤ᵣ D)

full_name: CategoryTheory._aux_Mathlib_CategoryTheory_Limits_ExactFunctor___unexpand_CategoryTheory_RightExactFunctor_1
code: /-- `C ⥤ᵣ D` denotes right exact functors `C ⥤ D` -/
infixr:26 " ⥤ᵣ " => RightExactFunctor
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.«_aux_Mathlib_CategoryTheory_Limits_ExactFunctor___macroRules_CategoryTheory_term_⥤ᵣ__1»
code: /-- `C ⥤ᵣ D` denotes right exact functors `C ⥤ D` -/
infixr:26 " ⥤ᵣ " => RightExactFunctor
goal: Lean.Macro

full_name: CategoryTheory.RightExactFunctor.forget
code: /-- A right exact functor is in particular a functor. -/
def RightExactFunctor.forget : (C ⥤ᵣ D) ⥤ C ⥤ D 
goal: CategoryTheory.Functor (C ⥤ᵣ D) (CategoryTheory.Functor C D)

full_name: CategoryTheory.instFullRightExactFunctorFunctorForget
code: instance : (RightExactFunctor.forget C D).Full 
goal: (CategoryTheory.RightExactFunctor.forget C D).Full

full_name: CategoryTheory.instFaithfulRightExactFunctorFunctorForget
code: instance : (RightExactFunctor.forget C D).Faithful 
goal: (CategoryTheory.RightExactFunctor.forget C D).Faithful

full_name: CategoryTheory.ExactFunctor
code: /-- Bundled exact functors. -/
def ExactFunctor 
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.instCategoryExactFunctor
code: instance : Category (ExactFunctor C D) 
goal: CategoryTheory.Category.{max u₁ v₂, max (max (max u₂ u₁) v₂) v₁} (C ⥤ₑ D)

full_name: CategoryTheory.«_aux_Mathlib_CategoryTheory_Limits_ExactFunctor___macroRules_CategoryTheory_term_⥤ₑ__1»
code: /-- `C ⥤ₑ D` denotes exact functors `C ⥤ D` -/
infixr:26 " ⥤ₑ " => ExactFunctor
goal: Lean.Macro

full_name: CategoryTheory._aux_Mathlib_CategoryTheory_Limits_ExactFunctor___unexpand_CategoryTheory_ExactFunctor_1
code: /-- `C ⥤ₑ D` denotes exact functors `C ⥤ D` -/
infixr:26 " ⥤ₑ " => ExactFunctor
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.ExactFunctor.forget
code: /-- An exact functor is in particular a functor. -/
def ExactFunctor.forget : (C ⥤ₑ D) ⥤ C ⥤ D 
goal: CategoryTheory.Functor (C ⥤ₑ D) (CategoryTheory.Functor C D)

full_name: CategoryTheory.instFullExactFunctorFunctorForget
code: instance : (ExactFunctor.forget C D).Full 
goal: (CategoryTheory.ExactFunctor.forget C D).Full

full_name: CategoryTheory.instFaithfulExactFunctorFunctorForget
code: instance : (ExactFunctor.forget C D).Faithful 
goal: (CategoryTheory.ExactFunctor.forget C D).Faithful

full_name: CategoryTheory.LeftExactFunctor.ofExact
code: /-- Turn an exact functor into a left exact functor. -/
def LeftExactFunctor.ofExact : (C ⥤ₑ D) ⥤ C ⥤ₗ D 
goal: CategoryTheory.Functor (C ⥤ₑ D) (C ⥤ₗ D)

full_name: CategoryTheory.instFullExactFunctorLeftExactFunctorOfExact
code: instance : (LeftExactFunctor.ofExact C D).Full 
goal: (CategoryTheory.LeftExactFunctor.ofExact C D).Full

full_name: CategoryTheory.instFaithfulExactFunctorLeftExactFunctorOfExact
code: instance : (LeftExactFunctor.ofExact C D).Faithful 
goal: (CategoryTheory.LeftExactFunctor.ofExact C D).Faithful

full_name: CategoryTheory.RightExactFunctor.ofExact
code: /-- Turn an exact functor into a left exact functor. -/
def RightExactFunctor.ofExact : (C ⥤ₑ D) ⥤ C ⥤ᵣ D 
goal: CategoryTheory.Functor (C ⥤ₑ D) (C ⥤ᵣ D)

full_name: CategoryTheory.instFullExactFunctorRightExactFunctorOfExact
code: instance : (RightExactFunctor.ofExact C D).Full 
goal: (CategoryTheory.RightExactFunctor.ofExact C D).Full

full_name: CategoryTheory.instFaithfulExactFunctorRightExactFunctorOfExact
code: instance : (RightExactFunctor.ofExact C D).Faithful 
goal: (CategoryTheory.RightExactFunctor.ofExact C D).Faithful

full_name: CategoryTheory.LeftExactFunctor.ofExact_obj
code: @[simp]
theorem LeftExactFunctor.ofExact_obj (F : C ⥤ₑ D) :
    (LeftExactFunctor.ofExact C D).obj F = ⟨F.1, F.2.1⟩ 
goal: (CategoryTheory.LeftExactFunctor.ofExact C D).obj F = { obj := F.obj, property := ⋯ }

full_name: CategoryTheory.RightExactFunctor.ofExact_obj
code: @[simp]
theorem RightExactFunctor.ofExact_obj (F : C ⥤ₑ D) :
    (RightExactFunctor.ofExact C D).obj F = ⟨F.1, F.2.2⟩ 
goal: (CategoryTheory.RightExactFunctor.ofExact C D).obj F = { obj := F.obj, property := ⋯ }

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

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

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

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

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

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

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

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

full_name: CategoryTheory.LeftExactFunctor.of
code: /-- Turn a left exact functor into an object of the category `LeftExactFunctor C D`. -/
def LeftExactFunctor.of (F : C ⥤ D) [PreservesFiniteLimits F] : C ⥤ₗ D 
goal: C ⥤ₗ D

full_name: CategoryTheory.RightExactFunctor.of
code: /-- Turn a right exact functor into an object of the category `RightExactFunctor C D`. -/
def RightExactFunctor.of (F : C ⥤ D) [PreservesFiniteColimits F] : C ⥤ᵣ D 
goal: C ⥤ᵣ D

full_name: CategoryTheory.ExactFunctor.of
code: /-- Turn an exact functor into an object of the category `ExactFunctor C D`. -/
def ExactFunctor.of (F : C ⥤ D) [PreservesFiniteLimits F] [PreservesFiniteColimits F] : C ⥤ₑ D 
goal: C ⥤ₑ D

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

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

full_name: CategoryTheory.ExactFunctor.of_fst
code: @[simp]
theorem ExactFunctor.of_fst (F : C ⥤ D) [PreservesFiniteLimits F] [PreservesFiniteColimits F] :
    (ExactFunctor.of F).obj = F 
goal: (CategoryTheory.ExactFunctor.of F).obj = F

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

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

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

full_name: CategoryTheory.instPreservesFiniteLimitsObjFunctorNonempty
code: noncomputable instance (F : C ⥤ₗ D) : PreservesFiniteLimits F.obj 
goal: CategoryTheory.Limits.PreservesFiniteLimits F.obj

full_name: CategoryTheory.instPreservesFiniteColimitsObjFunctorNonempty
code: noncomputable instance (F : C ⥤ᵣ D) : PreservesFiniteColimits F.obj 
goal: CategoryTheory.Limits.PreservesFiniteColimits F.obj

full_name: CategoryTheory.instPreservesFiniteLimitsObjFunctorAndNonemptyPreservesFiniteColimits
code: noncomputable instance (F : C ⥤ₑ D) : PreservesFiniteLimits F.obj 
goal: CategoryTheory.Limits.PreservesFiniteLimits F.obj

full_name: CategoryTheory.instPreservesFiniteColimitsObjFunctorAndNonemptyPreservesFiniteLimits
code: noncomputable instance (F : C ⥤ₑ D) : PreservesFiniteColimits F.obj 
goal: CategoryTheory.Limits.PreservesFiniteColimits F.obj