The category of refl quivers

The category ReflQuiv of (bundled) reflexive quivers, and the free/forgetful adjunction between Cat and ReflQuiv.

def CategoryTheory.ReflQuiv : Type (max (u + 1) u (v + 1))

Category of refl quivers.

Equations

• CategoryTheory.ReflQuiv = CategoryTheory.Bundled CategoryTheory.ReflQuiver

instance CategoryTheory.ReflQuiv.instCoeSortType : CoeSort ReflQuiv (Type u)

Equations

• CategoryTheory.ReflQuiv.instCoeSortType = { coe := CategoryTheory.Bundled.α }

instance CategoryTheory.ReflQuiv.instReflQuiverα (C : ReflQuiv) : ReflQuiver ↑C

Equations

• C.instReflQuiverα = C.str

def CategoryTheory.ReflQuiv.toQuiv (C : ReflQuiv) : Quiv

The underlying quiver of a reflexive quiver.

Equations

• C.toQuiv = CategoryTheory.Quiv.of ↑C

def CategoryTheory.ReflQuiv.of (C : Type u) [ReflQuiver C] : ReflQuiv

Construct a bundled ReflQuiv from the underlying type and the typeclass.

Equations

• CategoryTheory.ReflQuiv.of C = CategoryTheory.Bundled.of C

instance CategoryTheory.ReflQuiv.instInhabited : Inhabited ReflQuiv

Equations

• CategoryTheory.ReflQuiv.instInhabited = { default := CategoryTheory.ReflQuiv.of (CategoryTheory.Discrete default) }

@[simp]

theorem CategoryTheory.ReflQuiv.of_val (C : Type u) [ReflQuiver C] : ↑(of C) = C

instance CategoryTheory.ReflQuiv.category : LargeCategory ReflQuiv

Category structure on ReflQuiv

Equations

• CategoryTheory.ReflQuiv.category = CategoryTheory.Category.mk @CategoryTheory.ReflQuiv.category.proof_1 @CategoryTheory.ReflQuiv.category.proof_1 @CategoryTheory.ReflQuiv.category.proof_2

theorem CategoryTheory.ReflQuiv.id_eq_id (X : ReflQuiv) : CategoryStruct.id X = 𝟭rq ↑X

theorem CategoryTheory.ReflQuiv.comp_eq_comp {X Y Z : ReflQuiv} (F : X ⟶ Y) (G : Y ⟶ Z) : CategoryStruct.comp F G = F ⋙rq G

def CategoryTheory.ReflQuiv.forget : Functor Cat ReflQuiv

The forgetful functor from categories to quivers.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.ReflQuiv.forget_map {X✝ Y✝ : Cat} (F : X✝ ⟶ Y✝) : forget.map F = Functor.toReflPrefunctor F

@[simp]

theorem CategoryTheory.ReflQuiv.forget_obj (C : Cat) : forget.obj C = of ↑C

theorem CategoryTheory.ReflQuiv.forget_faithful {C D : Cat} (F G : Functor ↑C ↑D) (hyp : forget.map F = forget.map G) : F = G

theorem CategoryTheory.ReflQuiv.forget.Faithful : forget.Faithful

def CategoryTheory.ReflQuiv.forgetToQuiv : Functor ReflQuiv Quiv

The forgetful functor from categories to quivers.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.ReflQuiv.forgetToQuiv_obj (V : ReflQuiv) : forgetToQuiv.obj V = Quiv.of ↑V

@[simp]

theorem CategoryTheory.ReflQuiv.forgetToQuiv_map {X✝ Y✝ : ReflQuiv} (F : X✝ ⟶ Y✝) : forgetToQuiv.map F = F.toPrefunctor

theorem CategoryTheory.ReflQuiv.forgetToQuiv_faithful {V W : ReflQuiv} (F G : ↑V ⥤rq ↑W) (hyp : forgetToQuiv.map F = forgetToQuiv.map G) : F = G

instance CategoryTheory.ReflQuiv.forgetToQuiv.Faithful : forgetToQuiv.Faithful

theorem CategoryTheory.ReflQuiv.forget_forgetToQuiv : forget.comp forgetToQuiv = Quiv.forget

def CategoryTheory.ReflQuiv.isoOfQuivIso {V W : Type u} [ReflQuiver V] [ReflQuiver W] (e : Quiv.of V ≅ Quiv.of W) (h_id : ∀ (X : V), e.hom.map (ReflQuiver.id X) = ReflQuiver.id (e.hom.obj X)) : of V ≅ of W

An isomorphism of quivers lifts to an isomorphism of reflexive quivers given a suitable compatibility with the identities.

Equations

• CategoryTheory.ReflQuiv.isoOfQuivIso e h_id = { hom := { toPrefunctor := e.hom, map_id := h_id }, inv := { toPrefunctor := e.inv, map_id := ⋯ }, hom_inv_id := ⋯, inv_hom_id := ⋯ }

