File: Mathlib/CategoryTheory/Category/Quiv.lean

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

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

full_name: CategoryTheory.Quiv.str'
code: instance str' (C : Quiv.{v, u}) : Quiver.{v + 1, u} C 
goal: Quiver ↑C

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

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

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

full_name: CategoryTheory.Quiv.forget_map
code: /-- The forgetful functor from categories to quivers. -/
@[simps]
def forget : Cat.{v, u} ⥤ Quiv.{v, u} 
goal: ∀ {X Y : CategoryTheory.Cat} (F : X ⟶ Y), CategoryTheory.Quiv.forget.map F = F.toPrefunctor

full_name: CategoryTheory.Quiv.forget
code: /-- The forgetful functor from categories to quivers. -/
@[simps]
def forget : Cat.{v, u} ⥤ Quiv.{v, u} 
goal: CategoryTheory.Functor CategoryTheory.Cat CategoryTheory.Quiv

full_name: CategoryTheory.Quiv.forget_obj
code: /-- The forgetful functor from categories to quivers. -/
@[simps]
def forget : Cat.{v, u} ⥤ Quiv.{v, u} 
goal: CategoryTheory.Quiv.forget.obj C = CategoryTheory.Quiv.of ↑C

full_name: CategoryTheory.Cat.free_map_map
code: /-- The functor sending each quiver to its path category. -/
@[simps]
def free : Quiv.{v, u} ⥤ Cat.{max u v, u} 
goal: ∀ {X Y : CategoryTheory.Quiv} (F : X ⟶ Y) {X_1 Y_1 : ↑((fun V => CategoryTheory.Cat.of (CategoryTheory.Paths ↑V)) X)}
  (f : X_1 ⟶ Y_1), (CategoryTheory.Cat.free.map F).map f = Prefunctor.mapPath F f

full_name: CategoryTheory.Cat.free
code: /-- The functor sending each quiver to its path category. -/
@[simps]
def free : Quiv.{v, u} ⥤ Cat.{max u v, u} 
goal: CategoryTheory.Functor CategoryTheory.Quiv CategoryTheory.Cat

full_name: CategoryTheory.Cat.free_obj
code: /-- The functor sending each quiver to its path category. -/
@[simps]
def free : Quiv.{v, u} ⥤ Cat.{max u v, u} 
goal: CategoryTheory.Cat.free.obj V = CategoryTheory.Cat.of (CategoryTheory.Paths ↑V)

full_name: CategoryTheory.Cat.free_map_obj
code: /-- The functor sending each quiver to its path category. -/
@[simps]
def free : Quiv.{v, u} ⥤ Cat.{max u v, u} 
goal: ∀ {X Y : CategoryTheory.Quiv} (F : X ⟶ Y) (X_1 : ↑((fun V => CategoryTheory.Cat.of (CategoryTheory.Paths ↑V)) X)),
  (CategoryTheory.Cat.free.map F).obj X_1 = F.obj X_1

full_name: CategoryTheory.Quiv.lift
code: /-- Any prefunctor into a category lifts to a functor from the path category. -/
@[simps]
def lift {V : Type u} [Quiver.{v + 1} V] {C : Type*} [Category C] (F : Prefunctor V C) :
    Paths V ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Paths V) C

full_name: CategoryTheory.Quiv.lift_map
code: /-- Any prefunctor into a category lifts to a functor from the path category. -/
@[simps]
def lift {V : Type u} [Quiver.{v + 1} V] {C : Type*} [Category C] (F : Prefunctor V C) :
    Paths V ⥤ C 
goal: ∀ {X Y : CategoryTheory.Paths V} (f : X ⟶ Y),
  (CategoryTheory.Quiv.lift F).map f = CategoryTheory.composePath (F.mapPath f)

full_name: CategoryTheory.Quiv.lift_obj
code: /-- Any prefunctor into a category lifts to a functor from the path category. -/
@[simps]
def lift {V : Type u} [Quiver.{v + 1} V] {C : Type*} [Category C] (F : Prefunctor V C) :
    Paths V ⥤ C 
goal: (CategoryTheory.Quiv.lift F).obj X = F.obj X

full_name: CategoryTheory.Quiv.adj
code: /--
The adjunction between forming the free category on a quiver, and forgetting a category to a quiver.
-/
def adj : Cat.free ⊣ Quiv.forget 
goal: CategoryTheory.Cat.free ⊣ CategoryTheory.Quiv.forget