File: Mathlib/CategoryTheory/Category/Cat.lean

full_name: CategoryTheory.Cat
code: /-- Category of categories. -/
@[nolint checkUnivs]
def Cat 
goal: Type (max (u + 1) u (v + 1))

full_name: CategoryTheory.Cat.instInhabited
code: instance : Inhabited Cat 
goal: Inhabited CategoryTheory.Cat

full_name: CategoryTheory.Cat.instCoeSortType
code: instance : CoeSort Cat (Type u) 
goal: CoeSort CategoryTheory.Cat (Type u)

full_name: CategoryTheory.Cat.str
code: instance str (C : Cat.{v, u}) : Category.{v, u} C 
goal: CategoryTheory.Category.{v, u} ↑C

full_name: CategoryTheory.Cat.of
code: /-- Construct a bundled `Cat` from the underlying type and the typeclass. -/
def of (C : Type u) [Category.{v} C] : Cat.{v, u} 
goal: CategoryTheory.Cat

full_name: CategoryTheory.Cat.bicategory
code: /-- Bicategory structure on `Cat` -/
instance bicategory : Bicategory.{max v u, max v u} Cat.{v, u} 
goal: CategoryTheory.Bicategory CategoryTheory.Cat

full_name: CategoryTheory.Cat.bicategory.strict
code: /-- `Cat` is a strict bicategory. -/
instance bicategory.strict : Bicategory.Strict Cat.{v, u} 
goal: CategoryTheory.Bicategory.Strict CategoryTheory.Cat

full_name: CategoryTheory.Cat.category
code: /-- Category structure on `Cat` -/
instance category : LargeCategory.{max v u} Cat.{v, u} 
goal: CategoryTheory.LargeCategory CategoryTheory.Cat

full_name: CategoryTheory.Cat.id_map
code: @[simp]
theorem id_map {C : Cat} {X Y : C} (f : X ⟶ Y) : (𝟙 C : C ⥤ C).map f = f 
goal: (CategoryTheory.CategoryStruct.id C).map f = f

full_name: CategoryTheory.Cat.comp_obj
code: @[simp]
theorem comp_obj {C D E : Cat} (F : C ⟶ D) (G : D ⟶ E) (X : C) : (F ≫ G).obj X = G.obj (F.obj X) 
goal: (CategoryTheory.CategoryStruct.comp F G).obj X = G.obj (F.obj X)

full_name: CategoryTheory.Cat.comp_map
code: @[simp]
theorem comp_map {C D E : Cat} (F : C ⟶ D) (G : D ⟶ E) {X Y : C} (f : X ⟶ Y) :
    (F ≫ G).map f = G.map (F.map f) 
goal: (CategoryTheory.CategoryStruct.comp F G).map f = G.map (F.map f)

full_name: CategoryTheory.Cat.whiskerLeft_app
code: @[simp]
lemma whiskerLeft_app {C D E : Cat} (F : C ⟶ D) {G H : D ⟶ E} (η : G ⟶ H) (X : C) :
    (F ◁ η).app X = η.app (F.obj X) 
goal: (CategoryTheory.Bicategory.whiskerLeft F η).app X = η.app (F.obj X)

full_name: CategoryTheory.Cat.whiskerRight_app
code: @[simp]
lemma whiskerRight_app {C D E : Cat} {F G : C ⟶ D} (H : D ⟶ E) (η : F ⟶ G) (X : C) :
    (η ▷ H).app X = H.map (η.app X) 
goal: (CategoryTheory.Bicategory.whiskerRight η H).app X = H.map (η.app X)

full_name: CategoryTheory.Cat.leftUnitor_hom_app
code: lemma leftUnitor_hom_app {B C : Cat} (F : B ⟶ C) (X : B) : (λ_ F).hom.app X = eqToHom (by simp) 
goal: (CategoryTheory.Bicategory.leftUnitor F).hom.app X = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Cat.leftUnitor_inv_app
code: lemma leftUnitor_inv_app {B C : Cat} (F : B ⟶ C) (X : B) : (λ_ F).inv.app X = eqToHom (by simp) 
goal: (CategoryTheory.Bicategory.leftUnitor F).inv.app X = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Cat.rightUnitor_hom_app
code: lemma rightUnitor_hom_app {B C : Cat} (F : B ⟶ C) (X : B) : (ρ_ F).hom.app X = eqToHom (by simp) 
goal: (CategoryTheory.Bicategory.rightUnitor F).hom.app X = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Cat.rightUnitor_inv_app
code: lemma rightUnitor_inv_app {B C : Cat} (F : B ⟶ C) (X : B) : (ρ_ F).inv.app X = eqToHom (by simp) 
goal: (CategoryTheory.Bicategory.rightUnitor F).inv.app X = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Cat.associator_hom_app
code: lemma associator_hom_app {B C D E : Cat} (F : B ⟶ C) (G : C ⟶ D) (H : D ⟶ E) (X : B) :
    (α_ F G H).hom.app X = eqToHom (by simp) 
goal: (CategoryTheory.Bicategory.associator F G H).hom.app X = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Cat.associator_inv_app
code: lemma associator_inv_app {B C D E : Cat} (F : B ⟶ C) (G : C ⟶ D) (H : D ⟶ E) (X : B) :
    (α_ F G H).inv.app X = eqToHom (by simp) 
goal: (CategoryTheory.Bicategory.associator F G H).inv.app X = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Cat.objects
code: /-- Functor that gets the set of objects of a category. It is not
called `forget`, because it is not a faithful functor. -/
def objects : Cat.{v, u} ⥤ Type u 
goal: CategoryTheory.Functor CategoryTheory.Cat (Type u)

full_name: CategoryTheory.Cat.instCategoryObjObjects
code: instance (X : Cat.{v, u}) : Category (objects.obj X) 
goal: CategoryTheory.Category.{v, u} (CategoryTheory.Cat.objects.obj X)

full_name: CategoryTheory.Cat.equivOfIso
code: /-- Any isomorphism in `Cat` induces an equivalence of the underlying categories. -/
def equivOfIso {C D : Cat} (γ : C ≅ D) : C ≌ D 
goal: ↑C ≌ ↑D

full_name: CategoryTheory.typeToCat
code: /-- Embedding `Type` into `Cat` as discrete categories.

This ought to be modelled as a 2-functor!
-/
@[simps]
def typeToCat : Type u ⥤ Cat 
goal: CategoryTheory.Functor (Type u) CategoryTheory.Cat

full_name: CategoryTheory.typeToCat_obj
code: /-- Embedding `Type` into `Cat` as discrete categories.

This ought to be modelled as a 2-functor!
-/
@[simps]
def typeToCat : Type u ⥤ Cat 
goal: CategoryTheory.typeToCat.obj X = CategoryTheory.Cat.of (CategoryTheory.Discrete X)

full_name: CategoryTheory.typeToCat_map
code: /-- Embedding `Type` into `Cat` as discrete categories.

This ought to be modelled as a 2-functor!
-/
@[simps]
def typeToCat : Type u ⥤ Cat 
goal: CategoryTheory.typeToCat.map f = id (CategoryTheory.Discrete.functor (CategoryTheory.Discrete.mk ∘ f))

full_name: CategoryTheory.instFaithfulCatTypeToCat
code: instance : Functor.Faithful typeToCat.{u} 
goal: CategoryTheory.typeToCat.Faithful

full_name: CategoryTheory.instFullCatTypeToCat
code: instance : Functor.Full typeToCat.{u} 
goal: CategoryTheory.typeToCat.Full