File: Mathlib/CategoryTheory/Functor/Category.lean

full_name: CategoryTheory.Functor.category
code: /-- `Functor.category C D` gives the category structure on functors and natural transformations
between categories `C` and `D`.

Notice that if `C` and `D` are both small categories at the same universe level,
this is another small category at that level.
However if `C` and `D` are both large categories at the same universe level,
this is a small category at the next higher level.
-/
instance Functor.category : Category.{max u₁ v₂} (C ⥤ D) 
goal: CategoryTheory.Category.{max u₁ v₂, max (max (max u₂ u₁) v₂) v₁} (CategoryTheory.Functor C D)

full_name: CategoryTheory.NatTrans.ext'
code: @[ext]
theorem ext' {α β : F ⟶ G} (w : α.app = β.app) : α = β 
goal: α = β

full_name: CategoryTheory.NatTrans.vcomp_eq_comp
code: @[simp]
theorem vcomp_eq_comp (α : F ⟶ G) (β : G ⟶ H) : vcomp α β = α ≫ β 
goal: CategoryTheory.NatTrans.vcomp α β = CategoryTheory.CategoryStruct.comp α β

full_name: CategoryTheory.NatTrans.vcomp_app'
code: theorem vcomp_app' (α : F ⟶ G) (β : G ⟶ H) (X : C) : (α ≫ β).app X = α.app X ≫ β.app X 
goal: (CategoryTheory.CategoryStruct.comp α β).app X = CategoryTheory.CategoryStruct.comp (α.app X) (β.app X)

full_name: CategoryTheory.NatTrans.congr_app
code: theorem congr_app {α β : F ⟶ G} (h : α = β) (X : C) : α.app X = β.app X 
goal: α.app X = β.app X

full_name: CategoryTheory.NatTrans.id_app
code: @[simp]
theorem id_app (F : C ⥤ D) (X : C) : (𝟙 F : F ⟶ F).app X = 𝟙 (F.obj X) 
goal: (CategoryTheory.CategoryStruct.id F).app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.NatTrans.comp_app
code: @[simp]
theorem comp_app {F G H : C ⥤ D} (α : F ⟶ G) (β : G ⟶ H) (X : C) :
    (α ≫ β).app X = α.app X ≫ β.app X 
goal: (CategoryTheory.CategoryStruct.comp α β).app X = CategoryTheory.CategoryStruct.comp (α.app X) (β.app X)

full_name: CategoryTheory.NatTrans.app_naturality
code: @[reassoc]
theorem app_naturality {F G : C ⥤ D ⥤ E} (T : F ⟶ G) (X : C) {Y Z : D} (f : Y ⟶ Z) :
    (F.obj X).map f ≫ (T.app X).app Z = (T.app X).app Y ≫ (G.obj X).map f 
goal: CategoryTheory.CategoryStruct.comp ((F.obj X).map f) ((T.app X).app Z) =
  CategoryTheory.CategoryStruct.comp ((T.app X).app Y) ((G.obj X).map f)

full_name: CategoryTheory.NatTrans.naturality_app
code: @[reassoc]
theorem naturality_app {F G : C ⥤ D ⥤ E} (T : F ⟶ G) (Z : D) {X Y : C} (f : X ⟶ Y) :
    (F.map f).app Z ≫ (T.app Y).app Z = (T.app X).app Z ≫ (G.map f).app Z 
goal: CategoryTheory.CategoryStruct.comp ((F.map f).app Z) ((T.app Y).app Z) =
  CategoryTheory.CategoryStruct.comp ((T.app X).app Z) ((G.map f).app Z)

full_name: CategoryTheory.NatTrans.mono_of_mono_app
code: /-- A natural transformation is a monomorphism if each component is. -/
theorem mono_of_mono_app (α : F ⟶ G) [∀ X : C, Mono (α.app X)] : Mono α 
goal: CategoryTheory.Mono α

full_name: CategoryTheory.NatTrans.epi_of_epi_app
code: /-- A natural transformation is an epimorphism if each component is. -/
theorem epi_of_epi_app (α : F ⟶ G) [∀ X : C, Epi (α.app X)] : Epi α 
goal: CategoryTheory.Epi α

full_name: CategoryTheory.NatTrans.id_comm
code: /-- The monoid of natural transformations of the identity is commutative.-/
lemma id_comm (α β : (𝟭 C) ⟶ (𝟭 C)) : α ≫ β = β ≫ α 
goal: CategoryTheory.CategoryStruct.comp α β = CategoryTheory.CategoryStruct.comp β α

full_name: CategoryTheory.NatTrans.hcomp_app
code: /-- `hcomp α β` is the horizontal composition of natural transformations. -/
@[simps]
def hcomp {H I : D ⥤ E} (α : F ⟶ G) (β : H ⟶ I) : F ⋙ H ⟶ G ⋙ I 
goal: (α ◫ β).app X = CategoryTheory.CategoryStruct.comp (β.app (F.obj X)) (I.map (α.app X))

