File: Mathlib/CategoryTheory/Localization/Construction.lean

full_name: CategoryTheory.Localization.Construction.LocQuiver
code: /-- If `W : MorphismProperty C`, `LocQuiver W` is a quiver with the same objects
as `C`, and whose morphisms are those in `C` and placeholders for formal
inverses of the morphisms in `W`. -/
structure LocQuiver (W : MorphismProperty C) where
  /-- underlying object -/
  obj : C
goal: Type uC

full_name: CategoryTheory.Localization.Construction.LocQuiver.obj
code: /-- If `W : MorphismProperty C`, `LocQuiver W` is a quiver with the same objects
as `C`, and whose morphisms are those in `C` and placeholders for formal
inverses of the morphisms in `W`. -/
structure LocQuiver (W : MorphismProperty C) where
  /-- underlying object -/
  obj : C
goal: C

full_name: CategoryTheory.Localization.Construction.instQuiverLocQuiver
code: instance : Quiver (LocQuiver W) 
goal: Quiver (CategoryTheory.Localization.Construction.LocQuiver W)

full_name: CategoryTheory.Localization.Construction.ιPaths
code: /-- The object in the path category of `LocQuiver W` attached to an object in
the category `C` -/
def ιPaths (X : C) : Paths (LocQuiver W) 
goal: CategoryTheory.Paths (CategoryTheory.Localization.Construction.LocQuiver W)

full_name: CategoryTheory.Localization.Construction.ψ₁
code: /-- The morphism in the path category associated to a morphism in the original category. -/
@[simp]
def ψ₁ {X Y : C} (f : X ⟶ Y) : ιPaths W X ⟶ ιPaths W Y 
goal: CategoryTheory.Localization.Construction.ιPaths W X ⟶ CategoryTheory.Localization.Construction.ιPaths W Y

full_name: CategoryTheory.Localization.Construction.ψ₂
code: /-- The morphism in the path category corresponding to a formal inverse. -/
@[simp]
def ψ₂ {X Y : C} (w : X ⟶ Y) (hw : W w) : ιPaths W Y ⟶ ιPaths W X 
goal: CategoryTheory.Localization.Construction.ιPaths W Y ⟶ CategoryTheory.Localization.Construction.ιPaths W X

full_name: CategoryTheory.Localization.Construction.relations.Winv₁
code: /-- The relations by which we take the quotient in order to get the localized category. -/
inductive relations : HomRel (Paths (LocQuiver W))
  | id (X : C) : relations (ψ₁ W (𝟙 X)) (𝟙 _)
  | comp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : relations (ψ₁ W (f ≫ g)) (ψ₁ W f ≫ ψ₁ W g)
  | Winv₁ {X Y : C} (w : X ⟶ Y) (hw : W w) : relations (ψ₁ W w ≫ ψ₂ W w hw) (𝟙 _)
  | Winv₂ {X Y : C} (w : X ⟶ Y) (hw : W w) : relations (ψ₂ W w hw ≫ ψ₁ W w) (𝟙 _)
goal: CategoryTheory.Localization.Construction.relations W
  (CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.Construction.ψ₁ W w)
    (CategoryTheory.Localization.Construction.ψ₂ W w hw))
  (CategoryTheory.CategoryStruct.id (CategoryTheory.Localization.Construction.ιPaths W X))

full_name: CategoryTheory.Localization.Construction.relations.id
code: /-- The relations by which we take the quotient in order to get the localized category. -/
inductive relations : HomRel (Paths (LocQuiver W))
  | id (X : C) : relations (ψ₁ W (𝟙 X)) (𝟙 _)
  | comp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : relations (ψ₁ W (f ≫ g)) (ψ₁ W f ≫ ψ₁ W g)
  | Winv₁ {X Y : C} (w : X ⟶ Y) (hw : W w) : relations (ψ₁ W w ≫ ψ₂ W w hw) (𝟙 _)
  | Winv₂ {X Y : C} (w : X ⟶ Y) (hw : W w) : relations (ψ₂ W w hw ≫ ψ₁ W w) (𝟙 _)
goal: CategoryTheory.Localization.Construction.relations W
  (CategoryTheory.Localization.Construction.ψ₁ W (CategoryTheory.CategoryStruct.id X))
  (CategoryTheory.CategoryStruct.id (CategoryTheory.Localization.Construction.ιPaths W X))

