File: Mathlib/CategoryTheory/Localization/Predicate.lean

full_name: CategoryTheory.Functor.IsLocalization
code: /-- The predicate expressing that, up to equivalence, a functor `L : C ⥤ D`
identifies the category `D` with the localized category of `C` with respect
to `W : MorphismProperty C`. -/
class IsLocalization : Prop where
  /-- the functor inverts the given `MorphismProperty` -/
  inverts : W.IsInvertedBy L
  /-- the induced functor from the constructed localized category is an equivalence -/
  isEquivalence : IsEquivalence (Localization.Construction.lift L inverts)
goal: Prop

full_name: CategoryTheory.Functor.IsLocalization.inverts
code: /-- The predicate expressing that, up to equivalence, a functor `L : C ⥤ D`
identifies the category `D` with the localized category of `C` with respect
to `W : MorphismProperty C`. -/
class IsLocalization : Prop where
  /-- the functor inverts the given `MorphismProperty` -/
  inverts : W.IsInvertedBy L
  /-- the induced functor from the constructed localized category is an equivalence -/
  isEquivalence : IsEquivalence (Localization.Construction.lift L inverts)
goal: W.IsInvertedBy L

full_name: CategoryTheory.Functor.IsLocalization.isEquivalence
code: /-- The predicate expressing that, up to equivalence, a functor `L : C ⥤ D`
identifies the category `D` with the localized category of `C` with respect
to `W : MorphismProperty C`. -/
class IsLocalization : Prop where
  /-- the functor inverts the given `MorphismProperty` -/
  inverts : W.IsInvertedBy L
  /-- the induced functor from the constructed localized category is an equivalence -/
  isEquivalence : IsEquivalence (Localization.Construction.lift L inverts)
goal: (CategoryTheory.Localization.Construction.lift L ⋯).IsEquivalence

full_name: CategoryTheory.Functor.q_isLocalization
code: instance q_isLocalization : W.Q.IsLocalization W 
goal: W.Q.IsLocalization W

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.inverts
code: /-- This universal property states that a functor `L : C ⥤ D` inverts morphisms
in `W` and the all functors `D ⥤ E` (for a fixed category `E`) uniquely factors
through `L`. -/
structure StrictUniversalPropertyFixedTarget where
  /-- the functor `L` inverts `W` -/
  inverts : W.IsInvertedBy L
  /-- any functor `C ⥤ E` which inverts `W` can be lifted as a functor `D ⥤ E`  -/
  lift : ∀ (F : C ⥤ E) (_ : W.IsInvertedBy F), D ⥤ E
  /-- there is a factorisation involving the lifted functor  -/
  fac : ∀ (F : C ⥤ E) (hF : W.IsInvertedBy F), L ⋙ lift F hF = F
  /-- uniqueness of the lifted functor -/
  uniq : ∀ (F₁ F₂ : D ⥤ E) (_ : L ⋙ F₁ = L ⋙ F₂), F₁ = F₂
goal: W.IsInvertedBy L

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.lift
code: /-- This universal property states that a functor `L : C ⥤ D` inverts morphisms
in `W` and the all functors `D ⥤ E` (for a fixed category `E`) uniquely factors
through `L`. -/
structure StrictUniversalPropertyFixedTarget where
  /-- the functor `L` inverts `W` -/
  inverts : W.IsInvertedBy L
  /-- any functor `C ⥤ E` which inverts `W` can be lifted as a functor `D ⥤ E`  -/
  lift : ∀ (F : C ⥤ E) (_ : W.IsInvertedBy F), D ⥤ E
  /-- there is a factorisation involving the lifted functor  -/
  fac : ∀ (F : C ⥤ E) (hF : W.IsInvertedBy F), L ⋙ lift F hF = F
  /-- uniqueness of the lifted functor -/
  uniq : ∀ (F₁ F₂ : D ⥤ E) (_ : L ⋙ F₁ = L ⋙ F₂), F₁ = F₂
goal: W.IsInvertedBy F → CategoryTheory.Functor D E

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.fac
code: /-- This universal property states that a functor `L : C ⥤ D` inverts morphisms
in `W` and the all functors `D ⥤ E` (for a fixed category `E`) uniquely factors
through `L`. -/
structure StrictUniversalPropertyFixedTarget where
  /-- the functor `L` inverts `W` -/
  inverts : W.IsInvertedBy L
  /-- any functor `C ⥤ E` which inverts `W` can be lifted as a functor `D ⥤ E`  -/
  lift : ∀ (F : C ⥤ E) (_ : W.IsInvertedBy F), D ⥤ E
  /-- there is a factorisation involving the lifted functor  -/
  fac : ∀ (F : C ⥤ E) (hF : W.IsInvertedBy F), L ⋙ lift F hF = F
  /-- uniqueness of the lifted functor -/
  uniq : ∀ (F₁ F₂ : D ⥤ E) (_ : L ⋙ F₁ = L ⋙ F₂), F₁ = F₂
