File: Mathlib/CategoryTheory/PathCategory.lean

full_name: CategoryTheory.Paths
code: /-- A type synonym for the category of paths in a quiver.
-/
def Paths (V : Type u₁) : Type u₁ 
goal: Type u₁

full_name: CategoryTheory.instInhabitedPaths
code: instance (V : Type u₁) [Inhabited V] : Inhabited (Paths V) 
goal: Inhabited (CategoryTheory.Paths V)

full_name: CategoryTheory.Paths.categoryPaths
code: instance categoryPaths : Category.{max u₁ v₁} (Paths V) 
goal: CategoryTheory.Category.{max u₁ v₁, u₁} (CategoryTheory.Paths V)

full_name: CategoryTheory.Paths.of_map
code: /-- The inclusion of a quiver `V` into its path category, as a prefunctor.
-/
@[simps]
def of : V ⥤q Paths V 
goal: ∀ {X Y : V} (f : X ⟶ Y), CategoryTheory.Paths.of.map f = f.toPath

full_name: CategoryTheory.Paths.of
code: /-- The inclusion of a quiver `V` into its path category, as a prefunctor.
-/
@[simps]
def of : V ⥤q Paths V 
goal: V ⥤q CategoryTheory.Paths V

full_name: CategoryTheory.Paths.of_obj
code: /-- The inclusion of a quiver `V` into its path category, as a prefunctor.
-/
@[simps]
def of : V ⥤q Paths V 
goal: CategoryTheory.Paths.of.obj X = X

full_name: CategoryTheory.Paths.lift
code: /-- Any prefunctor from `V` lifts to a functor from `paths V` -/
def lift {C} [Category C] (φ : V ⥤q C) : Paths V ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Paths V) C

full_name: CategoryTheory.Paths.lift_nil
code: @[simp]
theorem lift_nil {C} [Category C] (φ : V ⥤q C) (X : V) :
    (lift φ).map Quiver.Path.nil = 𝟙 (φ.obj X) 
goal: (CategoryTheory.Paths.lift φ).map Quiver.Path.nil = CategoryTheory.CategoryStruct.id (φ.obj X)

full_name: CategoryTheory.Paths.lift_cons
code: @[simp]
theorem lift_cons {C} [Category C] (φ : V ⥤q C) {X Y Z : V} (p : Quiver.Path X Y) (f : Y ⟶ Z) :
    (lift φ).map (p.cons f) = (lift φ).map p ≫ φ.map f 
goal: (CategoryTheory.Paths.lift φ).map (p.cons f) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.lift φ).map p) (φ.map f)

full_name: CategoryTheory.Paths.lift_toPath
code: @[simp]
theorem lift_toPath {C} [Category C] (φ : V ⥤q C) {X Y : V} (f : X ⟶ Y) :
    (lift φ).map f.toPath = φ.map f 
goal: (CategoryTheory.Paths.lift φ).map f.toPath = φ.map f

full_name: CategoryTheory.Paths.lift_spec
code: theorem lift_spec {C} [Category C] (φ : V ⥤q C) : of ⋙q (lift φ).toPrefunctor = φ 
goal: CategoryTheory.Paths.of ⋙q (CategoryTheory.Paths.lift φ).toPrefunctor = φ

full_name: CategoryTheory.Paths.lift_unique
code: theorem lift_unique {C} [Category C] (φ : V ⥤q C) (Φ : Paths V ⥤ C)
    (hΦ : of ⋙q Φ.toPrefunctor = φ) : Φ = lift φ 
goal: Φ = CategoryTheory.Paths.lift φ

full_name: CategoryTheory.Paths.ext_functor
code: /-- Two functors out of a path category are equal when they agree on singleton paths. -/
@[ext]
theorem ext_functor {C} [Category C] {F G : Paths V ⥤ C} (h_obj : F.obj = G.obj)
    (h : ∀ (a b : V) (e : a ⟶ b), F.map e.toPath =
        eqToHom (congr_fun h_obj a) ≫ G.map e.toPath ≫ eqToHom (congr_fun h_obj.symm b)) :
    F = G 
goal: F = G

full_name: CategoryTheory.Prefunctor.mapPath_comp'
code: @[simp]
theorem Prefunctor.mapPath_comp' (F : V ⥤q W) {X Y Z : Paths V} (f : X ⟶ Y) (g : Y ⟶ Z) :
    F.mapPath (f ≫ g) = (F.mapPath f).comp (F.mapPath g) 
goal: F.mapPath (CategoryTheory.CategoryStruct.comp f g) = (F.mapPath f).comp (F.mapPath g)

full_name: CategoryTheory.composePath
code: /-- A path in a category can be composed to a single morphism. -/
def composePath {X : C} : ∀ {Y : C} (_ : Path X Y), X ⟶ Y
  
goal: Quiver.Path X Y → (X ⟶ Y)

