/--
The adjunction between forming the free category on a quiver, and forgetting a category to a quiver.
-/
def adj : Cat.free ⊣ Quiv.forget :=
  Adjunction.mkOfHomEquiv
    { homEquiv := fun V C =>
        { toFun := fun F => Paths.of.comp F.toPrefunctor
          invFun := fun F => @lift V _ C _ F
          left_inv := fun F => Paths.ext_functor rfl (by simp)
          right_inv := by
            rintro ⟨obj, map⟩
            dsimp only [Prefunctor.comp]
            congr
            funext X Y f
            exact Category.id_comp _ }
      homEquiv_naturality_left_symm := fun {V _ _} f g => by
        change (show Paths V ⥤ _ from _) = _
        ext; swap
        

Proof state:
case h
V x✝¹ : Quiv
x✝ : Cat
f : V ⟶ x✝¹
g : x✝¹ ⟶ forget.obj x✝
a✝ b✝ : ↑V
e✝ : a✝ ⟶ b✝
⊢ (let_fun this :=
          ((fun V C =>
                  { toFun := fun F => Paths.of ⋙q F.toPrefunctor, invFun := fun F => lift F,
                    left_inv :=
                      (_ : ∀ (F : Cat.free.obj V ⟶ C), (fun F => lift F) ((fun F => Paths.of ⋙q F.toPrefunctor) F) = F),
                    right_inv :=
                      (_ : ∀ (x : V ⟶ forget.obj C), (fun F => Paths.of ⋙q F.toPrefunctor) ((fun F => lift F) x) = x) })
                V x✝).symm
            (f ≫ g);
        this).map
      (Quiver.Hom.toPath e✝) =
    eqToHom
        (_ :
          (let_fun this :=
                  ((fun V C =>
                          { toFun := fun F => Paths.of ⋙q F.toPrefunctor, invFun := fun F => lift F,
                            left_inv :=
                              (_ :
                                ∀ (F : Cat.free.obj V ⟶ C),
                                  (fun F => lift F) ((fun F => Paths.of ⋙q F.toPrefunctor) F) = F),
                            right_inv :=
                              (_ :
                                ∀ (x : V ⟶ forget.obj C),
                                  (fun F => Paths.of ⋙q F.toPrefunctor) ((fun F => lift F) x) = x) })
                        V x✝).symm
                    (f ≫ g);
                this).obj
              a✝ =
            (Cat.free.map f ≫
                  ((fun V C =>
                          { toFun := fun F => Paths.of ⋙q F.toPrefunctor, invFun := fun F => lift F,
                            left_inv :=
                              (_ :
                                ∀ (F : Cat.free.obj V ⟶ C),
                                  (fun F => lift F) ((fun F => Paths.of ⋙q F.toPrefunctor) F) = F),
                            right_inv :=
                              (_ :
                                ∀ (x : V ⟶ forget.obj C),
                                  (fun F => Paths.of ⋙q F.toPrefunctor) ((fun F => lift F) x) = x) })
                        x✝¹ x✝).symm
                    g).obj
              a✝) ≫
      (Cat.free.map f ≫
              ((fun V C =>
                      { toFun := fun F => Paths.of ⋙q F.toPrefunctor, invFun := fun F => lift F,
                        left_inv :=
                          (_ :
                            ∀ (F : Cat.free.obj V ⟶ C),
                              (fun F => lift F) ((fun F => Paths.of ⋙q F.toPrefunctor) F) = F),
                        right_inv :=
                          (_ :
                            ∀ (x : V ⟶ forget.obj C),
                              (fun F => Paths.of ⋙q F.toPrefunctor) ((fun F => lift F) x) = x) })
                    x✝¹ x✝).symm
                g).map
          (Quiver.Hom.toPath e✝) ≫
        eqToHom
          (_ :
            (Cat.free.map f ≫
                    ((fun V C =>
                            { toFun := fun F => Paths.of ⋙q F.toPrefunctor, invFun := fun F => lift F,
                              left_inv :=
                                (_ :
                                  ∀ (F : Cat.free.obj V ⟶ C),
                                    (fun F => lift F) ((fun F => Paths.of ⋙q F.toPrefunctor) F) = F),
                              right_inv :=
                                (_ :
                                  ∀ (x : V ⟶ forget.obj C),
                                    (fun F => Paths.of ⋙q F.toPrefunctor) ((fun F => lift F) x) = x) })
                          x✝¹ x✝).symm
                      g).obj
                b✝ =
              (let_fun this :=
                    ((fun V C =>
                            { toFun := fun F => Paths.of ⋙q F.toPrefunctor, invFun := fun F => lift F,
                              left_inv :=
                                (_ :
                                  ∀ (F : Cat.free.obj V ⟶ C),
                                    (fun F => lift F) ((fun F => Paths.of ⋙q F.toPrefunctor) F) = F),
                              right_inv :=
                                (_ :
                                  ∀ (x : V ⟶ forget.obj C),
                                    (fun F => Paths.of ⋙q F.toPrefunctor) ((fun F => lift F) x) = x) })
                          V x✝).symm
                      (f ≫ g);
                  this).obj
                b✝)
case h_obj.h
V x✝² : Quiv
x✝¹ : Cat
f : V ⟶ x✝²
g : x✝² ⟶ forget.obj x✝¹
x✝ : Paths ↑V
⊢ (let_fun this :=
          ((fun V C =>
                  { toFun := fun F => Paths.of ⋙q F.toPrefunctor, invFun := fun F => lift F,
                    left_inv :=
                      (_ : ∀ (F : Cat.free.obj V ⟶ C), (fun F => lift F) ((fun F => Paths.of ⋙q F.toPrefunctor) F) = F),
                    right_inv :=
                      (_ : ∀ (x : V ⟶ forget.obj C), (fun F => Paths.of ⋙q F.toPrefunctor) ((fun F => lift F) x) = x) })
                V x✝¹).symm
            (f ≫ g);
        this).obj
      x✝ =
    (Cat.free.map f ≫
          ((fun V C =>
                  { toFun := fun F => Paths.of ⋙q F.toPrefunctor, invFun := fun F => lift F,
                    left_inv :=
                      (_ : ∀ (F : Cat.free.obj V ⟶ C), (fun F => lift F) ((fun F => Paths.of ⋙q F.toPrefunctor) F) = F),
                    right_inv :=
                      (_ : ∀ (x : V ⟶ forget.obj C), (fun F => Paths.of ⋙q F.toPrefunctor) ((fun F => lift F) x) = x) })
                x✝² x✝¹).symm
            g).obj
      x✝

Next tactic:
apply eq_conj_eqToHom