goal: L.comp (self.lift F hF) = F

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.uniq
code: /-- This universal property states that a functor `L : C ⥤ D` inverts morphisms
in `W` and the all functors `D ⥤ E` (for a fixed category `E`) uniquely factors
through `L`. -/
structure StrictUniversalPropertyFixedTarget where
  /-- the functor `L` inverts `W` -/
  inverts : W.IsInvertedBy L
  /-- any functor `C ⥤ E` which inverts `W` can be lifted as a functor `D ⥤ E`  -/
  lift : ∀ (F : C ⥤ E) (_ : W.IsInvertedBy F), D ⥤ E
  /-- there is a factorisation involving the lifted functor  -/
  fac : ∀ (F : C ⥤ E) (hF : W.IsInvertedBy F), L ⋙ lift F hF = F
  /-- uniqueness of the lifted functor -/
  uniq : ∀ (F₁ F₂ : D ⥤ E) (_ : L ⋙ F₁ = L ⋙ F₂), F₁ = F₂
goal: L.comp F₁ = L.comp F₂ → F₁ = F₂

full_name: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget
code: /-- This universal property states that a functor `L : C ⥤ D` inverts morphisms
in `W` and the all functors `D ⥤ E` (for a fixed category `E`) uniquely factors
through `L`. -/
structure StrictUniversalPropertyFixedTarget where
  /-- the functor `L` inverts `W` -/
  inverts : W.IsInvertedBy L
  /-- any functor `C ⥤ E` which inverts `W` can be lifted as a functor `D ⥤ E`  -/
  lift : ∀ (F : C ⥤ E) (_ : W.IsInvertedBy F), D ⥤ E
  /-- there is a factorisation involving the lifted functor  -/
  fac : ∀ (F : C ⥤ E) (hF : W.IsInvertedBy F), L ⋙ lift F hF = F
  /-- uniqueness of the lifted functor -/
  uniq : ∀ (F₁ F₂ : D ⥤ E) (_ : L ⋙ F₁ = L ⋙ F₂), F₁ = F₂
goal: Type (max (max (max (max (max u_1 u_2) u_3) u_4) u_5) u_6)

full_name: CategoryTheory.Localization.strictUniversalPropertyFixedTargetQ_lift
code: /-- The localized category `W.Localization` that was constructed satisfies
the universal property of the localization. -/
@[simps]
def strictUniversalPropertyFixedTargetQ : StrictUniversalPropertyFixedTarget W.Q W E 
goal: (CategoryTheory.Localization.strictUniversalPropertyFixedTargetQ W E).lift G hG =
  CategoryTheory.Localization.Construction.lift G hG

full_name: CategoryTheory.Localization.strictUniversalPropertyFixedTargetQ
code: /-- The localized category `W.Localization` that was constructed satisfies
the universal property of the localization. -/
@[simps]
def strictUniversalPropertyFixedTargetQ : StrictUniversalPropertyFixedTarget W.Q W E 
goal: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget W.Q W E

full_name: CategoryTheory.Localization.instInhabitedStrictUniversalPropertyFixedTargetLocalizationQ
code: instance : Inhabited (StrictUniversalPropertyFixedTarget W.Q W E) 
goal: Inhabited (CategoryTheory.Localization.StrictUniversalPropertyFixedTarget W.Q W E)

full_name: CategoryTheory.Localization.strictUniversalPropertyFixedTargetId
code: /-- When `W` consists of isomorphisms, the identity satisfies the universal property
of the localization. -/
@[simps]
def strictUniversalPropertyFixedTargetId (hW : W ≤ MorphismProperty.isomorphisms C) :
    StrictUniversalPropertyFixedTarget (𝟭 C) W E 
goal: CategoryTheory.Localization.StrictUniversalPropertyFixedTarget (CategoryTheory.Functor.id C) W E

full_name: CategoryTheory.Localization.strictUniversalPropertyFixedTargetId_lift
code: /-- When `W` consists of isomorphisms, the identity satisfies the universal property
of the localization. -/
@[simps]
def strictUniversalPropertyFixedTargetId (hW : W ≤ MorphismProperty.isomorphisms C) :
    StrictUniversalPropertyFixedTarget (𝟭 C) W E 
