File: Mathlib/CategoryTheory/Groupoid/FreeGroupoid.lean

full_name: Quiver.Hom.toPosPath
code: /-- Shorthand for the "forward" arrow corresponding to `f` in `paths <| symmetrify V` -/
abbrev _root_.Quiver.Hom.toPosPath {X Y : V} (f : X ⟶ Y) :
    (CategoryTheory.Paths.categoryPaths <| Quiver.Symmetrify V).Hom X Y 
goal: X ⟶ Y

full_name: Quiver.Hom.toNegPath
code: /-- Shorthand for the "forward" arrow corresponding to `f` in `paths <| symmetrify V` -/
abbrev _root_.Quiver.Hom.toNegPath {X Y : V} (f : X ⟶ Y) :
    (CategoryTheory.Paths.categoryPaths <| Quiver.Symmetrify V).Hom Y X 
goal: Y ⟶ X

full_name: CategoryTheory.Groupoid.Free.redStep
code: /-- The "reduction" relation -/
inductive redStep : HomRel (Paths (Quiver.Symmetrify V))
  | step (X Z : Quiver.Symmetrify V) (f : X ⟶ Z) :
    redStep (𝟙 (Paths.of.obj X)) (f.toPath ≫ (Quiver.reverse f).toPath)
goal: HomRel (CategoryTheory.Paths (Quiver.Symmetrify V))

full_name: CategoryTheory.Groupoid.Free.redStep.step
code: /-- The "reduction" relation -/
inductive redStep : HomRel (Paths (Quiver.Symmetrify V))
  | step (X Z : Quiver.Symmetrify V) (f : X ⟶ Z) :
    redStep (𝟙 (Paths.of.obj X)) (f.toPath ≫ (Quiver.reverse f).toPath)
goal: CategoryTheory.Groupoid.Free.redStep (CategoryTheory.CategoryStruct.id (CategoryTheory.Paths.of.obj X))
  (CategoryTheory.CategoryStruct.comp f.toPath (Quiver.reverse f).toPath)

full_name: CategoryTheory.FreeGroupoid
code: /-- The underlying vertices of the free groupoid -/
def _root_.CategoryTheory.FreeGroupoid (V) [Q : Quiver V] 
goal: Type u_1

full_name: CategoryTheory.Groupoid.Free.instNonemptyFreeGroupoid
code: instance {V} [Quiver V] [Nonempty V] : Nonempty (FreeGroupoid V) 
goal: Nonempty (CategoryTheory.FreeGroupoid V)

full_name: CategoryTheory.Groupoid.Free.congr_reverse
code: theorem congr_reverse {X Y : Paths <| Quiver.Symmetrify V} (p q : X ⟶ Y) :
    Quotient.CompClosure redStep p q → Quotient.CompClosure redStep p.reverse q.reverse 
goal: CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep p q →
  CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep (Quiver.Path.reverse p)
    (Quiver.Path.reverse q)

full_name: CategoryTheory.Groupoid.Free.congr_comp_reverse
code: theorem congr_comp_reverse {X Y : Paths <| Quiver.Symmetrify V} (p : X ⟶ Y) :
    Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (p ≫ p.reverse) =
      Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (𝟙 X) 
goal: Quot.mk (CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep)
    (CategoryTheory.CategoryStruct.comp p (Quiver.Path.reverse p)) =
  Quot.mk (CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep)
    (CategoryTheory.CategoryStruct.id X)

full_name: CategoryTheory.Groupoid.Free.congr_reverse_comp
code: theorem congr_reverse_comp {X Y : Paths <| Quiver.Symmetrify V} (p : X ⟶ Y) :
    Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (p.reverse ≫ p) =
      Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (𝟙 Y) 
goal: Quot.mk (CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep)
    (CategoryTheory.CategoryStruct.comp (Quiver.Path.reverse p) p) =
  Quot.mk (CategoryTheory.Quotient.CompClosure CategoryTheory.Groupoid.Free.redStep)
    (CategoryTheory.CategoryStruct.id Y)

