l3lab/ntp-mathlib huggingface dataset:
/-- If `F₁` and `F₂` are functors `W.Localization ⥤ D`, a natural transformation `F₁ ⟶ F₂`
can be obtained from a natural transformation `W.Q ⋙ F₁ ⟶ W.Q ⋙ F₂`. -/
@[simps]
def natTransExtension {F₁ F₂ : W.Localization ⥤ D} (τ : W.Q ⋙ F₁ ⟶ W.Q ⋙ F₂) : F₁ ⟶ F₂
    where
  app := NatTransExtension.app τ
  naturality := by
    suffices MorphismProperty.naturalityProperty (NatTransExtension.app τ) = ⊤ by
      intro X Y f
      simpa only [← this] using MorphismProperty.top_apply f
    refine' morphismProperty_is_top'
      (MorphismProperty.naturalityProperty (NatTransExtension.app τ))
      _ (MorphismProperty.naturalityProperty.stableUnderInverse _)
      (MorphismProperty.naturalityProperty.stableUnderComposition _)
    intros X Y f
    dsimp
    

Proof state:
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
F₁ F₂ : MorphismProperty.Localization W ⥤ D
τ : MorphismProperty.Q W ⋙ F₁ ⟶ MorphismProperty.Q W ⋙ F₂
X Y : C
f : X ⟶ Y
⊢ F₁.map ((MorphismProperty.Q W).map f) ≫ NatTransExtension.app τ ((MorphismProperty.Q W).obj Y) =
    NatTransExtension.app τ ((MorphismProperty.Q W).obj X) ≫ F₂.map ((MorphismProperty.Q W).map f)

Next tactic:
simpa only [NatTransExtension.app_eq] using τ.naturality f
@[simp]
theorem natTransExtension_hcomp {F G : W.Localization ⥤ D} (τ : W.Q ⋙ F ⟶ W.Q ⋙ G) :
    𝟙 W.Q ◫ natTransExtension τ = τ := by 

Proof state:
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✝
F G : MorphismProperty.Localization W ⥤ D
τ : MorphismProperty.Q W ⋙ F ⟶ MorphismProperty.Q W ⋙ G
⊢ 𝟙 (MorphismProperty.Q W) ◫ natTransExtension τ = τ

Next tactic:
aesop_cat
theorem natTrans_hcomp_injective {F G : W.Localization ⥤ D} {τ₁ τ₂ : F ⟶ G}
    (h : 𝟙 W.Q ◫ τ₁ = 𝟙 W.Q ◫ τ₂) : τ₁ = τ₂ := by
  

Proof state:
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✝
F G : MorphismProperty.Localization W ⥤ D
τ₁ τ₂ : F ⟶ G
h : 𝟙 (MorphismProperty.Q W) ◫ τ₁ = 𝟙 (MorphismProperty.Q W) ◫ τ₂
⊢ τ₁ = τ₂

Next tactic:
ext X
theorem natTrans_hcomp_injective {F G : W.Localization ⥤ D} {τ₁ τ₂ : F ⟶ G}
    (h : 𝟙 W.Q ◫ τ₁ = 𝟙 W.Q ◫ τ₂) : τ₁ = τ₂ := 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✝
F G : MorphismProperty.Localization W ⥤ D
τ₁ τ₂ : F ⟶ G
h : 𝟙 (MorphismProperty.Q W) ◫ τ₁ = 𝟙 (MorphismProperty.Q W) ◫ τ₂
X : MorphismProperty.Localization W
⊢ τ₁.app X = τ₂.app X

Next tactic:
have eq := (objEquiv W).right_inv X
theorem natTrans_hcomp_injective {F G : W.Localization ⥤ D} {τ₁ τ₂ : F ⟶ G}
    (h : 𝟙 W.Q ◫ τ₁ = 𝟙 W.Q ◫ τ₂) : τ₁ = τ₂ := by
  ext X
  have eq := (objEquiv W).right_inv 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✝
F G : MorphismProperty.Localization W ⥤ D
τ₁ τ₂ : F ⟶ G
h : 𝟙 (MorphismProperty.Q W) ◫ τ₁ = 𝟙 (MorphismProperty.Q W) ◫ τ₂
X : MorphismProperty.Localization W
eq : Equiv.toFun (objEquiv W) (Equiv.invFun (objEquiv W) X) = X
⊢ τ₁.app X = τ₂.app X

Next tactic:
simp only [objEquiv] at eq
theorem natTrans_hcomp_injective {F G : W.Localization ⥤ D} {τ₁ τ₂ : F ⟶ G}
    (h : 𝟙 W.Q ◫ τ₁ = 𝟙 W.Q ◫ τ₂) : τ₁ = τ₂ := by
  ext X
  have eq := (objEquiv W).right_inv X
  simp only [objEquiv] at eq
  

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✝
F G : MorphismProperty.Localization W ⥤ D
τ₁ τ₂ : F ⟶ G
h : 𝟙 (MorphismProperty.Q W) ◫ τ₁ = 𝟙 (MorphismProperty.Q W) ◫ τ₂
X : MorphismProperty.Localization W
eq : (MorphismProperty.Q W).obj X.as.obj = X
⊢ τ₁.app X = τ₂.app X