goal: ∀ (x : W.IsInvertedBy F), (CategoryTheory.Localization.strictUniversalPropertyFixedTargetId W E hW).lift F x = F

full_name: CategoryTheory.Functor.IsLocalization.mk'
code: theorem IsLocalization.mk' (h₁ : Localization.StrictUniversalPropertyFixedTarget L W D)
    (h₂ : Localization.StrictUniversalPropertyFixedTarget L W W.Localization) :
    IsLocalization L W 
goal: L.IsLocalization W

full_name: CategoryTheory.Functor.IsLocalization.for_id
code: theorem IsLocalization.for_id (hW : W ≤ MorphismProperty.isomorphisms C) : (𝟭 C).IsLocalization W 
goal: (CategoryTheory.Functor.id C).IsLocalization W

full_name: CategoryTheory.Localization.inverts
code: theorem inverts : W.IsInvertedBy L 
goal: W.IsInvertedBy L

full_name: CategoryTheory.Localization.isoOfHom
code: /-- The isomorphism `L.obj X ≅ L.obj Y` that is deduced from a morphism `f : X ⟶ Y` which
belongs to `W`, when `L.IsLocalization W`. -/
@[simps! hom]
def isoOfHom {X Y : C} (f : X ⟶ Y) (hf : W f) : L.obj X ≅ L.obj Y 
goal: L.obj X ≅ L.obj Y

full_name: CategoryTheory.Localization.isoOfHom_hom
code: /-- The isomorphism `L.obj X ≅ L.obj Y` that is deduced from a morphism `f : X ⟶ Y` which
belongs to `W`, when `L.IsLocalization W`. -/
@[simps! hom]
def isoOfHom {X Y : C} (f : X ⟶ Y) (hf : W f) : L.obj X ≅ L.obj Y 
goal: (CategoryTheory.Localization.isoOfHom L W f hf).hom = L.map f

full_name: CategoryTheory.Localization.isoOfHom_hom_inv_id
code: @[reassoc (attr := simp)]
lemma isoOfHom_hom_inv_id {X Y : C} (f : X ⟶ Y) (hf : W f) :
    L.map f ≫ (isoOfHom L W f hf).inv = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (L.map f) (CategoryTheory.Localization.isoOfHom L W f hf).inv =
  CategoryTheory.CategoryStruct.id (L.obj X)

full_name: CategoryTheory.Localization.isoOfHom_inv_hom_id
code: @[reassoc (attr := simp)]
lemma isoOfHom_inv_hom_id {X Y : C} (f : X ⟶ Y) (hf : W f) :
    (isoOfHom L W f hf).inv ≫ L.map f = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.isoOfHom L W f hf).inv (L.map f) =
  CategoryTheory.CategoryStruct.id (L.obj Y)

full_name: CategoryTheory.Localization.isoOfHom_id_inv
code: @[simp]
lemma isoOfHom_id_inv (X : C) (hX : W (𝟙 X)) :
    (isoOfHom L W (𝟙 X) hX).inv = 𝟙 _ 
goal: (CategoryTheory.Localization.isoOfHom L W (CategoryTheory.CategoryStruct.id X) hX).inv =
  CategoryTheory.CategoryStruct.id (L.obj X)

full_name: CategoryTheory.Localization.Construction.wIso_eq_isoOfHom
code: lemma Construction.wIso_eq_isoOfHom {X Y : C} (f : X ⟶ Y) (hf : W f) :
    Construction.wIso f hf = isoOfHom W.Q W f hf 
goal: CategoryTheory.Localization.Construction.wIso f hf = CategoryTheory.Localization.isoOfHom W.Q W f hf

full_name: CategoryTheory.Localization.Construction.wInv_eq_isoOfHom_inv
code: lemma Construction.wInv_eq_isoOfHom_inv {X Y : C} (f : X ⟶ Y) (hf : W f) :
    Construction.wInv f hf = (isoOfHom W.Q W f hf).inv 
goal: CategoryTheory.Localization.Construction.wInv f hf = (CategoryTheory.Localization.isoOfHom W.Q W f hf).inv

full_name: CategoryTheory.Localization.instIsEquivalenceLocalizationLift
code: instance : (Localization.Construction.lift L (inverts L W)).IsEquivalence 
goal: (CategoryTheory.Localization.Construction.lift L ⋯).IsEquivalence

full_name: CategoryTheory.Localization.equivalenceFromModel
code: /-- A chosen equivalence of categories `W.Localization ≅ D` for a functor
`L : C ⥤ D` which satisfies `L.IsLocalization W`. This shall be used in
order to deduce properties of `L` from properties of `W.Q`. -/
def equivalenceFromModel : W.Localization ≌ D 
goal: W.Localization ≌ D