full_name: CategoryTheory.Groupoid.Free.instCategoryFreeGroupoid
code: instance : Category (FreeGroupoid V) 
goal: CategoryTheory.Category.{max u v, u} (CategoryTheory.FreeGroupoid V)

full_name: CategoryTheory.Groupoid.Free.quotInv
code: /-- The inverse of an arrow in the free groupoid -/
def quotInv {X Y : FreeGroupoid V} (f : X ⟶ Y) : Y ⟶ X 
goal: Y ⟶ X

full_name: CategoryTheory.FreeGroupoid.instGroupoid
code: instance _root_.CategoryTheory.FreeGroupoid.instGroupoid : Groupoid (FreeGroupoid V) 
goal: CategoryTheory.Groupoid (CategoryTheory.FreeGroupoid V)

full_name: CategoryTheory.Groupoid.Free.of
code: /-- The inclusion of the quiver on `V` to the underlying quiver on `FreeGroupoid V`-/
def of (V) [Quiver V] : V ⥤q FreeGroupoid V 
goal: V ⥤q CategoryTheory.FreeGroupoid V

full_name: CategoryTheory.Groupoid.Free.of_eq
code: theorem of_eq :
    of V = (Quiver.Symmetrify.of ⋙q Paths.of).comp
      (Quotient.functor <| @redStep V _).toPrefunctor 
goal: CategoryTheory.Groupoid.Free.of V =
  Quiver.Symmetrify.of ⋙q CategoryTheory.Paths.of ⋙q
    (CategoryTheory.Quotient.functor CategoryTheory.Groupoid.Free.redStep).toPrefunctor

full_name: CategoryTheory.Groupoid.Free.lift
code: /-- The lift of a prefunctor to a groupoid, to a functor from `FreeGroupoid V` -/
def lift (φ : V ⥤q V') : FreeGroupoid V ⥤ V' 
goal: CategoryTheory.Functor (CategoryTheory.FreeGroupoid V) V'

full_name: CategoryTheory.Groupoid.Free.lift_spec
code: theorem lift_spec (φ : V ⥤q V') : of V ⋙q (lift φ).toPrefunctor = φ 
goal: CategoryTheory.Groupoid.Free.of V ⋙q (CategoryTheory.Groupoid.Free.lift φ).toPrefunctor = φ

full_name: CategoryTheory.Groupoid.Free.lift_unique
code: theorem lift_unique (φ : V ⥤q V') (Φ : FreeGroupoid V ⥤ V') (hΦ : of V ⋙q Φ.toPrefunctor = φ) :
    Φ = lift φ 
goal: Φ = CategoryTheory.Groupoid.Free.lift φ

full_name: CategoryTheory.freeGroupoidFunctor
code: /-- The functor of free groupoid induced by a prefunctor of quivers -/
def _root_.CategoryTheory.freeGroupoidFunctor (φ : V ⥤q V') : FreeGroupoid V ⥤ FreeGroupoid V' 
goal: CategoryTheory.Functor (CategoryTheory.FreeGroupoid V) (CategoryTheory.FreeGroupoid V')

full_name: CategoryTheory.Groupoid.Free.freeGroupoidFunctor_id
code: theorem freeGroupoidFunctor_id :
    freeGroupoidFunctor (Prefunctor.id V) = Functor.id (FreeGroupoid V) 
goal: CategoryTheory.freeGroupoidFunctor (𝟭q V) = CategoryTheory.Functor.id (CategoryTheory.FreeGroupoid V)

full_name: CategoryTheory.Groupoid.Free.freeGroupoidFunctor_comp
code: theorem freeGroupoidFunctor_comp (φ : V ⥤q V') (φ' : V' ⥤q V'') :
    freeGroupoidFunctor (φ ⋙q φ') = freeGroupoidFunctor φ ⋙ freeGroupoidFunctor φ' 
goal: CategoryTheory.freeGroupoidFunctor (φ ⋙q φ') =
  (CategoryTheory.freeGroupoidFunctor φ).comp (CategoryTheory.freeGroupoidFunctor φ')