full_name: CategoryTheory.Localization.Construction.relations.Winv₂
code: /-- The relations by which we take the quotient in order to get the localized category. -/
inductive relations : HomRel (Paths (LocQuiver W))
  | id (X : C) : relations (ψ₁ W (𝟙 X)) (𝟙 _)
  | comp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : relations (ψ₁ W (f ≫ g)) (ψ₁ W f ≫ ψ₁ W g)
  | Winv₁ {X Y : C} (w : X ⟶ Y) (hw : W w) : relations (ψ₁ W w ≫ ψ₂ W w hw) (𝟙 _)
  | Winv₂ {X Y : C} (w : X ⟶ Y) (hw : W w) : relations (ψ₂ W w hw ≫ ψ₁ W w) (𝟙 _)
goal: CategoryTheory.Localization.Construction.relations W
  (CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.Construction.ψ₂ W w hw)
    (CategoryTheory.Localization.Construction.ψ₁ W w))
  (CategoryTheory.CategoryStruct.id (CategoryTheory.Localization.Construction.ιPaths W Y))

full_name: CategoryTheory.Localization.Construction.relations
code: /-- The relations by which we take the quotient in order to get the localized category. -/
inductive relations : HomRel (Paths (LocQuiver W))
  | id (X : C) : relations (ψ₁ W (𝟙 X)) (𝟙 _)
  | comp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : relations (ψ₁ W (f ≫ g)) (ψ₁ W f ≫ ψ₁ W g)
  | Winv₁ {X Y : C} (w : X ⟶ Y) (hw : W w) : relations (ψ₁ W w ≫ ψ₂ W w hw) (𝟙 _)
  | Winv₂ {X Y : C} (w : X ⟶ Y) (hw : W w) : relations (ψ₂ W w hw ≫ ψ₁ W w) (𝟙 _)
goal: HomRel (CategoryTheory.Paths (CategoryTheory.Localization.Construction.LocQuiver W))

full_name: CategoryTheory.Localization.Construction.relations.comp
code: /-- The relations by which we take the quotient in order to get the localized category. -/
inductive relations : HomRel (Paths (LocQuiver W))
  | id (X : C) : relations (ψ₁ W (𝟙 X)) (𝟙 _)
  | comp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : relations (ψ₁ W (f ≫ g)) (ψ₁ W f ≫ ψ₁ W g)
  | Winv₁ {X Y : C} (w : X ⟶ Y) (hw : W w) : relations (ψ₁ W w ≫ ψ₂ W w hw) (𝟙 _)
  | Winv₂ {X Y : C} (w : X ⟶ Y) (hw : W w) : relations (ψ₂ W w hw ≫ ψ₁ W w) (𝟙 _)
goal: CategoryTheory.Localization.Construction.relations W
  (CategoryTheory.Localization.Construction.ψ₁ W (CategoryTheory.CategoryStruct.comp f g))
  (CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.Construction.ψ₁ W f)
    (CategoryTheory.Localization.Construction.ψ₁ W g))

full_name: CategoryTheory.MorphismProperty.Localization
code: /-- The localized category obtained by formally inverting the morphisms
in `W : MorphismProperty C` -/
def Localization 
goal: Type uC