full_name: CategoryTheory.NatTrans.hcomp
code: /-- `hcomp α β` is the horizontal composition of natural transformations. -/
@[simps]
def hcomp {H I : D ⥤ E} (α : F ⟶ G) (β : H ⟶ I) : F ⋙ H ⟶ G ⋙ I 
goal: F.comp H ⟶ G.comp I

full_name: CategoryTheory.NatTrans._aux_Mathlib_CategoryTheory_Functor_Category___unexpand_CategoryTheory_NatTrans_hcomp_1
code: /-- Notation for horizontal composition of natural transformations. -/
infixl:80 " ◫ " => hcomp
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.NatTrans.«_aux_Mathlib_CategoryTheory_Functor_Category___macroRules_CategoryTheory_NatTrans_term_◫__1»
code: /-- Notation for horizontal composition of natural transformations. -/
infixl:80 " ◫ " => hcomp
goal: Lean.Macro

full_name: CategoryTheory.NatTrans.hcomp_id_app
code: theorem hcomp_id_app {H : D ⥤ E} (α : F ⟶ G) (X : C) : (α ◫ 𝟙 H).app X = H.map (α.app X) 
goal: (α ◫ CategoryTheory.CategoryStruct.id H).app X = H.map (α.app X)

full_name: CategoryTheory.NatTrans.id_hcomp_app
code: theorem id_hcomp_app {H : E ⥤ C} (α : F ⟶ G) (X : E) : (𝟙 H ◫ α).app X = α.app _ 
goal: (CategoryTheory.CategoryStruct.id H ◫ α).app X = α.app (H.obj X)

full_name: CategoryTheory.NatTrans.exchange
code: theorem exchange {I J K : D ⥤ E} (α : F ⟶ G) (β : G ⟶ H) (γ : I ⟶ J) (δ : J ⟶ K) :
    (α ≫ β) ◫ (γ ≫ δ) = (α ◫ γ) ≫ β ◫ δ 
goal: CategoryTheory.CategoryStruct.comp α β ◫ CategoryTheory.CategoryStruct.comp γ δ =
  CategoryTheory.CategoryStruct.comp (α ◫ γ) (β ◫ δ)

full_name: CategoryTheory.Functor.flip_obj_obj
code: /-- Flip the arguments of a bifunctor. See also `Currying.lean`. -/
@[simps]
protected def flip (F : C ⥤ D ⥤ E) : D ⥤ C ⥤ E 
goal: (F.flip.obj k).obj j = (F.obj j).obj k

full_name: CategoryTheory.Functor.flip
code: /-- Flip the arguments of a bifunctor. See also `Currying.lean`. -/
@[simps]
protected def flip (F : C ⥤ D ⥤ E) : D ⥤ C ⥤ E 
goal: CategoryTheory.Functor D (CategoryTheory.Functor C E)

full_name: CategoryTheory.Functor.flip_map_app
code: /-- Flip the arguments of a bifunctor. See also `Currying.lean`. -/
@[simps]
protected def flip (F : C ⥤ D ⥤ E) : D ⥤ C ⥤ E 
goal: ∀ {X Y : D} (f : X ⟶ Y) (j : C), (F.flip.map f).app j = (F.obj j).map f

full_name: CategoryTheory.Functor.flip_obj_map
code: /-- Flip the arguments of a bifunctor. See also `Currying.lean`. -/
@[simps]
protected def flip (F : C ⥤ D ⥤ E) : D ⥤ C ⥤ E 
goal: ∀ {X Y : C} (f : X ⟶ Y), (F.flip.obj k).map f = (F.map f).app k

full_name: CategoryTheory.Iso.map_hom_inv_id_app
code: @[reassoc (attr := simp)]
theorem map_hom_inv_id_app {X Y : C} (e : X ≅ Y) (F : C ⥤ D ⥤ E) (Z : D) :
    (F.map e.hom).app Z ≫ (F.map e.inv).app Z = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((F.map e.hom).app Z) ((F.map e.inv).app Z) =
  CategoryTheory.CategoryStruct.id ((F.obj X).obj Z)

full_name: CategoryTheory.Iso.map_inv_hom_id_app
code: @[reassoc (attr := simp)]
theorem map_inv_hom_id_app {X Y : C} (e : X ≅ Y) (F : C ⥤ D ⥤ E) (Z : D) :
    (F.map e.inv).app Z ≫ (F.map e.hom).app Z = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((F.map e.inv).app Z) ((F.map e.hom).app Z) =
  CategoryTheory.CategoryStruct.id ((F.obj Y).obj Z)