l3lab/ntp-mathlib huggingface dataset:
instance : IsEquivalence (whiskeringLeftFunctor L W E) := by
  refine'
    IsEquivalence.ofIso _
      (IsEquivalence.ofEquivalence
        ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
          (Construction.whiskeringLeftEquivalence W E)))
  exact
    NatIso.ofComponents
      (fun F =>
        eqToIso
          (by
            ext
            change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ F = L ⋙ F
            rw [Construction.fac]))
      fun τ => by
        

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.22534, u_1} C
inst✝² : Category.{?u.22538, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.22587, u_3} E
inst✝ : Functor.IsLocalization L W
X✝ Y✝ : D ⥤ E
τ : X✝ ⟶ Y✝
⊢ ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
              (Construction.whiskeringLeftEquivalence W E)).functor.map
        τ ≫
      ((fun F =>
            eqToIso
              (_ :
                ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
                          (Construction.whiskeringLeftEquivalence W E)).functor.obj
                    F =
                  (whiskeringLeftFunctor L W E).obj F))
          Y✝).hom =
    ((fun F =>
            eqToIso
              (_ :
                ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
                          (Construction.whiskeringLeftEquivalence W E)).functor.obj
                    F =
                  (whiskeringLeftFunctor L W E).obj F))
          X✝).hom ≫
      (whiskeringLeftFunctor L W E).map τ

Next tactic:
ext
instance : IsEquivalence (whiskeringLeftFunctor L W E) := by
  refine'
    IsEquivalence.ofIso _
      (IsEquivalence.ofEquivalence
        ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
          (Construction.whiskeringLeftEquivalence W E)))
  exact
    NatIso.ofComponents
      (fun F =>
        eqToIso
          (by
            ext
            change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ F = L ⋙ F
            rw [Construction.fac]))
      fun τ => by
        ext
        

Proof state:
case h.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.22534, u_1} C
inst✝² : Category.{?u.22538, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.22587, u_3} E
inst✝ : Functor.IsLocalization L W
X✝ Y✝ : D ⥤ E
τ : X✝ ⟶ Y✝
x✝ : C
⊢ (((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
                  (Construction.whiskeringLeftEquivalence W E)).functor.map
            τ ≫
          ((fun F =>
                eqToIso
                  (_ :
                    ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
                              (Construction.whiskeringLeftEquivalence W E)).functor.obj
                        F =
                      (whiskeringLeftFunctor L W E).obj F))
              Y✝).hom).app
      x✝ =
    (((fun F =>
                eqToIso
                  (_ :
                    ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
                              (Construction.whiskeringLeftEquivalence W E)).functor.obj
                        F =
                      (whiskeringLeftFunctor L W E).obj F))
              X✝).hom ≫
          (whiskeringLeftFunctor L W E).map τ).app
      x✝

Next tactic:
dsimp [Construction.whiskeringLeftEquivalence, equivalenceFromModel, whiskerLeft]
instance : IsEquivalence (whiskeringLeftFunctor L W E) := by
  refine'
    IsEquivalence.ofIso _
      (IsEquivalence.ofEquivalence
        ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
          (Construction.whiskeringLeftEquivalence W E)))
  exact
    NatIso.ofComponents
      (fun F =>
        eqToIso
          (by
            ext
            change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ F = L ⋙ F
            rw [Construction.fac]))
      fun τ => by
        ext
        dsimp [Construction.whiskeringLeftEquivalence, equivalenceFromModel, whiskerLeft]
        

Proof state:
case h.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.22534, u_1} C
inst✝² : Category.{?u.22538, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.22587, u_3} E
inst✝ : Functor.IsLocalization L W
X✝ Y✝ : D ⥤ E
τ : X✝ ⟶ Y✝
x✝ : C
⊢ ((Construction.WhiskeringLeftEquivalence.functor W E).map (NatTrans.mk fun X => τ.app (L.obj X.as.obj)) ≫
          eqToHom
            (_ :
              (Construction.WhiskeringLeftEquivalence.functor W E).obj
                  (Construction.lift L (_ : MorphismProperty.IsInvertedBy W L) ⋙ Y✝) =
                (whiskeringLeftFunctor L W E).obj Y✝)).app
      x✝ =
    (eqToHom
            (_ :
              (Construction.WhiskeringLeftEquivalence.functor W E).obj
                  (Construction.lift L (_ : MorphismProperty.IsInvertedBy W L) ⋙ X✝) =
                (whiskeringLeftFunctor L W E).obj X✝) ≫
          (whiskeringLeftFunctor L W E).map τ).app
      x✝