full_name: CategoryTheory.MorphismProperty.instCategoryLocalization
code: instance : Category (Localization W) 
goal: CategoryTheory.Category.{max uC uC', uC} W.Localization

full_name: CategoryTheory.MorphismProperty.Q
code: /-- The obvious functor `C ⥤ W.Localization` -/
def Q : C ⥤ W.Localization 
goal: CategoryTheory.Functor C W.Localization

full_name: CategoryTheory.Localization.Construction.wIso
code: /-- The isomorphism in `W.Localization` associated to a morphism `w` in W -/
def wIso {X Y : C} (w : X ⟶ Y) (hw : W w) : Iso (W.Q.obj X) (W.Q.obj Y) 
goal: W.Q.obj X ≅ W.Q.obj Y

full_name: CategoryTheory.Localization.Construction.wInv
code: /-- The formal inverse in `W.Localization` of a morphism `w` in `W`. -/
abbrev wInv {X Y : C} (w : X ⟶ Y) (hw : W w) 
goal: W.Q.obj Y ⟶ W.Q.obj X

full_name: CategoryTheory.MorphismProperty.Q_inverts
code: theorem _root_.CategoryTheory.MorphismProperty.Q_inverts : W.IsInvertedBy W.Q 
goal: W.IsInvertedBy W.Q

full_name: CategoryTheory.Localization.Construction.liftToPathCategory_map
code: /-- The lifting of a functor to the path category of `LocQuiver W` -/
@[simps!]
def liftToPathCategory : Paths (LocQuiver W) ⥤ D 
goal: ∀ {X Y : CategoryTheory.Paths (CategoryTheory.Localization.Construction.LocQuiver W)} (f : X ⟶ Y),
  (CategoryTheory.Localization.Construction.liftToPathCategory G hG).map f =
    CategoryTheory.composePath
      ({ obj := fun X => G.obj X.obj,
            map := fun {X Y} a =>
              Sum.rec (fun val => G.map val) (fun val => CategoryTheory.inv (G.map ↑val)) a }.mapPath
        f)

full_name: CategoryTheory.Localization.Construction.liftToPathCategory
code: /-- The lifting of a functor to the path category of `LocQuiver W` -/
@[simps!]
def liftToPathCategory : Paths (LocQuiver W) ⥤ D 
goal: CategoryTheory.Functor (CategoryTheory.Paths (CategoryTheory.Localization.Construction.LocQuiver W)) D

full_name: CategoryTheory.Localization.Construction.liftToPathCategory_obj
code: /-- The lifting of a functor to the path category of `LocQuiver W` -/
@[simps!]
def liftToPathCategory : Paths (LocQuiver W) ⥤ D 
goal: (CategoryTheory.Localization.Construction.liftToPathCategory G hG).obj X = G.obj X.obj

full_name: CategoryTheory.Localization.Construction.lift_obj
code: /-- The lifting of a functor `C ⥤ D` inverting `W` as a functor `W.Localization ⥤ D` -/
@[simps!]
def lift : W.Localization ⥤ D 
goal: (CategoryTheory.Localization.Construction.lift G hG).obj a = G.obj a.as.obj

full_name: CategoryTheory.Localization.Construction.lift_map
code: /-- The lifting of a functor `C ⥤ D` inverting `W` as a functor `W.Localization ⥤ D` -/
@[simps!]
def lift : W.Localization ⥤ D 
goal: (CategoryTheory.Localization.Construction.lift G hG).map hf =
  Quot.liftOn hf
    (fun f =>
      CategoryTheory.composePath
        ({ obj := fun X => G.obj X.obj,
              map := fun {X Y} a =>
                Sum.rec (fun val => G.map val) (fun val => CategoryTheory.inv (G.map ↑val)) a }.mapPath
          f))
    ⋯

full_name: CategoryTheory.Localization.Construction.lift
code: /-- The lifting of a functor `C ⥤ D` inverting `W` as a functor `W.Localization ⥤ D` -/
@[simps!]
def lift : W.Localization ⥤ D 
goal: CategoryTheory.Functor W.Localization D

full_name: CategoryTheory.Localization.Construction.fac
code: @[simp]
theorem fac : W.Q ⋙ lift G hG = G 
goal: W.Q.comp (CategoryTheory.Localization.Construction.lift G hG) = G

full_name: CategoryTheory.Localization.Construction.uniq
code: theorem uniq (G₁ G₂ : W.Localization ⥤ D) (h : W.Q ⋙ G₁ = W.Q ⋙ G₂) : G₁ = G₂ 
goal: G₁ = G₂

full_name: CategoryTheory.Localization.Construction.objEquiv_symm_apply
code: /-- The canonical bijection between objects in a category and its
localization with respect to a morphism_property `W` -/
@[simps]
def objEquiv : C ≃ W.Localization 
goal: (CategoryTheory.Localization.Construction.objEquiv W).symm X = X.as.obj

full_name: CategoryTheory.Localization.Construction.objEquiv_apply
code: /-- The canonical bijection between objects in a category and its
localization with respect to a morphism_property `W` -/
@[simps]
def objEquiv : C ≃ W.Localization 
goal: ∀ (a : C), (CategoryTheory.Localization.Construction.objEquiv W) a = W.Q.obj a

full_name: CategoryTheory.Localization.Construction.objEquiv
code: /-- The canonical bijection between objects in a category and its
localization with respect to a morphism_property `W` -/
@[simps]
def objEquiv : C ≃ W.Localization 
goal: C ≃ W.Localization

full_name: CategoryTheory.Localization.Construction.morphismProperty_is_top
code: /-- A `MorphismProperty` in `W.Localization` is satisfied by all
morphisms in the localized category if it contains the image of the
morphisms in the original category, the inverses of the morphisms
in `W` and if it is stable under composition -/
theorem morphismProperty_is_top (P : MorphismProperty W.Localization)
    [P.IsStableUnderComposition] (hP₁ : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), P (W.Q.map f))
    (hP₂ : ∀ ⦃X Y : C⦄ (w : X ⟶ Y) (hw : W w), P (wInv w hw)) :
    P = ⊤ 