def CategoryTheory.ReflQuiv.isoOfEquiv {V W : Type u} [ReflQuiver V] [ReflQuiver W] (e : V ≃ W) (he : (X Y : V) → (X ⟶ Y) ≃ (e X ⟶ e Y)) (h_id : ∀ (X : V), (he X X) (ReflQuiver.id X) = ReflQuiver.id (e X)) : of V ≅ of W

Compatible equivalences of types and hom-types induce an isomorphism of reflexive quivers.

Equations

• CategoryTheory.ReflQuiv.isoOfEquiv e he h_id = CategoryTheory.ReflQuiv.isoOfQuivIso (CategoryTheory.Quiv.isoOfEquiv e he) h_id

def CategoryTheory.ReflPrefunctor.toFunctor {C D : Cat} (F : ReflQuiv.of ↑C ⟶ ReflQuiv.of ↑D) (hyp : ∀ {X Y Z : ↑C} (f : X ⟶ Y) (g : Y ⟶ Z), F.map (CategoryStruct.comp f g) = CategoryStruct.comp (F.map f) (F.map g)) : Functor ↑C ↑D

A refl prefunctor can be promoted to a functor if it respects composition.

Equations

• CategoryTheory.ReflPrefunctor.toFunctor F hyp = { obj := F.obj, map := fun {X Y : ↑C} => F.map, map_id := ⋯, map_comp := ⋯ }

inductive CategoryTheory.Cat.FreeReflRel {V : Type u_1} [ReflQuiver V] (X Y : Paths V) (f g : X ⟶ Y) : Prop

The hom relation that identifies the specified reflexivity arrows with the nil paths.

• mk {V : Type u_1} [ReflQuiver V] {X : V} : FreeReflRel X X (ReflQuiver.id X).toPath Quiver.Path.nil

def CategoryTheory.Cat.FreeRefl (V : Type u_1) [ReflQuiver V] : Type u_1

A reflexive quiver generates a free category, defined as as quotient of the free category on its underlying quiver (called the "path category") by the hom relation that uses the specified reflexivity arrows as the identity arrows.

Equations

• CategoryTheory.Cat.FreeRefl V = CategoryTheory.Quotient CategoryTheory.Cat.FreeReflRel

instance CategoryTheory.Cat.instCategoryFreeRefl (V : Type u_1) [ReflQuiver V] : Category.{max u_1 u_2, u_1} (FreeRefl V)

Equations

• CategoryTheory.Cat.instCategoryFreeRefl V = inferInstanceAs (CategoryTheory.Category.{max ?u.19 ?u.18, ?u.19} (CategoryTheory.Quotient CategoryTheory.Cat.FreeReflRel))

def CategoryTheory.Cat.FreeRefl.quotientFunctor (V : Type u_1) [ReflQuiver V] : Functor (↑(free.obj (Quiv.of V))) (FreeRefl V)

The quotient functor associated to a quotient category defines a natural map from the free category on the underlying quiver of a refl quiver to the free category on the reflexive quiver.

Equations

• CategoryTheory.Cat.FreeRefl.quotientFunctor V = CategoryTheory.Quotient.functor CategoryTheory.Cat.FreeReflRel

theorem CategoryTheory.Cat.FreeRefl.lift_unique' {V : Type u_1} [ReflQuiver V] {D : Type u_3} [Category.{u_4, u_3} D] (F₁ F₂ : Functor (FreeRefl V) D) (h : (quotientFunctor V).comp F₁ = (quotientFunctor V).comp F₂) : F₁ = F₂

This is a specialization of Quotient.lift_unique' rather than Quotient.lift_unique, hence the prime in the name.

def CategoryTheory.Cat.freeRefl : Functor ReflQuiv Cat

The functor sending a reflexive quiver to the free category it generates, a quotient of its path category.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Cat.freeRefl_map_obj_as {X✝ Y✝ : ReflQuiv} (f : X✝ ⟶ Y✝) (a : Quotient FreeReflRel) : ((freeRefl.map f).obj a).as = f.obj a.as

@[simp]

theorem CategoryTheory.Cat.freeRefl_obj_str_comp (V : ReflQuiv) ⦃a b c : Quotient FreeReflRel⦄ (a✝ : Quotient.Hom FreeReflRel a b) (a✝¹ : Quotient.Hom FreeReflRel b c) : CategoryStruct.comp a✝ a✝¹ = Quotient.comp FreeReflRel a✝ a✝¹

@[simp]

theorem CategoryTheory.Cat.freeRefl_obj_str_id (V : ReflQuiv) (a : Quotient FreeReflRel) : CategoryStruct.id a = Quot.mk (Quotient.CompClosure FreeReflRel) (CategoryStruct.id a.as)

@[simp]

theorem CategoryTheory.Cat.freeRefl_obj_α (V : ReflQuiv) : ↑(freeRefl.obj V) = FreeRefl ↑V

@[simp]

