/-- The functor sending each quiver to its path category. -/
@[simps]
def free : Quiv.{v, u} ⥤ Cat.{max u v, u}
    where
  obj V := Cat.of (Paths V)
  map F :=
    { obj := fun X => F.obj X
      map := fun f => F.mapPath f
      map_comp := fun f g => F.mapPath_comp f g }
  map_id V := by
    change (show Paths V ⥤ _ from _) = _
    ext; swap
    apply eq_conj_eqToHom
    rfl
  map_comp {U _ _} F G := by
    change (show Paths U ⥤ _ from _) = _
    ext; 

Proof state:
case h_obj.h
U x✝² x✝¹ : Quiv
F : U ⟶ x✝²
G : x✝² ⟶ x✝¹
x✝ : Paths ↑U
⊢ (let_fun this :=
          { obj := fun V => of (Paths ↑V),
                map := fun {X Y} F =>
                  Functor.mk { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
            (F ≫ G);
        this).obj
      x✝ =
    ({ obj := fun V => of (Paths ↑V),
                map := fun {X Y} F =>
                  Functor.mk { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
            F ≫
          { obj := fun V => of (Paths ↑V),
                map := fun {X Y} F =>
                  Functor.mk { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
            G).obj
      x✝
case h
U x✝¹ x✝ : Quiv
F : U ⟶ x✝¹
G : x✝¹ ⟶ x✝
a✝ b✝ : ↑U
e✝ : a✝ ⟶ b✝
⊢ (let_fun this :=
          { obj := fun V => of (Paths ↑V),
                map := fun {X Y} F =>
                  Functor.mk { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
            (F ≫ G);
        this).map
      (Quiver.Hom.toPath e✝) =
    eqToHom
        (_ :
          (let_fun this :=
                  { obj := fun V => of (Paths ↑V),
                        map := fun {X Y} F =>
                          Functor.mk
                            { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
                    (F ≫ G);
                this).obj
              a✝ =
            ({ obj := fun V => of (Paths ↑V),
                        map := fun {X Y} F =>
                          Functor.mk
                            { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
                    F ≫
                  { obj := fun V => of (Paths ↑V),
                        map := fun {X Y} F =>
                          Functor.mk
                            { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
                    G).obj
              a✝) ≫
      ({ obj := fun V => of (Paths ↑V),
                    map := fun {X Y} F =>
                      Functor.mk { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
                F ≫
              { obj := fun V => of (Paths ↑V),
                    map := fun {X Y} F =>
                      Functor.mk { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
                G).map
          (Quiver.Hom.toPath e✝) ≫
        eqToHom
          (_ :
            ({ obj := fun V => of (Paths ↑V),
                          map := fun {X Y} F =>
                            Functor.mk
                              { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
                      F ≫
                    { obj := fun V => of (Paths ↑V),
                          map := fun {X Y} F =>
                            Functor.mk
                              { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
                      G).obj
                b✝ =
              (let_fun this :=
                    { obj := fun V => of (Paths ↑V),
                          map := fun {X Y} F =>
                            Functor.mk
                              { obj := fun X_1 => F.obj X_1, map := fun {X_1 Y_1} f => Prefunctor.mapPath F f } }.map
                      (F ≫ G);
                  this).obj
                b✝)

Next tactic:
swap