goal: P = ⊤

full_name: CategoryTheory.Localization.Construction.morphismProperty_is_top'
code: /-- A `MorphismProperty` in `W.Localization` is satisfied by all
morphisms in the localized category if it contains the image of the
morphisms in the original category, if is stable under composition
and if the property is stable by passing to inverses. -/
theorem morphismProperty_is_top' (P : MorphismProperty W.Localization)
    [P.IsStableUnderComposition] (hP₁ : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), P (W.Q.map f))
    (hP₂ : ∀ ⦃X Y : W.Localization⦄ (e : X ≅ Y) (_ : P e.hom), P e.inv) : P = ⊤ 
goal: P = ⊤

full_name: CategoryTheory.Localization.Construction.NatTransExtension.app
code: /-- If `F₁` and `F₂` are functors `W.Localization ⥤ D` and if we have
`τ : W.Q ⋙ F₁ ⟶ W.Q ⋙ F₂`, we shall define a natural transformation `F₁ ⟶ F₂`.
This is the `app` field of this natural transformation. -/
def app (X : W.Localization) : F₁.obj X ⟶ F₂.obj X 
goal: F₁.obj X ⟶ F₂.obj X

full_name: CategoryTheory.Localization.Construction.NatTransExtension.app_eq
code: @[simp]
theorem app_eq (X : C) : (app τ) (W.Q.obj X) = τ.app X 
goal: CategoryTheory.Localization.Construction.NatTransExtension.app τ (W.Q.obj X) = τ.app X

full_name: CategoryTheory.Localization.Construction.natTransExtension
code: /-- 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₂ 
goal: F₁ ⟶ F₂

full_name: CategoryTheory.Localization.Construction.natTransExtension_app
code: /-- 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₂ 
goal: (CategoryTheory.Localization.Construction.natTransExtension τ).app X =
  CategoryTheory.Localization.Construction.NatTransExtension.app τ X

full_name: CategoryTheory.Localization.Construction.natTransExtension_hcomp
code: @[simp]
theorem natTransExtension_hcomp {F G : W.Localization ⥤ D} (τ : W.Q ⋙ F ⟶ W.Q ⋙ G) :
    𝟙 W.Q ◫ natTransExtension τ = τ 
goal: CategoryTheory.CategoryStruct.id W.Q ◫ CategoryTheory.Localization.Construction.natTransExtension τ = τ

full_name: CategoryTheory.Localization.Construction.natTrans_hcomp_injective
code: theorem natTrans_hcomp_injective {F G : W.Localization ⥤ D} {τ₁ τ₂ : F ⟶ G}
    (h : 𝟙 W.Q ◫ τ₁ = 𝟙 W.Q ◫ τ₂) : τ₁ = τ₂ 