Next tactic:
erw [NatTrans.comp_app, NatTrans.comp_app, eqToHom_app, eqToHom_app, eqToHom_refl,
          eqToHom_refl, comp_id, id_comp]
instance : IsEquivalence (whiskeringLeftFunctor L W E) := by
  refine'
    IsEquivalence.ofIso _
      (IsEquivalence.ofEquivalence
        ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
          (Construction.whiskeringLeftEquivalence W E)))
  exact
    NatIso.ofComponents
      (fun F =>
        eqToIso
          (by
            ext
            change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ F = L ⋙ F
            rw [Construction.fac]))
      fun τ => by
        ext
        dsimp [Construction.whiskeringLeftEquivalence, equivalenceFromModel, whiskerLeft]
        erw [NatTrans.comp_app, NatTrans.comp_app, eqToHom_app, eqToHom_app, eqToHom_refl,
          eqToHom_refl, comp_id, id_comp]
        · 

Proof state:
case h.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.22534, u_1} C
inst✝² : Category.{?u.22538, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.22587, u_3} E
inst✝ : Functor.IsLocalization L W
X✝ Y✝ : D ⥤ E
τ : X✝ ⟶ Y✝
x✝ : C
⊢ ((Construction.WhiskeringLeftEquivalence.functor W E).map (NatTrans.mk fun X => τ.app (L.obj X.as.obj))).app x✝ =
    ((whiskeringLeftFunctor L W E).map τ).app x✝

Next tactic:
rfl
instance : IsEquivalence (whiskeringLeftFunctor L W E) := by
  refine'
    IsEquivalence.ofIso _
      (IsEquivalence.ofEquivalence
        ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
          (Construction.whiskeringLeftEquivalence W E)))
  exact
    NatIso.ofComponents
      (fun F =>
        eqToIso
          (by
            ext
            change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ F = L ⋙ F
            rw [Construction.fac]))
      fun τ => by
        ext
        dsimp [Construction.whiskeringLeftEquivalence, equivalenceFromModel, whiskerLeft]
        erw [NatTrans.comp_app, NatTrans.comp_app, eqToHom_app, eqToHom_app, eqToHom_refl,
          eqToHom_refl, comp_id, id_comp]
        · rfl
        all_goals
          

Proof state:
case h.h.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.22534, u_1} C
inst✝² : Category.{?u.22538, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.22587, u_3} E
inst✝ : Functor.IsLocalization L W
X✝ Y✝ : D ⥤ E
τ : X✝ ⟶ Y✝
x✝ : C
⊢ ((Construction.WhiskeringLeftEquivalence.functor W E).obj
        (Construction.lift L (_ : MorphismProperty.IsInvertedBy W L) ⋙ X✝)).obj =
    ((whiskeringLeftFunctor L W E).obj X✝).obj

Next tactic:
change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ _ = L ⋙ _
instance : IsEquivalence (whiskeringLeftFunctor L W E) := by
  refine'
    IsEquivalence.ofIso _
      (IsEquivalence.ofEquivalence
        ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
          (Construction.whiskeringLeftEquivalence W E)))
  exact
    NatIso.ofComponents
      (fun F =>
        eqToIso
          (by
            ext
            change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ F = L ⋙ F
            rw [Construction.fac]))
      fun τ => by
        ext
        dsimp [Construction.whiskeringLeftEquivalence, equivalenceFromModel, whiskerLeft]
        erw [NatTrans.comp_app, NatTrans.comp_app, eqToHom_app, eqToHom_app, eqToHom_refl,
          eqToHom_refl, comp_id, id_comp]
        · rfl
        all_goals
          change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ _ = L ⋙ _
          

Proof state:
case h.h.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.22534, u_1} C
inst✝² : Category.{?u.22538, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.22587, u_3} E
inst✝ : Functor.IsLocalization L W
X✝ Y✝ : D ⥤ E
τ : X✝ ⟶ Y✝
x✝ : C
⊢ (MorphismProperty.Q W ⋙ Construction.lift L (_ : MorphismProperty.IsInvertedBy W L)) ⋙ X✝ = L ⋙ X✝

