/-- The function `(W.FunctorsInverting D) ⥤ (W.Localization ⥤ D)` induced by
`Construction.lift`. -/
@[simps!]
def inverse : W.FunctorsInverting D ⥤ W.Localization ⥤ D
    where
  obj G := lift G.obj G.property
  map τ := natTransExtension (eqToHom (by rw [fac]) ≫ τ ≫ eqToHom (by rw [fac]))
  map_id G :=
    natTrans_hcomp_injective
      (by
        rw [natTransExtension_hcomp]
        ext X
        simp only [NatTrans.comp_app, eqToHom_app, eqToHom_refl, comp_id, id_comp,
          NatTrans.hcomp_id_app, NatTrans.id_app, Functor.map_id]
        rfl)
  map_comp τ₁ τ₂ :=
    natTrans_hcomp_injective
      (by
        ext X
        

Proof state:
case w.h
C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G
X✝ Y✝ Z✝ : MorphismProperty.FunctorsInverting W D
τ₁ : X✝ ⟶ Y✝
τ₂ : Y✝ ⟶ Z✝
X : C
⊢ (𝟙 (MorphismProperty.Q W) ◫
          { obj := fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj),
                map := fun {X Y} τ =>
                  natTransExtension
                    (eqToHom
                        (_ :
                          MorphismProperty.Q W ⋙ (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) X =
                            X.obj) ≫
                      τ ≫
                        eqToHom
                          (_ :
                            Y.obj =
                              MorphismProperty.Q W ⋙
                                (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) Y)) }.map
            (τ₁ ≫ τ₂)).app
      X =
    (𝟙 (MorphismProperty.Q W) ◫
          ({ obj := fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj),
                  map := fun {X Y} τ =>
                    natTransExtension
                      (eqToHom
                          (_ :
                            MorphismProperty.Q W ⋙ (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) X =
                              X.obj) ≫
                        τ ≫
                          eqToHom
                            (_ :
                              Y.obj =
                                MorphismProperty.Q W ⋙
                                  (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) Y)) }.map
              τ₁ ≫
            { obj := fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj),
                  map := fun {X Y} τ =>
                    natTransExtension
                      (eqToHom
                          (_ :
                            MorphismProperty.Q W ⋙ (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) X =
                              X.obj) ≫
                        τ ≫
                          eqToHom
                            (_ :
                              Y.obj =
                                MorphismProperty.Q W ⋙
                                  (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) Y)) }.map
              τ₂)).app
      X

Next tactic:
simp only [natTransExtension_hcomp, NatTrans.comp_app, eqToHom_app, eqToHom_refl,
          id_comp, comp_id, NatTrans.hcomp_app, NatTrans.id_app, Functor.map_id,
          natTransExtension_app, NatTransExtension.app_eq]