goal: τ₁ = τ₂

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.functor_obj_obj_obj
code: /-- The functor `(W.Localization ⥤ D) ⥤ (W.FunctorsInverting D)` induced by the
composition with `W.Q : C ⥤ W.Localization`. -/
@[simps!]
def functor : (W.Localization ⥤ D) ⥤ W.FunctorsInverting D 
goal: ∀ (X_1 : C),
  ((CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.functor W D).obj X).obj.obj X_1 =
    X.obj (W.Q.obj X_1)

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.functor
code: /-- The functor `(W.Localization ⥤ D) ⥤ (W.FunctorsInverting D)` induced by the
composition with `W.Q : C ⥤ W.Localization`. -/
@[simps!]
def functor : (W.Localization ⥤ D) ⥤ W.FunctorsInverting D 
goal: CategoryTheory.Functor (CategoryTheory.Functor W.Localization D) (W.FunctorsInverting D)

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.functor_obj_obj_map
code: /-- The functor `(W.Localization ⥤ D) ⥤ (W.FunctorsInverting D)` induced by the
composition with `W.Q : C ⥤ W.Localization`. -/
@[simps!]
def functor : (W.Localization ⥤ D) ⥤ W.FunctorsInverting D 
goal: ∀ {X_1 Y : C} (f : X_1 ⟶ Y),
  ((CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.functor W D).obj X).obj.map f = X.map (W.Q.map f)

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.functor_map_app
code: /-- The functor `(W.Localization ⥤ D) ⥤ (W.FunctorsInverting D)` induced by the
composition with `W.Q : C ⥤ W.Localization`. -/
@[simps!]
def functor : (W.Localization ⥤ D) ⥤ W.FunctorsInverting D 
goal: ∀ {X Y : CategoryTheory.Functor W.Localization D} (f : X ⟶ Y) (X_1 : C),
  ((CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.functor W D).map f).app X_1 = f.app (W.Q.obj X_1)

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse_obj_obj
code: /-- The function `(W.FunctorsInverting D) ⥤ (W.Localization ⥤ D)` induced by
`Construction.lift`. -/
@[simps!]
def inverse : W.FunctorsInverting D ⥤ W.Localization ⥤ D 
goal: ((CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse W D).obj G).obj a = G.obj.obj a.as.obj

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse_map_app
code: /-- The function `(W.FunctorsInverting D) ⥤ (W.Localization ⥤ D)` induced by
`Construction.lift`. -/
@[simps!]
def inverse : W.FunctorsInverting D ⥤ W.Localization ⥤ D 
goal: ∀ {X Y : W.FunctorsInverting D} (τ : X ⟶ Y) (X_1 : W.Localization),
  ((CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse W D).map τ).app X_1 =
    CategoryTheory.Localization.Construction.NatTransExtension.app
      (CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
        (CategoryTheory.CategoryStruct.comp τ (CategoryTheory.eqToHom ⋯)))
      X_1

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse
code: /-- The function `(W.FunctorsInverting D) ⥤ (W.Localization ⥤ D)` induced by
`Construction.lift`. -/
@[simps!]
def inverse : W.FunctorsInverting D ⥤ W.Localization ⥤ D 
goal: CategoryTheory.Functor (W.FunctorsInverting D) (CategoryTheory.Functor W.Localization D)

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse_obj_map
code: /-- The function `(W.FunctorsInverting D) ⥤ (W.Localization ⥤ D)` induced by
`Construction.lift`. -/
@[simps!]
def inverse : W.FunctorsInverting D ⥤ W.Localization ⥤ D 
goal: ((CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse W D).obj G).map hf =
  Quot.liftOn hf
    (fun f =>
      CategoryTheory.composePath
        ({ obj := fun X => G.obj.obj X.obj,
              map := fun {X Y} a =>
                Sum.rec (fun val => G.obj.map val) (fun val => CategoryTheory.inv (G.obj.map ↑val)) a }.mapPath
          f))
    ⋯

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.unitIso
code: /-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D 
goal: CategoryTheory.Functor.id (CategoryTheory.Functor W.Localization D) ≅
  (CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.functor W D).comp
    (CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse W D)

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.unitIso_inv
code: /-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D 
goal: (CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.unitIso W D).inv = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.unitIso_hom
code: /-- The unit isomorphism of the equivalence of categories `whiskeringLeftEquivalence W D`. -/
@[simps!]
def unitIso : 𝟭 (W.Localization ⥤ D) ≅ functor W D ⋙ inverse W D 
goal: (CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.unitIso W D).hom = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.counitIso_hom
code: /-- The counit isomorphism of the equivalence of categories `WhiskeringLeftEquivalence W D`. -/
@[simps!]
def counitIso : inverse W D ⋙ functor W D ≅ 𝟭 (W.FunctorsInverting D) 
goal: (CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.counitIso W D).hom = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.counitIso
code: /-- The counit isomorphism of the equivalence of categories `WhiskeringLeftEquivalence W D`. -/
@[simps!]
def counitIso : inverse W D ⋙ functor W D ≅ 𝟭 (W.FunctorsInverting D) 
goal: (CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.inverse W D).comp
    (CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.functor W D) ≅
  CategoryTheory.Functor.id (W.FunctorsInverting D)

full_name: CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.counitIso_inv
code: /-- The counit isomorphism of the equivalence of categories `WhiskeringLeftEquivalence W D`. -/
@[simps!]
def counitIso : inverse W D ⋙ functor W D ≅ 𝟭 (W.FunctorsInverting D) 
goal: (CategoryTheory.Localization.Construction.WhiskeringLeftEquivalence.counitIso W D).inv = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Localization.Construction.whiskeringLeftEquivalence
code: /-- The equivalence of categories `(W.localization ⥤ D) ≌ (W.FunctorsInverting D)`
induced by the composition with `W.Q : C ⥤ W.localization`. -/
def whiskeringLeftEquivalence : W.Localization ⥤ D ≌ W.FunctorsInverting D 
goal: CategoryTheory.Functor W.Localization D ≌ W.FunctorsInverting D