Natural transformations

Defines natural transformations between functors.

A natural transformation α : NatTrans F G consists of morphisms α.app X : F.obj X ⟶ G.obj X, and the naturality squares α.naturality f : F.map f ≫ α.app Y = α.app X ≫ G.map f, where f : X ⟶ Y.

Note that we make NatTrans.naturality a simp lemma, with the preferred simp normal form pushing components of natural transformations to the left.

See also CategoryTheory.FunctorCat, where we provide the category structure on functors and natural transformations.

Introduces notations

• τ.app X for the components of natural transformations,
• F ⟶ G for the type of natural transformations between functors F and G (this and the next require CategoryTheory.FunctorCat),
• σ ≫ τ for vertical compositions, and
• σ ◫ τ for horizontal compositions.

structure CategoryTheory.NatTrans {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F G : Functor C D) : Type (max u₁ v₂)

NatTrans F G represents a natural transformation between functors F and G.

The field app provides the components of the natural transformation.

Naturality is expressed by α.naturality.

• app (X : C) : F.obj X ⟶ G.obj X

  The component of a natural transformation.

• naturality ⦃X Y : C⦄ (f : X ⟶ Y) : CategoryStruct.comp (F.map f) (self.app Y) = CategoryStruct.comp (self.app X) (G.map f)

  The naturality square for a given morphism.

theorem CategoryTheory.NatTrans.ext {C : Type u₁} {inst✝ : Category.{v₁, u₁} C} {D : Type u₂} {inst✝¹ : Category.{v₂, u₂} D} {F G : Functor C D} {x y : NatTrans F G} (app : x.app = y.app) : x = y

theorem CategoryTheory.NatTrans.ext_iff {C : Type u₁} {inst✝ : Category.{v₁, u₁} C} {D : Type u₂} {inst✝¹ : Category.{v₂, u₂} D} {F G : Functor C D} {x y : NatTrans F G} : x = y ↔ x.app = y.app

@[simp]

theorem CategoryTheory.NatTrans.naturality_assoc {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G : Functor C D} (self : NatTrans F G) ⦃X Y : C⦄ (f : X ⟶ Y) {Z : D} (h : G.obj Y ⟶ Z) : CategoryStruct.comp (F.map f) (CategoryStruct.comp (self.app Y) h) = CategoryStruct.comp (self.app X) (CategoryStruct.comp (G.map f) h)

theorem CategoryTheory.congr_app {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G : Functor C D} {α β : NatTrans F G} (h : α = β) (X : C) : α.app X = β.app X

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

NatTrans.id F is the identity natural transformation on a functor F.

Equations

• CategoryTheory.NatTrans.id F = { app := fun (X : C) => CategoryTheory.CategoryStruct.id (F.obj X), naturality := ⋯ }

@[simp]

theorem CategoryTheory.NatTrans.id_app' {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) (X : C) : (NatTrans.id F).app X = CategoryStruct.id (F.obj X)

instance CategoryTheory.NatTrans.instInhabited {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] (F : Functor C D) : Inhabited (NatTrans F F)

Equations

• CategoryTheory.NatTrans.instInhabited F = { default := CategoryTheory.NatTrans.id F }

def CategoryTheory.NatTrans.vcomp {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G H : Functor C D} (α : NatTrans F G) (β : NatTrans G H) : NatTrans F H

vcomp α β is the vertical compositions of natural transformations.

Equations

• α.vcomp β = { app := fun (X : C) => CategoryTheory.CategoryStruct.comp (α.app X) (β.app X), naturality := ⋯ }

theorem CategoryTheory.NatTrans.vcomp_app {C : Type u₁} [Category.{v₁, u₁} C] {D : Type u₂} [Category.{v₂, u₂} D] {F G H : Functor C D} (α : NatTrans F G) (β : NatTrans G H) (X : C) : (α.vcomp β).app X = CategoryStruct.comp (α.app X) (β.app X)