full_name: CategoryTheory.Localization.qCompEquivalenceFromModelFunctorIso
code: /-- Via the equivalence of categories `equivalence_from_model L W : W.localization ≌ D`,
one may identify the functors `W.Q` and `L`. -/
def qCompEquivalenceFromModelFunctorIso : W.Q ⋙ (equivalenceFromModel L W).functor ≅ L 
goal: W.Q.comp (CategoryTheory.Localization.equivalenceFromModel L W).functor ≅ L

full_name: CategoryTheory.Localization.compEquivalenceFromModelInverseIso
code: /-- Via the equivalence of categories `equivalence_from_model L W : W.localization ≌ D`,
one may identify the functors `L` and `W.Q`. -/
def compEquivalenceFromModelInverseIso : L ⋙ (equivalenceFromModel L W).inverse ≅ W.Q 
goal: L.comp (CategoryTheory.Localization.equivalenceFromModel L W).inverse ≅ W.Q

full_name: CategoryTheory.Localization.essSurj
code: theorem essSurj (W) [L.IsLocalization W] : L.EssSurj 
goal: L.EssSurj

full_name: CategoryTheory.Localization.whiskeringLeftFunctor
code: /-- The functor `(D ⥤ E) ⥤ W.functors_inverting E` induced by the composition
with a localization functor `L : C ⥤ D` with respect to `W : morphism_property C`. -/
def whiskeringLeftFunctor : (D ⥤ E) ⥤ W.FunctorsInverting E 
goal: CategoryTheory.Functor (CategoryTheory.Functor D E) (W.FunctorsInverting E)

full_name: CategoryTheory.Localization.instIsEquivalenceFunctorFunctorsInvertingWhiskeringLeftFunctor
code: instance : (whiskeringLeftFunctor L W E).IsEquivalence 
goal: (CategoryTheory.Localization.whiskeringLeftFunctor L W E).IsEquivalence

full_name: CategoryTheory.Localization.functorEquivalence
code: /-- The equivalence of categories `(D ⥤ E) ≌ (W.FunctorsInverting E)` induced by
the composition with a localization functor `L : C ⥤ D` with respect to
`W : MorphismProperty C`. -/
def functorEquivalence : D ⥤ E ≌ W.FunctorsInverting E 
goal: CategoryTheory.Functor D E ≌ W.FunctorsInverting E

full_name: CategoryTheory.Localization.whiskeringLeftFunctor'
code: /-- The functor `(D ⥤ E) ⥤ (C ⥤ E)` given by the composition with a localization
functor `L : C ⥤ D` with respect to `W : MorphismProperty C`. -/
@[nolint unusedArguments]
def whiskeringLeftFunctor' [L.IsLocalization W] (E : Type*) [Category E] :
    (D ⥤ E) ⥤ C ⥤ E 
goal: CategoryTheory.Functor (CategoryTheory.Functor D E) (CategoryTheory.Functor C E)

full_name: CategoryTheory.Localization.whiskeringLeftFunctor'_eq
code: theorem whiskeringLeftFunctor'_eq :
    whiskeringLeftFunctor' L W E = Localization.whiskeringLeftFunctor L W E ⋙ inducedFunctor _ 
goal: CategoryTheory.Localization.whiskeringLeftFunctor' L W E =
  (CategoryTheory.Localization.whiskeringLeftFunctor L W E).comp
    (CategoryTheory.inducedFunctor CategoryTheory.FullSubcategory.obj)