Next tactic:
rw [← eq, ← NatTrans.id_hcomp_app, ← NatTrans.id_hcomp_app, h]
/-- 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 

Proof state:
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✝ : MorphismProperty.FunctorsInverting W D
τ : X✝ ⟶ Y✝
⊢ MorphismProperty.Q W ⋙ (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) X✝ = X✝.obj

Next tactic:
rw [fac]
/-- 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 

Proof state:
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✝ : MorphismProperty.FunctorsInverting W D
τ : X✝ ⟶ Y✝
⊢ Y✝.obj = MorphismProperty.Q W ⋙ (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) Y✝

Next tactic:
rw [fac]
/-- 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
        

Proof state:
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✝
G : MorphismProperty.FunctorsInverting W D
⊢ 𝟙 (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
        (𝟙 G) =
    𝟙 (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)) }.obj
          G)

Next tactic:
rw [natTransExtension_hcomp]
/-- 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]
        

Proof state:
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✝
G : MorphismProperty.FunctorsInverting W D
⊢ eqToHom (_ : MorphismProperty.Q W ⋙ (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) G = G.obj) ≫
      𝟙 G ≫
        eqToHom
          (_ : G.obj = MorphismProperty.Q W ⋙ (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) G) =
    𝟙 (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)) }.obj
          G)

Next tactic:
ext X
/-- 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
        

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✝
G : MorphismProperty.FunctorsInverting W D
X : C
⊢ (eqToHom (_ : MorphismProperty.Q W ⋙ (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) G = G.obj) ≫
          𝟙 G ≫
            eqToHom
              (_ :
                G.obj = MorphismProperty.Q W ⋙ (fun G => lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)) G)).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)) }.obj
              G)).app
      X

Next tactic:
simp only [NatTrans.comp_app, eqToHom_app, eqToHom_refl, comp_id, id_comp,
          NatTrans.hcomp_id_app, NatTrans.id_app, Functor.map_id]
/-- 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]
        

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✝
G : MorphismProperty.FunctorsInverting W D
X : C
⊢ (𝟙 G).app X = 𝟙 ((lift G.obj (_ : MorphismProperty.IsInvertedBy W G.obj)).obj ((MorphismProperty.Q W).obj X))

Next tactic:
rfl
/-- 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
        

Proof state:
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✝
⊢ 𝟙 (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
        (τ₁ ≫ τ₂) =
    𝟙 (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
          τ₂)

Next tactic:
ext X
/-- 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
        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]
        

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
⊢ (τ₁ ≫ τ₂).app X = τ₁.app X ≫ τ₂.app X