full_name: CategoryTheory.composePath_nil
code: @[simp] lemma composePath_nil {X : C} : composePath (Path.nil : Path X X) = 𝟙 X 
goal: CategoryTheory.composePath Quiver.Path.nil = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.composePath_cons
code: @[simp] lemma composePath_cons {X Y Z : C} (p : Path X Y) (e : Y ⟶ Z) :
  composePath (p.cons e) = composePath p ≫ e 
goal: CategoryTheory.composePath (p.cons e) = CategoryTheory.CategoryStruct.comp (CategoryTheory.composePath p) e

full_name: CategoryTheory.composePath_toPath
code: @[simp]
theorem composePath_toPath {X Y : C} (f : X ⟶ Y) : composePath f.toPath = f 
goal: CategoryTheory.composePath f.toPath = f

full_name: CategoryTheory.composePath_comp
code: @[simp]
theorem composePath_comp {X Y Z : C} (f : Path X Y) (g : Path Y Z) :
    composePath (f.comp g) = composePath f ≫ composePath g 
goal: CategoryTheory.composePath (f.comp g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.composePath f) (CategoryTheory.composePath g)

full_name: CategoryTheory.composePath_id
code: @[simp]
-- Porting note (#11215): TODO get rid of `(id X : C)` somehow?
theorem composePath_id {X : Paths C} : composePath (𝟙 X) = 𝟙 (id X : C) 
goal: CategoryTheory.composePath (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (id X)

full_name: CategoryTheory.composePath_comp'
code: @[simp]
theorem composePath_comp' {X Y Z : Paths C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    composePath (f ≫ g) = composePath f ≫ composePath g 
goal: CategoryTheory.composePath (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.composePath f) (CategoryTheory.composePath g)

full_name: CategoryTheory.pathComposition_map
code: /-- Composition of paths as functor from the path category of a category to the category. -/
@[simps]
def pathComposition : Paths C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Paths C} (f : X ⟶ Y), (CategoryTheory.pathComposition C).map f = CategoryTheory.composePath f

full_name: CategoryTheory.pathComposition_obj
code: /-- Composition of paths as functor from the path category of a category to the category. -/
@[simps]
def pathComposition : Paths C ⥤ C 
goal: (CategoryTheory.pathComposition C).obj X = X

full_name: CategoryTheory.pathComposition
code: /-- Composition of paths as functor from the path category of a category to the category. -/
@[simps]
def pathComposition : Paths C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Paths C) C

full_name: CategoryTheory.pathsHomRel
code: /-- The canonical relation on the path category of a category:
two paths are related if they compose to the same morphism. -/
@[simp]
def pathsHomRel : HomRel (Paths C) 
goal: HomRel (CategoryTheory.Paths C)

full_name: CategoryTheory.toQuotientPaths_obj_as
code: /-- The functor from a category to the canonical quotient of its path category. -/
@[simps]
def toQuotientPaths : C ⥤ Quotient (pathsHomRel C) 
goal: ((CategoryTheory.toQuotientPaths C).obj X).as = X

full_name: CategoryTheory.toQuotientPaths
code: /-- The functor from a category to the canonical quotient of its path category. -/
@[simps]
def toQuotientPaths : C ⥤ Quotient (pathsHomRel C) 
goal: CategoryTheory.Functor C (CategoryTheory.Quotient (CategoryTheory.pathsHomRel C))

full_name: CategoryTheory.toQuotientPaths_map
code: /-- The functor from a category to the canonical quotient of its path category. -/
@[simps]
def toQuotientPaths : C ⥤ Quotient (pathsHomRel C) 
goal: ∀ {X Y : C} (f : X ⟶ Y),
  (CategoryTheory.toQuotientPaths C).map f =
    Quot.mk (CategoryTheory.Quotient.CompClosure (CategoryTheory.pathsHomRel C)) f.toPath

full_name: CategoryTheory.quotientPathsTo
code: /-- The functor from the canonical quotient of a path category of a category
to the original category. -/
@[simps!]
def quotientPathsTo : Quotient (pathsHomRel C) ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Quotient (CategoryTheory.pathsHomRel C)) C

full_name: CategoryTheory.quotientPathsTo_map
code: /-- The functor from the canonical quotient of a path category of a category
to the original category. -/
@[simps!]
def quotientPathsTo : Quotient (pathsHomRel C) ⥤ C 
goal: (CategoryTheory.quotientPathsTo C).map hf = Quot.liftOn hf (fun f => CategoryTheory.composePath f) ⋯

full_name: CategoryTheory.quotientPathsTo_obj
code: /-- The functor from the canonical quotient of a path category of a category
to the original category. -/
@[simps!]
def quotientPathsTo : Quotient (pathsHomRel C) ⥤ C 
goal: (CategoryTheory.quotientPathsTo C).obj a = a.as

full_name: CategoryTheory.quotientPathsEquiv
code: /-- The canonical quotient of the path category of a category
is equivalent to the original category. -/
def quotientPathsEquiv : Quotient (pathsHomRel C) ≌ C 
goal: CategoryTheory.Quotient (CategoryTheory.pathsHomRel C) ≌ C