Next tactic:
rw [Construction.fac]
instance : IsEquivalence (whiskeringLeftFunctor L W E) := by
  refine'
    IsEquivalence.ofIso _
      (IsEquivalence.ofEquivalence
        ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
          (Construction.whiskeringLeftEquivalence W E)))
  exact
    NatIso.ofComponents
      (fun F =>
        eqToIso
          (by
            ext
            change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ F = L ⋙ F
            rw [Construction.fac]))
      fun τ => by
        ext
        dsimp [Construction.whiskeringLeftEquivalence, equivalenceFromModel, whiskerLeft]
        erw [NatTrans.comp_app, NatTrans.comp_app, eqToHom_app, eqToHom_app, eqToHom_refl,
          eqToHom_refl, comp_id, id_comp]
        · rfl
        all_goals
          

Proof state:
case h.h.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.22534, u_1} C
inst✝² : Category.{?u.22538, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.22587, u_3} E
inst✝ : Functor.IsLocalization L W
X✝ Y✝ : D ⥤ E
τ : X✝ ⟶ Y✝
x✝ : C
⊢ ((Construction.WhiskeringLeftEquivalence.functor W E).obj
        (Construction.lift L (_ : MorphismProperty.IsInvertedBy W L) ⋙ Y✝)).obj =
    ((whiskeringLeftFunctor L W E).obj Y✝).obj

Next tactic:
change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ _ = L ⋙ _
instance : IsEquivalence (whiskeringLeftFunctor L W E) := by
  refine'
    IsEquivalence.ofIso _
      (IsEquivalence.ofEquivalence
        ((Equivalence.congrLeft (equivalenceFromModel L W).symm).trans
          (Construction.whiskeringLeftEquivalence W E)))
  exact
    NatIso.ofComponents
      (fun F =>
        eqToIso
          (by
            ext
            change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ F = L ⋙ F
            rw [Construction.fac]))
      fun τ => by
        ext
        dsimp [Construction.whiskeringLeftEquivalence, equivalenceFromModel, whiskerLeft]
        erw [NatTrans.comp_app, NatTrans.comp_app, eqToHom_app, eqToHom_app, eqToHom_refl,
          eqToHom_refl, comp_id, id_comp]
        · rfl
        all_goals
          change (W.Q ⋙ Localization.Construction.lift L (inverts L W)) ⋙ _ = L ⋙ _
          

Proof state:
case h.h.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.22534, u_1} C
inst✝² : Category.{?u.22538, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.22587, u_3} E
inst✝ : Functor.IsLocalization L W
X✝ Y✝ : D ⥤ E
τ : X✝ ⟶ Y✝
x✝ : C
⊢ (MorphismProperty.Q W ⋙ Construction.lift L (_ : MorphismProperty.IsInvertedBy W L)) ⋙ Y✝ = L ⋙ Y✝