theorem CategoryTheory.Cat.freeRefl_map_map {X✝ Y✝ : ReflQuiv} (f : X✝ ⟶ Y✝) (a b : Quotient FreeReflRel) (hf : a ⟶ b) : (freeRefl.map f).map hf = Quot.liftOn hf (fun (f_1 : a.as ⟶ b.as) => (FreeRefl.quotientFunctor ↑Y✝).map (f.mapPath f_1)) ⋯

theorem CategoryTheory.Cat.freeRefl_naturality {X Y : Type u_1} [ReflQuiver X] [ReflQuiver Y] (f : X ⥤rq Y) : Functor.comp (free.map f.toPrefunctor) (FreeRefl.quotientFunctor Y) = (FreeRefl.quotientFunctor X).comp (freeRefl.map f)

def CategoryTheory.Cat.freeReflNatTrans : ReflQuiv.forgetToQuiv.comp free ⟶ freeRefl

We will make use of the natural quotient map from the free category on the underlying quiver of a refl quiver to the free category on the reflexive quiver.

Equations

• CategoryTheory.Cat.freeReflNatTrans = { app := fun (V : CategoryTheory.ReflQuiv) => CategoryTheory.Cat.FreeRefl.quotientFunctor ↑V, naturality := CategoryTheory.Cat.freeReflNatTrans.proof_1 }

def CategoryTheory.ReflQuiv.adj.unit.app (V : ReflQuiv) : ↑V ⥤rq ↑(forget.obj (Cat.freeRefl.obj V))

The unit components are defined as the composite of the corresponding unit component for the adjunction between categories and quivers with the map underlying the quotient functor.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.ReflQuiv.adj.unit.app_toPrefunctor (V : ReflQuiv) : (app V).toPrefunctor = Quiv.adj.unit.app V.toQuiv ⋙q (Cat.FreeRefl.quotientFunctor ↑V).toPrefunctor

@[simp]

theorem CategoryTheory.ReflQuiv.adj.unit.app_obj (V : ReflQuiv) (X : ↑V) : (app V).obj X = (Cat.FreeRefl.quotientFunctor ↑V).obj ((Quiv.adj.unit.app V.toQuiv).obj X)

@[simp]

theorem CategoryTheory.ReflQuiv.adj.unit.app_map (V : ReflQuiv) {X✝ Y✝ : ↑V} (f : X✝ ⟶ Y✝) : (app V).map f = (Cat.FreeRefl.quotientFunctor ↑V).map ((Quiv.adj.unit.app V.toQuiv).map f)

theorem CategoryTheory.ReflQuiv.adj.unit.component_eq (V : ReflQuiv) : forgetToQuiv.map (app V) = CategoryStruct.comp (Quiv.adj.unit.app V.toQuiv) (Quiv.forget.map (Cat.FreeRefl.quotientFunctor ↑V))

This is used in the proof of both triangle equalities.

def CategoryTheory.ReflQuiv.adj.counit.app (C : Cat) : Functor ↑(Cat.freeRefl.obj (forget.obj C)) ↑C

The counit components are defined using the universal property of the quotient from the corresponding counit component for the adjunction between categories and quivers.

Equations

• CategoryTheory.ReflQuiv.adj.counit.app C = CategoryTheory.Quotient.lift CategoryTheory.Cat.FreeReflRel (CategoryTheory.Quiv.adj.counit.app C) ⋯

@[simp]

theorem CategoryTheory.ReflQuiv.adj.counit.app_map (C : Cat) (a b : Quotient Cat.FreeReflRel) (hf : a ⟶ b) : (app C).map hf = Quot.liftOn hf (fun (f : a.as ⟶ b.as) => (Quiv.adj.counit.app C).map f) ⋯

@[simp]

theorem CategoryTheory.ReflQuiv.adj.counit.app_obj (C : Cat) (a : Quotient Cat.FreeReflRel) : (app C).obj a = (Quiv.adj.counit.app C).obj a.as

@[simp]

theorem CategoryTheory.ReflQuiv.adj.counit.component_eq (C : Cat) : (Cat.FreeRefl.quotientFunctor ↑C).comp (app C) = Quiv.adj.counit.app C

The counit of ReflQuiv.adj is closely related to the counit of Quiv.adj.

@[simp]

theorem CategoryTheory.ReflQuiv.adj.counit.component_eq' (C : Type u_1) [Category.{max u_1 u_2, u_1} C] : (Cat.FreeRefl.quotientFunctor C).comp (app (Cat.of C)) = Quiv.adj.counit.app (Cat.of C)

The counit of ReflQuiv.adj is closely related to the counit of Quiv.adj. For ease of use, we introduce primed version for unbundled categories.

def CategoryTheory.ReflQuiv.adj : Cat.freeRefl ⊣ forget

The adjunction between forming the free category on a reflexive quiver, and forgetting a category to a reflexive quiver.

Equations

• One or more equations did not get rendered due to their size.