full_name: CategoryTheory.Localization.whiskeringLeftFunctor'_obj
code: @[simp]
theorem whiskeringLeftFunctor'_obj (F : D ⥤ E) : (whiskeringLeftFunctor' L W E).obj F = L ⋙ F 
goal: (CategoryTheory.Localization.whiskeringLeftFunctor' L W E).obj F = L.comp F

full_name: CategoryTheory.Localization.instFullFunctorWhiskeringLeftFunctor'
code: instance : (whiskeringLeftFunctor' L W E).Full 
goal: (CategoryTheory.Localization.whiskeringLeftFunctor' L W E).Full

full_name: CategoryTheory.Localization.instFaithfulFunctorWhiskeringLeftFunctor'
code: instance : (whiskeringLeftFunctor' L W E).Faithful 
goal: (CategoryTheory.Localization.whiskeringLeftFunctor' L W E).Faithful

full_name: CategoryTheory.Localization.full_whiskeringLeft
code: lemma full_whiskeringLeft (L : C ⥤ D) (W) [L.IsLocalization W] (E : Type*) [Category E] :
    ((whiskeringLeft C D E).obj L).Full 
goal: ((CategoryTheory.whiskeringLeft C D E).obj L).Full

full_name: CategoryTheory.Localization.faithful_whiskeringLeft
code: lemma faithful_whiskeringLeft (L : C ⥤ D) (W) [L.IsLocalization W] (E : Type*) [Category E] :
    ((whiskeringLeft C D E).obj L).Faithful 
goal: ((CategoryTheory.whiskeringLeft C D E).obj L).Faithful

full_name: CategoryTheory.Localization.natTrans_ext
code: theorem natTrans_ext (L : C ⥤ D) (W) [L.IsLocalization W] {F₁ F₂ : D ⥤ E} (τ τ' : F₁ ⟶ F₂)
    (h : ∀ X : C, τ.app (L.obj X) = τ'.app (L.obj X)) : τ = τ' 
goal: τ = τ'

full_name: CategoryTheory.Localization.Lifting.iso'
code: /-- When `L : C ⥤ D` is a localization functor for `W : MorphismProperty C` and
`F : C ⥤ E` is a functor, we shall say that `F' : D ⥤ E` lifts `F` if the obvious diagram
is commutative up to an isomorphism. -/
class Lifting (W : MorphismProperty C) (F : C ⥤ E) (F' : D ⥤ E) where
  /-- the isomorphism relating the localization functor and the two other given functors -/
  iso' : L ⋙ F' ≅ F
goal: L.comp F' ≅ F

full_name: CategoryTheory.Localization.Lifting
code: /-- When `L : C ⥤ D` is a localization functor for `W : MorphismProperty C` and
`F : C ⥤ E` is a functor, we shall say that `F' : D ⥤ E` lifts `F` if the obvious diagram
is commutative up to an isomorphism. -/
class Lifting (W : MorphismProperty C) (F : C ⥤ E) (F' : D ⥤ E) where
  /-- the isomorphism relating the localization functor and the two other given functors -/
  iso' : L ⋙ F' ≅ F
goal: Type (max u_1 u_6)

full_name: CategoryTheory.Localization.Lifting.iso
code: /-- The distinguished isomorphism `L ⋙ F' ≅ F` given by `[Lifting L W F F']`. -/
def Lifting.iso (F : C ⥤ E) (F' : D ⥤ E) [Lifting L W F F'] :
    L ⋙ F' ≅ F 
goal: L.comp F' ≅ F

full_name: CategoryTheory.Localization.lift
code: /-- Given a localization functor `L : C ⥤ D` for `W : MorphismProperty C` and
a functor `F : C ⥤ E` which inverts `W`, this is a choice of functor
`D ⥤ E` which lifts `F`. -/
def lift (F : C ⥤ E) (hF : W.IsInvertedBy F) (L : C ⥤ D) [L.IsLocalization W] : D ⥤ E 
goal: CategoryTheory.Functor D E

full_name: CategoryTheory.Localization.liftingLift
code: instance liftingLift (F : C ⥤ E) (hF : W.IsInvertedBy F) (L : C ⥤ D) [L.IsLocalization W] :
    Lifting L W F (lift F hF L) 
goal: CategoryTheory.Localization.Lifting L W F (CategoryTheory.Localization.lift F hF L)

full_name: CategoryTheory.Localization.fac
code: /-- The canonical isomorphism `L ⋙ lift F hF L ≅ F` for any functor `F : C ⥤ E`
which inverts `W`, when `L : C ⥤ D` is a localization functor for `W`. -/
def fac (F : C ⥤ E) (hF : W.IsInvertedBy F) (L : C ⥤ D) [L.IsLocalization W] :
    L ⋙ lift F hF L ≅ F 
goal: L.comp (CategoryTheory.Localization.lift F hF L) ≅ F

full_name: CategoryTheory.Localization.liftingConstructionLift
code: instance liftingConstructionLift (F : C ⥤ D) (hF : W.IsInvertedBy F) :
    Lifting W.Q W F (Construction.lift F hF) 
goal: CategoryTheory.Localization.Lifting W.Q W F (CategoryTheory.Localization.Construction.lift F hF)

full_name: CategoryTheory.Localization.liftNatTrans
code: /-- Given a localization functor `L : C ⥤ D` for `W : MorphismProperty C`,
if `(F₁' F₂' : D ⥤ E)` are functors which lifts functors `(F₁ F₂ : C ⥤ E)`,
a natural transformation `τ : F₁ ⟶ F₂` uniquely lifts to a natural transformation `F₁' ⟶ F₂'`. -/
def liftNatTrans (F₁ F₂ : C ⥤ E) (F₁' F₂' : D ⥤ E) [Lifting L W F₁ F₁'] [Lifting L W F₂ F₂']
    (τ : F₁ ⟶ F₂) : F₁' ⟶ F₂' 
goal: F₁' ⟶ F₂'

full_name: CategoryTheory.Localization.liftNatTrans_app
code: @[simp]
theorem liftNatTrans_app (F₁ F₂ : C ⥤ E) (F₁' F₂' : D ⥤ E) [Lifting L W F₁ F₁'] [Lifting L W F₂ F₂']
    (τ : F₁ ⟶ F₂) (X : C) :
    (liftNatTrans L W F₁ F₂ F₁' F₂' τ).app (L.obj X) =
      (Lifting.iso L W F₁ F₁').hom.app X ≫ τ.app X ≫ (Lifting.iso L W F₂ F₂').inv.app X 
goal: (CategoryTheory.Localization.liftNatTrans L W F₁ F₂ F₁' F₂' τ).app (L.obj X) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Localization.Lifting.iso L W F₁ F₁').hom.app X)
    (CategoryTheory.CategoryStruct.comp (τ.app X) ((CategoryTheory.Localization.Lifting.iso L W F₂ F₂').inv.app X))

full_name: CategoryTheory.Localization.comp_liftNatTrans
code: @[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₃' (τ ≫ τ') 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.liftNatTrans L W F₁ F₂ F₁' F₂' τ)
    (CategoryTheory.Localization.liftNatTrans L W F₂ F₃ F₂' F₃' τ') =
  CategoryTheory.Localization.liftNatTrans L W F₁ F₃ F₁' F₃' (CategoryTheory.CategoryStruct.comp τ τ')

full_name: CategoryTheory.Localization.liftNatTrans_id
code: @[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' 
goal: CategoryTheory.Localization.liftNatTrans L W F F F' F' (CategoryTheory.CategoryStruct.id F) =
  CategoryTheory.CategoryStruct.id F'

full_name: CategoryTheory.Localization.liftNatIso_inv
code: /-- Given a localization functor `L : C ⥤ D` for `W : MorphismProperty C`,
if `(F₁' F₂' : D ⥤ E)` are functors which lifts functors `(F₁ F₂ : C ⥤ E)`,
a natural isomorphism `τ : F₁ ⟶ F₂` lifts to a natural isomorphism `F₁' ⟶ F₂'`. -/
@[simps]
def liftNatIso (F₁ F₂ : C ⥤ E) (F₁' F₂' : D ⥤ E) [h₁ : Lifting L W F₁ F₁'] [h₂ : Lifting L W F₂ F₂']
    (e : F₁ ≅ F₂) : F₁' ≅ F₂' 
goal: (CategoryTheory.Localization.liftNatIso L W F₁ F₂ F₁' F₂' e).inv =
  CategoryTheory.Localization.liftNatTrans L W F₂ F₁ F₂' F₁' e.inv

full_name: CategoryTheory.Localization.liftNatIso_hom
code: /-- Given a localization functor `L : C ⥤ D` for `W : MorphismProperty C`,
if `(F₁' F₂' : D ⥤ E)` are functors which lifts functors `(F₁ F₂ : C ⥤ E)`,
a natural isomorphism `τ : F₁ ⟶ F₂` lifts to a natural isomorphism `F₁' ⟶ F₂'`. -/
@[simps]
def liftNatIso (F₁ F₂ : C ⥤ E) (F₁' F₂' : D ⥤ E) [h₁ : Lifting L W F₁ F₁'] [h₂ : Lifting L W F₂ F₂']
    (e : F₁ ≅ F₂) : F₁' ≅ F₂' 
goal: (CategoryTheory.Localization.liftNatIso L W F₁ F₂ F₁' F₂' e).hom =
  CategoryTheory.Localization.liftNatTrans L W F₁ F₂ F₁' F₂' e.hom

full_name: CategoryTheory.Localization.liftNatIso
code: /-- Given a localization functor `L : C ⥤ D` for `W : MorphismProperty C`,
if `(F₁' F₂' : D ⥤ E)` are functors which lifts functors `(F₁ F₂ : C ⥤ E)`,
a natural isomorphism `τ : F₁ ⟶ F₂` lifts to a natural isomorphism `F₁' ⟶ F₂'`. -/
@[simps]
def liftNatIso (F₁ F₂ : C ⥤ E) (F₁' F₂' : D ⥤ E) [h₁ : Lifting L W F₁ F₁'] [h₂ : Lifting L W F₂ F₂']
    (e : F₁ ≅ F₂) : F₁' ≅ F₂' 
goal: F₁' ≅ F₂'

full_name: CategoryTheory.Localization.Lifting.compRight
code: @[simps]
instance compRight {E' : Type*} [Category E'] (F : C ⥤ E) (F' : D ⥤ E) [Lifting L W F F']
    (G : E ⥤ E') : Lifting L W (F ⋙ G) (F' ⋙ G) 
goal: CategoryTheory.Localization.Lifting L W (F.comp G) (F'.comp G)

full_name: CategoryTheory.Localization.Lifting.compRight_iso'
code: @[simps]
instance compRight {E' : Type*} [Category E'] (F : C ⥤ E) (F' : D ⥤ E) [Lifting L W F F']
    (G : E ⥤ E') : Lifting L W (F ⋙ G) (F' ⋙ G) 
goal: CategoryTheory.Localization.Lifting.iso' W =
  CategoryTheory.isoWhiskerRight (CategoryTheory.Localization.Lifting.iso L W F F') G

full_name: CategoryTheory.Localization.Lifting.id_iso'
code: @[simps]
instance id : Lifting L W L (𝟭 D) 
goal: CategoryTheory.Localization.Lifting.iso' W = L.rightUnitor

full_name: CategoryTheory.Localization.Lifting.id
code: @[simps]
instance id : Lifting L W L (𝟭 D) 
goal: CategoryTheory.Localization.Lifting L W L (CategoryTheory.Functor.id D)

full_name: CategoryTheory.Localization.Lifting.compLeft
code: @[simps]
instance compLeft (F : D ⥤ E) : Localization.Lifting L W (L ⋙ F) F 
goal: CategoryTheory.Localization.Lifting L W (L.comp F) F

full_name: CategoryTheory.Localization.Lifting.compLeft_iso'
code: @[simps]
instance compLeft (F : D ⥤ E) : Localization.Lifting L W (L ⋙ F) F 
goal: CategoryTheory.Localization.Lifting.iso' W = CategoryTheory.Iso.refl (L.comp F)

full_name: CategoryTheory.Localization.Lifting.compLeft_iso
code: @[simp]
lemma compLeft_iso (W) (F : D ⥤ E) : Localization.Lifting.iso L W (L ⋙ F) F = Iso.refl _ 
goal: CategoryTheory.Localization.Lifting.iso L W (L.comp F) F = CategoryTheory.Iso.refl (L.comp F)

full_name: CategoryTheory.Localization.Lifting.ofIsos_iso'
code: /-- Given a localization functor `L : C ⥤ D` for `W : MorphismProperty C`,
if `F₁' : D ⥤ E` lifts a functor `F₁ : C ⥤ D`, then a functor `F₂'` which
is isomorphic to `F₁'` also lifts a functor `F₂` that is isomorphic to `F₁`.  -/
@[simps]
def ofIsos {F₁ F₂ : C ⥤ E} {F₁' F₂' : D ⥤ E} (e : F₁ ≅ F₂) (e' : F₁' ≅ F₂') [Lifting L W F₁ F₁'] :
    Lifting L W F₂ F₂' 
goal: CategoryTheory.Localization.Lifting.iso' W =
  CategoryTheory.isoWhiskerLeft L e'.symm ≪≫ CategoryTheory.Localization.Lifting.iso L W F₁ F₁' ≪≫ e

full_name: CategoryTheory.Localization.Lifting.ofIsos
code: /-- Given a localization functor `L : C ⥤ D` for `W : MorphismProperty C`,
if `F₁' : D ⥤ E` lifts a functor `F₁ : C ⥤ D`, then a functor `F₂'` which
is isomorphic to `F₁'` also lifts a functor `F₂` that is isomorphic to `F₁`.  -/
@[simps]
def ofIsos {F₁ F₂ : C ⥤ E} {F₁' F₂' : D ⥤ E} (e : F₁ ≅ F₂) (e' : F₁' ≅ F₂') [Lifting L W F₁ F₁'] :
    Lifting L W F₂ F₂' 
goal: CategoryTheory.Localization.Lifting L W F₂ F₂'

full_name: CategoryTheory.Functor.IsLocalization.of_iso
code: theorem of_iso {L₁ L₂ : C ⥤ D} (e : L₁ ≅ L₂) [L₁.IsLocalization W] : L₂.IsLocalization W 
goal: L₂.IsLocalization W

full_name: CategoryTheory.Functor.IsLocalization.of_equivalence_target
code: /-- 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 
goal: L'.IsLocalization W

full_name: CategoryTheory.Functor.IsLocalization.instCompOfIsEquivalence
code: instance (F : D ⥤ E) [F.IsEquivalence] [L.IsLocalization W] :
    (L ⋙ F).IsLocalization W 
goal: (L.comp F).IsLocalization W

full_name: CategoryTheory.Functor.IsLocalization.of_isEquivalence
code: lemma of_isEquivalence (L : C ⥤ D) (W : MorphismProperty C)
    (hW : W ≤ MorphismProperty.isomorphisms C) [IsEquivalence L] :
    L.IsLocalization W 
goal: L.IsLocalization W

full_name: CategoryTheory.Localization.uniq
code: /-- If `L₁ : C ⥤ D₁` and `L₂ : C ⥤ D₂` are two localization functors for the
same `MorphismProperty C`, this is an equivalence of categories `D₁ ≌ D₂`. -/
def uniq : D₁ ≌ D₂ 
goal: D₁ ≌ D₂

full_name: CategoryTheory.Localization.uniq_symm
code: lemma uniq_symm : (uniq L₁ L₂ W').symm = uniq L₂ L₁ W' 
goal: (CategoryTheory.Localization.uniq L₁ L₂ W').symm = CategoryTheory.Localization.uniq L₂ L₁ W'

full_name: CategoryTheory.Localization.compUniqFunctor
code: /-- The functor of equivalence of localized categories given by `Localization.uniq` is
compatible with the localization functors. -/
def compUniqFunctor : L₁ ⋙ (uniq L₁ L₂ W').functor ≅ L₂ 
goal: L₁.comp (CategoryTheory.Localization.uniq L₁ L₂ W').functor ≅ L₂

full_name: CategoryTheory.Localization.compUniqInverse
code: /-- The inverse functor of equivalence of localized categories given by `Localization.uniq` is
compatible with the localization functors. -/
def compUniqInverse : L₂ ⋙ (uniq L₁ L₂ W').inverse ≅ L₁ 
goal: L₂.comp (CategoryTheory.Localization.uniq L₁ L₂ W').inverse ≅ L₁

full_name: CategoryTheory.Localization.instLiftingFunctorUniq
code: instance : Lifting L₁ W' L₂ (uniq L₁ L₂ W').functor 
goal: CategoryTheory.Localization.Lifting L₁ W' L₂ (CategoryTheory.Localization.uniq L₁ L₂ W').functor

full_name: CategoryTheory.Localization.instLiftingInverseUniq
code: instance : Lifting L₂ W' L₁ (uniq L₁ L₂ W').inverse 
goal: CategoryTheory.Localization.Lifting L₂ W' L₁ (CategoryTheory.Localization.uniq L₁ L₂ W').inverse

full_name: CategoryTheory.Localization.isoUniqFunctor
code: /-- If `L₁ : C ⥤ D₁` and `L₂ : C ⥤ D₂` are two localization functors for the
same `MorphismProperty C`, any functor `F : D₁ ⥤ D₂` equipped with an isomorphism
`L₁ ⋙ F ≅ L₂` is isomorphic to the functor of the equivalence given by `uniq`. -/
def isoUniqFunctor (F : D₁ ⥤ D₂) (e : L₁ ⋙ F ≅ L₂) :
    F ≅ (uniq L₁ L₂ W').functor 
goal: F ≅ (CategoryTheory.Localization.uniq L₁ L₂ W').functor

full_name: CategoryTheory.AreEqualizedByLocalization
code: /-- The property that two morphisms become equal in the localized category. -/
def AreEqualizedByLocalization : Prop 
goal: Prop

full_name: CategoryTheory.areEqualizedByLocalization_iff
code: lemma areEqualizedByLocalization_iff [L.IsLocalization W] :
    AreEqualizedByLocalization W f g ↔ L.map f = L.map g 
goal: CategoryTheory.AreEqualizedByLocalization W f g ↔ L.map f = L.map g

full_name: CategoryTheory.AreEqualizedByLocalization.mk
code: lemma mk (L : C ⥤ D) [L.IsLocalization W] (h : L.map f = L.map g) :
    AreEqualizedByLocalization W f g 
goal: CategoryTheory.AreEqualizedByLocalization W f g

full_name: CategoryTheory.AreEqualizedByLocalization.map_eq
code: lemma map_eq (h : AreEqualizedByLocalization W f g) (L : C ⥤ D) [L.IsLocalization W] :
    L.map f = L.map g 
goal: L.map f = L.map g