Next tactic:
rw [Construction.fac]
instance : Full (whiskeringLeftFunctor' L W E) := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.45952, u_1} C
inst✝² : Category.{?u.45956, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.46005, u_3} E
inst✝ : Functor.IsLocalization L W
⊢ Full (whiskeringLeftFunctor' L W E)

Next tactic:
rw [whiskeringLeftFunctor'_eq]
instance : Full (whiskeringLeftFunctor' L W E) := by
  rw [whiskeringLeftFunctor'_eq]
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.45952, u_1} C
inst✝² : Category.{?u.45956, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.46005, u_3} E
inst✝ : Functor.IsLocalization L W
⊢ Full (whiskeringLeftFunctor L W E ⋙ inducedFunctor FullSubcategory.obj)

Next tactic:
apply @Full.comp _ _ _ _ _ _ _ _ ?_ ?_
instance : Full (whiskeringLeftFunctor' L W E) := by
  rw [whiskeringLeftFunctor'_eq]
  apply @Full.comp _ _ _ _ _ _ _ _ ?_ ?_
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.45952, u_1} C
inst✝² : Category.{?u.45956, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.46005, u_3} E
inst✝ : Functor.IsLocalization L W
⊢ Full (whiskeringLeftFunctor L W E)
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.45952, u_1} C
inst✝² : Category.{?u.45956, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.46005, u_3} E
inst✝ : Functor.IsLocalization L W
⊢ Full (inducedFunctor FullSubcategory.obj)

Next tactic:
infer_instance
instance : Full (whiskeringLeftFunctor' L W E) := by
  rw [whiskeringLeftFunctor'_eq]
  apply @Full.comp _ _ _ _ _ _ _ _ ?_ ?_
  infer_instance
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.45952, u_1} C
inst✝² : Category.{?u.45956, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.46005, u_3} E
inst✝ : Functor.IsLocalization L W
⊢ Full (inducedFunctor FullSubcategory.obj)

Next tactic:
apply InducedCategory.full
instance : Faithful (whiskeringLeftFunctor' L W E) := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.48056, u_1} C
inst✝² : Category.{?u.48060, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.48109, u_3} E
inst✝ : Functor.IsLocalization L W
⊢ Faithful (whiskeringLeftFunctor' L W E)

Next tactic:
rw [whiskeringLeftFunctor'_eq]
instance : Faithful (whiskeringLeftFunctor' L W E) := by
  rw [whiskeringLeftFunctor'_eq]
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.48056, u_1} C
inst✝² : Category.{?u.48060, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.48109, u_3} E
inst✝ : Functor.IsLocalization L W
⊢ Faithful (whiskeringLeftFunctor L W E ⋙ inducedFunctor FullSubcategory.obj)

Next tactic:
apply @Faithful.comp _ _ _ _ _ _ _ _ ?_ ?_
instance : Faithful (whiskeringLeftFunctor' L W E) := by
  rw [whiskeringLeftFunctor'_eq]
  apply @Faithful.comp _ _ _ _ _ _ _ _ ?_ ?_
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.48056, u_1} C
inst✝² : Category.{?u.48060, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.48109, u_3} E
inst✝ : Functor.IsLocalization L W
⊢ Faithful (whiskeringLeftFunctor L W E)
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.48056, u_1} C
inst✝² : Category.{?u.48060, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.48109, u_3} E
inst✝ : Functor.IsLocalization L W
⊢ Faithful (inducedFunctor FullSubcategory.obj)

Next tactic:
infer_instance
instance : Faithful (whiskeringLeftFunctor' L W E) := by
  rw [whiskeringLeftFunctor'_eq]
  apply @Faithful.comp _ _ _ _ _ _ _ _ ?_ ?_
  infer_instance
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.48056, u_1} C
inst✝² : Category.{?u.48060, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.48109, u_3} E
inst✝ : Functor.IsLocalization L W
⊢ Faithful (inducedFunctor FullSubcategory.obj)

Next tactic:
apply InducedCategory.faithful
theorem natTrans_ext {F₁ F₂ : D ⥤ E} (τ τ' : F₁ ⟶ F₂)
    (h : ∀ X : C, τ.app (L.obj X) = τ'.app (L.obj X)) : τ = τ' := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_6, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : Functor.IsLocalization L W
F₁ F₂ : D ⥤ E
τ τ' : F₁ ⟶ F₂
h : ∀ (X : C), τ.app (L.obj X) = τ'.app (L.obj X)
⊢ τ = τ'

Next tactic:
haveI : CategoryTheory.EssSurj L := essSurj L W
theorem natTrans_ext {F₁ F₂ : D ⥤ E} (τ τ' : F₁ ⟶ F₂)
    (h : ∀ X : C, τ.app (L.obj X) = τ'.app (L.obj X)) : τ = τ' := by
  haveI : CategoryTheory.EssSurj L := essSurj L W
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_6, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : Functor.IsLocalization L W
F₁ F₂ : D ⥤ E
τ τ' : F₁ ⟶ F₂
h : ∀ (X : C), τ.app (L.obj X) = τ'.app (L.obj X)
this : EssSurj L
⊢ τ = τ'

Next tactic:
ext Y
theorem natTrans_ext {F₁ F₂ : D ⥤ E} (τ τ' : F₁ ⟶ F₂)
    (h : ∀ X : C, τ.app (L.obj X) = τ'.app (L.obj X)) : τ = τ' := by
  haveI : CategoryTheory.EssSurj L := essSurj L W
  ext Y
  

Proof state:
case w.h
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_6, u_1} C
inst✝² : Category.{u_4, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : Functor.IsLocalization L W
F₁ F₂ : D ⥤ E
τ τ' : F₁ ⟶ F₂
h : ∀ (X : C), τ.app (L.obj X) = τ'.app (L.obj X)
this : EssSurj L
Y : D
⊢ τ.app Y = τ'.app Y

Next tactic:
rw [← cancel_epi (F₁.map (L.objObjPreimageIso Y).hom), τ.naturality, τ'.naturality, h]
@[reassoc (attr := simp)]
theorem comp_liftNatTrans (F₁ F₂ F₃ : C ⥤ E) (F₁' F₂' F₃' : D ⥤ E) [h₁ : Lifting L W F₁ F₁']
    [h₂ : Lifting L W F₂ F₂'] [h₃ : Lifting L W F₃ F₃'] (τ : F₁ ⟶ F₂) (τ' : F₂ ⟶ F₃) :
    liftNatTrans L W F₁ F₂ F₁' F₂' τ ≫ liftNatTrans L W F₂ F₃ F₂' F₃' τ' =
      liftNatTrans L W F₁ F₃ F₁' F₃' (τ ≫ τ') :=
  natTrans_ext L W _ _ fun X => by
    

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : Functor.IsLocalization L W
F₁ F₂ F₃ : C ⥤ E
F₁' F₂' F₃' : D ⥤ E
h₁ : Lifting L W F₁ F₁'
h₂ : Lifting L W F₂ F₂'
h₃ : Lifting L W F₃ F₃'
τ : F₁ ⟶ F₂
τ' : F₂ ⟶ F₃
X : C
⊢ (liftNatTrans L W F₁ F₂ F₁' F₂' τ ≫ liftNatTrans L W F₂ F₃ F₂' F₃' τ').app (L.obj X) =
    (liftNatTrans L W F₁ F₃ F₁' F₃' (τ ≫ τ')).app (L.obj X)

Next tactic:
simp only [NatTrans.comp_app, liftNatTrans_app, assoc, Iso.inv_hom_id_app_assoc]
@[simp]
theorem liftNatTrans_id (F : C ⥤ E) (F' : D ⥤ E) [h : Lifting L W F F'] :
    liftNatTrans L W F F F' F' (𝟙 F) = 𝟙 F' :=
  natTrans_ext L W _ _ fun X => by
    

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : Functor.IsLocalization L W
F : C ⥤ E
F' : D ⥤ E
h : Lifting L W F F'
X : C
⊢ (liftNatTrans L W F F F' F' (𝟙 F)).app (L.obj X) = (𝟙 F').app (L.obj X)

Next tactic:
simp only [liftNatTrans_app, NatTrans.id_app, id_comp, Iso.hom_inv_id_app]
@[simp]
theorem liftNatTrans_id (F : C ⥤ E) (F' : D ⥤ E) [h : Lifting L W F F'] :
    liftNatTrans L W F F F' F' (𝟙 F) = 𝟙 F' :=
  natTrans_ext L W _ _ fun X => by
    simp only [liftNatTrans_app, NatTrans.id_app, id_comp, Iso.hom_inv_id_app]
    

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_6, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{u_5, u_3} E
inst✝ : Functor.IsLocalization L W
F : C ⥤ E
F' : D ⥤ E
h : Lifting L W F F'
X : C
⊢ 𝟙 ((L ⋙ F').obj X) = 𝟙 (F'.obj (L.obj X))

Next tactic:
rfl
theorem of_iso {L₁ L₂ : C ⥤ D} (e : L₁ ≅ L₂) [L₁.IsLocalization W] : L₂.IsLocalization W := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_5, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.79202, u_3} E
L₁ L₂ : C ⥤ D
e : L₁ ≅ L₂
inst✝ : IsLocalization L₁ W
⊢ IsLocalization L₂ W

Next tactic:
have h := Localization.inverts L₁ W
theorem of_iso {L₁ L₂ : C ⥤ D} (e : L₁ ≅ L₂) [L₁.IsLocalization W] : L₂.IsLocalization W := by
  have h := Localization.inverts L₁ W
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_5, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.79202, u_3} E
L₁ L₂ : C ⥤ D
e : L₁ ≅ L₂
inst✝ : IsLocalization L₁ W
h : MorphismProperty.IsInvertedBy W L₁
⊢ IsLocalization L₂ W

Next tactic:
rw [MorphismProperty.IsInvertedBy.iff_of_iso W e] at h
theorem of_iso {L₁ L₂ : C ⥤ D} (e : L₁ ≅ L₂) [L₁.IsLocalization W] : L₂.IsLocalization W := by
  have h := Localization.inverts L₁ W
  rw [MorphismProperty.IsInvertedBy.iff_of_iso W e] at h
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_5, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.79202, u_3} E
L₁ L₂ : C ⥤ D
e : L₁ ≅ L₂
inst✝ : IsLocalization L₁ W
h : MorphismProperty.IsInvertedBy W L₂
⊢ IsLocalization L₂ W

Next tactic:
let F₁ := Localization.Construction.lift L₁ (Localization.inverts L₁ W)
theorem of_iso {L₁ L₂ : C ⥤ D} (e : L₁ ≅ L₂) [L₁.IsLocalization W] : L₂.IsLocalization W := by
  have h := Localization.inverts L₁ W
  rw [MorphismProperty.IsInvertedBy.iff_of_iso W e] at h
  let F₁ := Localization.Construction.lift L₁ (Localization.inverts L₁ W)
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_5, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.79202, u_3} E
L₁ L₂ : C ⥤ D
e : L₁ ≅ L₂
inst✝ : IsLocalization L₁ W
h : MorphismProperty.IsInvertedBy W L₂
F₁ : MorphismProperty.Localization W ⥤ D := Construction.lift L₁ (_ : MorphismProperty.IsInvertedBy W L₁)
⊢ IsLocalization L₂ W

Next tactic:
let F₂ := Localization.Construction.lift L₂ h
theorem of_iso {L₁ L₂ : C ⥤ D} (e : L₁ ≅ L₂) [L₁.IsLocalization W] : L₂.IsLocalization W := by
  have h := Localization.inverts L₁ W
  rw [MorphismProperty.IsInvertedBy.iff_of_iso W e] at h
  let F₁ := Localization.Construction.lift L₁ (Localization.inverts L₁ W)
  let F₂ := Localization.Construction.lift L₂ h
  

Proof state:
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_4, u_1} C
inst✝² : Category.{u_5, u_2} D
L : C ⥤ D
W : MorphismProperty C
E : Type u_3
inst✝¹ : Category.{?u.79202, u_3} E
L₁ L₂ : C ⥤ D
e : L₁ ≅ L₂
inst✝ : IsLocalization L₁ W
h : MorphismProperty.IsInvertedBy W L₂
F₁ : MorphismProperty.Localization W ⥤ D := Construction.lift L₁ (_ : MorphismProperty.IsInvertedBy W L₁)
F₂ : MorphismProperty.Localization W ⥤ D := Construction.lift L₂ h
⊢ IsLocalization L₂ W

Next tactic:
exact
    { inverts := h
      nonempty_isEquivalence :=
        Nonempty.intro (IsEquivalence.ofIso (liftNatIso W.Q W L₁ L₂ F₁ F₂ e) inferInstance) }
/-- If `L : C ⥤ D` is a localization for `W : MorphismProperty C`, then it is also
the case of a functor obtained by post-composing `L` with an equivalence of categories. -/
theorem of_equivalence_target {E : Type*} [Category E] (L' : C ⥤ E) (eq : D ≌ E)
    [L.IsLocalization W] (e : L ⋙ eq.functor ≅ L') : L'.IsLocalization W := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_6, u_1} C
inst✝³ : Category.{u_7, u_2} D
L : C ⥤ D
W : MorphismProperty C
E✝ : Type u_3
inst✝² : Category.{?u.80704, u_3} E✝
E : Type u_4
inst✝¹ : Category.{u_5, u_4} E
L' : C ⥤ E
eq : D ≌ E
inst✝ : IsLocalization L W
e : L ⋙ eq.functor ≅ L'
⊢ IsLocalization L' W

Next tactic:
have h : W.IsInvertedBy L' := by
    rw [← MorphismProperty.IsInvertedBy.iff_of_iso W e]
    exact MorphismProperty.IsInvertedBy.of_comp W L (Localization.inverts L W) eq.functor
/-- If `L : C ⥤ D` is a localization for `W : MorphismProperty C`, then it is also
the case of a functor obtained by post-composing `L` with an equivalence of categories. -/
theorem of_equivalence_target {E : Type*} [Category E] (L' : C ⥤ E) (eq : D ≌ E)
    [L.IsLocalization W] (e : L ⋙ eq.functor ≅ L') : L'.IsLocalization W := by
  have h : W.IsInvertedBy L' := by
    

Proof state:
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_6, u_1} C
inst✝³ : Category.{u_7, u_2} D
L : C ⥤ D
W : MorphismProperty C
E✝ : Type u_3
inst✝² : Category.{?u.80704, u_3} E✝
E : Type u_4
inst✝¹ : Category.{u_5, u_4} E
L' : C ⥤ E
eq : D ≌ E
inst✝ : IsLocalization L W
e : L ⋙ eq.functor ≅ L'
⊢ MorphismProperty.IsInvertedBy W L'

Next tactic:
rw [← MorphismProperty.IsInvertedBy.iff_of_iso W e]