Next tactic:
rfl
/-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D :=
  eqToIso
    (by
      

Proof state:
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
⊢ 𝟭 (MorphismProperty.Localization W ⥤ D) = functor W D ⋙ inverse W D

Next tactic:
refine' Functor.ext (fun G => _) fun G₁ G₂ τ => _
/-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D :=
  eqToIso
    (by
      refine' Functor.ext (fun G => _) fun G₁ G₂ τ => _
      · 

Proof state:
case refine'_1
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✝
G : MorphismProperty.Localization W ⥤ D
⊢ (𝟭 (MorphismProperty.Localization W ⥤ D)).obj G = (functor W D ⋙ inverse W D).obj G

Next tactic:
apply uniq
/-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D :=
  eqToIso
    (by
      refine' Functor.ext (fun G => _) fun G₁ G₂ τ => _
      · apply uniq
        

Proof state:
case refine'_1.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✝
G : MorphismProperty.Localization W ⥤ D
⊢ MorphismProperty.Q W ⋙ (𝟭 (MorphismProperty.Localization W ⥤ D)).obj G =
    MorphismProperty.Q W ⋙ (functor W D ⋙ inverse W D).obj G

Next tactic:
dsimp [Functor]
/-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D :=
  eqToIso
    (by
      refine' Functor.ext (fun G => _) fun G₁ G₂ τ => _
      · apply uniq
        dsimp [Functor]
        

Proof state:
case refine'_1.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✝
G : MorphismProperty.Localization W ⥤ D
⊢ MorphismProperty.Q W ⋙ G = MorphismProperty.Q W ⋙ (inverse W D).obj ((functor W D).obj G)

Next tactic:
erw [fac]
/-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D :=
  eqToIso
    (by
      refine' Functor.ext (fun G => _) fun G₁ G₂ τ => _
      · apply uniq
        dsimp [Functor]
        erw [fac]
        

Proof state:
case refine'_1.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✝
G : MorphismProperty.Localization W ⥤ D
⊢ MorphismProperty.Q W ⋙ G = ((functor W D).obj G).obj

Next tactic:
rfl
/-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D :=
  eqToIso
    (by
      refine' Functor.ext (fun G => _) fun G₁ G₂ τ => _
      · apply uniq
        dsimp [Functor]
        erw [fac]
        rfl
      · 

Proof state:
case refine'_2
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
G₁ G₂ : MorphismProperty.Localization W ⥤ D
τ : G₁ ⟶ G₂
⊢ (𝟭 (MorphismProperty.Localization W ⥤ D)).map τ =
    eqToHom (_ : (𝟭 (MorphismProperty.Localization W ⥤ D)).obj G₁ = (functor W D ⋙ inverse W D).obj G₁) ≫
      (functor W D ⋙ inverse W D).map τ ≫
        eqToHom (_ : (functor W D ⋙ inverse W D).obj G₂ = (𝟭 (MorphismProperty.Localization W ⥤ D)).obj G₂)

Next tactic:
apply natTrans_hcomp_injective
/-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D :=
  eqToIso
    (by
      refine' Functor.ext (fun G => _) fun G₁ G₂ τ => _
      · apply uniq
        dsimp [Functor]
        erw [fac]
        rfl
      · apply natTrans_hcomp_injective
        

Proof state:
case refine'_2.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
G₁ G₂ : MorphismProperty.Localization W ⥤ D
τ : G₁ ⟶ G₂
⊢ 𝟙 (MorphismProperty.Q W) ◫ (𝟭 (MorphismProperty.Localization W ⥤ D)).map τ =
    𝟙 (MorphismProperty.Q W) ◫
      (eqToHom (_ : (𝟭 (MorphismProperty.Localization W ⥤ D)).obj G₁ = (functor W D ⋙ inverse W D).obj G₁) ≫
        (functor W D ⋙ inverse W D).map τ ≫
          eqToHom (_ : (functor W D ⋙ inverse W D).obj G₂ = (𝟭 (MorphismProperty.Localization W ⥤ D)).obj G₂))

Next tactic:
ext X
/-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D :=
  eqToIso
    (by
      refine' Functor.ext (fun G => _) fun G₁ G₂ τ => _
      · apply uniq
        dsimp [Functor]
        erw [fac]
        rfl
      · apply natTrans_hcomp_injective
        ext X
        

Proof state:
case refine'_2.h.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
G₁ G₂ : MorphismProperty.Localization W ⥤ D
τ : G₁ ⟶ G₂
X : C
⊢ (𝟙 (MorphismProperty.Q W) ◫ (𝟭 (MorphismProperty.Localization W ⥤ D)).map τ).app X =
    (𝟙 (MorphismProperty.Q W) ◫
          (eqToHom (_ : (𝟭 (MorphismProperty.Localization W ⥤ D)).obj G₁ = (functor W D ⋙ inverse W D).obj G₁) ≫
            (functor W D ⋙ inverse W D).map τ ≫
              eqToHom (_ : (functor W D ⋙ inverse W D).obj G₂ = (𝟭 (MorphismProperty.Localization W ⥤ D)).obj G₂))).app
      X

Next tactic:
simp
/-- The counit isomorphism of the equivalence of categories `WhiskeringLeftEquivalence W D`. -/
@[simps!]
def counitIso : inverse W D ⋙ functor W D ≅ 𝟭 (W.FunctorsInverting D) :=
  eqToIso
    (by
      

Proof state:
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
⊢ inverse W D ⋙ functor W D = 𝟭 (MorphismProperty.FunctorsInverting W D)

Next tactic:
refine' Functor.ext _ _
/-- The counit isomorphism of the equivalence of categories `WhiskeringLeftEquivalence W D`. -/
@[simps!]
def counitIso : inverse W D ⋙ functor W D ≅ 𝟭 (W.FunctorsInverting D) :=
  eqToIso
    (by
      refine' Functor.ext _ _
      · 

Proof state:
case refine'_1
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 : MorphismProperty.FunctorsInverting W D),
    (inverse W D ⋙ functor W D).obj X = (𝟭 (MorphismProperty.FunctorsInverting W D)).obj X

Next tactic:
rintro ⟨G, hG⟩
/-- The counit isomorphism of the equivalence of categories `WhiskeringLeftEquivalence W D`. -/
@[simps!]
def counitIso : inverse W D ⋙ functor W D ≅ 𝟭 (W.FunctorsInverting D) :=
  eqToIso
    (by
      refine' Functor.ext _ _
      · rintro ⟨G, hG⟩
        

Proof state:
case refine'_1.mk
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✝
G : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G
⊢ (inverse W D ⋙ functor W D).obj { obj := G, property := hG } =
    (𝟭 (MorphismProperty.FunctorsInverting W D)).obj { obj := G, property := hG }

Next tactic:
ext
/-- The counit isomorphism of the equivalence of categories `WhiskeringLeftEquivalence W D`. -/
@[simps!]
def counitIso : inverse W D ⋙ functor W D ≅ 𝟭 (W.FunctorsInverting D) :=
  eqToIso
    (by
      refine' Functor.ext _ _
      · rintro ⟨G, hG⟩
        ext
        

Proof state:
case refine'_1.mk.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✝
G : C ⥤ D
hG : MorphismProperty.IsInvertedBy W G
⊢ ((inverse W D ⋙ functor W D).obj { obj := G, property := hG }).obj =
    ((𝟭 (MorphismProperty.FunctorsInverting W D)).obj { obj := G, property := hG }).obj

Next tactic:
exact fac G hG