File: Mathlib/CategoryTheory/Localization/SmallHom.lean

full_name: CategoryTheory.Localization.HasSmallLocalizedHom.small
code: /-- This property holds if the type of morphisms between `X` and `Y`
in the localized category with respect to `W : MorphismProperty C`
is small. -/
class HasSmallLocalizedHom : Prop where
  small : Small.{w} (W.Q.obj X ⟶ W.Q.obj Y)
goal: Small.{w, max u₁ v₁} (W.Q.obj X ⟶ W.Q.obj Y)

full_name: CategoryTheory.Localization.HasSmallLocalizedHom
code: /-- This property holds if the type of morphisms between `X` and `Y`
in the localized category with respect to `W : MorphismProperty C`
is small. -/
class HasSmallLocalizedHom : Prop where
  small : Small.{w} (W.Q.obj X ⟶ W.Q.obj Y)
goal: Prop

full_name: CategoryTheory.Localization.hasSmallLocalizedHom_iff
code: lemma hasSmallLocalizedHom_iff :
    HasSmallLocalizedHom.{w} W X Y ↔ Small.{w} (L.obj X ⟶ L.obj Y) 
goal: CategoryTheory.Localization.HasSmallLocalizedHom W X Y ↔ Small.{w, v₂} (L.obj X ⟶ L.obj Y)

full_name: CategoryTheory.Localization.hasSmallLocalizedHom_of_isLocalization
code: lemma hasSmallLocalizedHom_of_isLocalization :
    HasSmallLocalizedHom.{v₂} W X Y 
goal: CategoryTheory.Localization.HasSmallLocalizedHom W X Y

full_name: CategoryTheory.Localization.small_of_hasSmallLocalizedHom
code: lemma small_of_hasSmallLocalizedHom [HasSmallLocalizedHom.{w} W X Y] :
    Small.{w} (L.obj X ⟶ L.obj Y) 
goal: Small.{w, v₂} (L.obj X ⟶ L.obj Y)

full_name: CategoryTheory.Localization.hasSmallLocalizedHom_iff_of_isos
code: lemma hasSmallLocalizedHom_iff_of_isos {X' Y' : C} (e : X ≅ X') (e' : Y ≅ Y') :
    HasSmallLocalizedHom.{w} W X Y ↔ HasSmallLocalizedHom.{w} W X' Y' 
goal: CategoryTheory.Localization.HasSmallLocalizedHom W X Y ↔ CategoryTheory.Localization.HasSmallLocalizedHom W X' Y'

full_name: CategoryTheory.Localization.SmallHom
code: /-- The type of morphisms from `X` to `Y` in the localized category
with respect to `W : MorphismProperty C` that is shrunk to `Type w`
when `HasSmallLocalizedHom.{w} W X Y` holds. -/
def SmallHom (X Y : C) [HasSmallLocalizedHom.{w} W X Y] : Type w 
goal: Type w

full_name: CategoryTheory.Localization.SmallHom.equiv
code: /-- The canonical bijection `SmallHom.{w} W X Y ≃ (L.obj X ⟶ L.obj Y)`
when `L` is a localization functor for `W : MorphismProperty C` and
that `HasSmallLocalizedHom.{w} W X Y` holds. -/
noncomputable def equiv (L : C ⥤ D) [L.IsLocalization W] {X Y : C}
    [HasSmallLocalizedHom.{w} W X Y] :
    SmallHom.{w} W X Y ≃ (L.obj X ⟶ L.obj Y) 
goal: CategoryTheory.Localization.SmallHom W X Y ≃ (L.obj X ⟶ L.obj Y)

full_name: CategoryTheory.Localization.SmallHom.equiv_equiv_symm
code: lemma equiv_equiv_symm (L : C ⥤ D) [L.IsLocalization W]
    (L' : C ⥤ D') [L'.IsLocalization W] (G : D ⥤ D')
    (e : L ⋙ G ≅ L') {X Y : C} [HasSmallLocalizedHom.{w} W X Y]
    (f : L.obj X ⟶ L.obj Y) :
    equiv W L' ((equiv W L).symm f) =
      e.inv.app X ≫ G.map f ≫ e.hom.app Y 
goal: (CategoryTheory.Localization.SmallHom.equiv W L') ((CategoryTheory.Localization.SmallHom.equiv W L).symm f) =
  CategoryTheory.CategoryStruct.comp (e.inv.app X) (CategoryTheory.CategoryStruct.comp (G.map f) (e.hom.app Y))

full_name: CategoryTheory.Localization.SmallHom.mk
code: /-- The element in `SmallHom W X Y` induced by `f : X ⟶ Y`. -/
noncomputable def mk {X Y : C} [HasSmallLocalizedHom.{w} W X Y] (f : X ⟶ Y) :
    SmallHom.{w} W X Y 
goal: CategoryTheory.Localization.SmallHom W X Y

full_name: CategoryTheory.Localization.SmallHom.equiv_mk
code: @[simp]
lemma equiv_mk (L : C ⥤ D) [L.IsLocalization W] {X Y : C}
    [HasSmallLocalizedHom.{w} W X Y] (f : X ⟶ Y) :
    equiv.{w} W L (mk W f) = L.map f 
goal: (CategoryTheory.Localization.SmallHom.equiv W L) (CategoryTheory.Localization.SmallHom.mk W f) = L.map f

full_name: CategoryTheory.Localization.SmallHom.mkInv
code: /-- The formal inverse in `SmallHom W X Y` of a morphism `f : Y ⟶ X` such that `W f`. -/
noncomputable def mkInv {X Y : C} (f : Y ⟶ X) (hf : W f) [HasSmallLocalizedHom.{w} W X Y] :
    SmallHom.{w} W X Y 
goal: CategoryTheory.Localization.SmallHom W X Y

full_name: CategoryTheory.Localization.SmallHom.equiv_mkInv
code: @[simp]
lemma equiv_mkInv (L : C ⥤ D) [L.IsLocalization W] {X Y : C} (f : Y ⟶ X) (hf : W f)
    [HasSmallLocalizedHom.{w} W X Y] :
    equiv.{w} W L (mkInv f hf) = (Localization.isoOfHom L W f hf).inv 
goal: (CategoryTheory.Localization.SmallHom.equiv W L) (CategoryTheory.Localization.SmallHom.mkInv f hf) =
  (CategoryTheory.Localization.isoOfHom L W f hf).inv

full_name: CategoryTheory.Localization.SmallHom.comp
code: /-- The composition on `SmallHom W`. -/
noncomputable def comp {X Y Z : C} [HasSmallLocalizedHom.{w} W X Y]
    [HasSmallLocalizedHom.{w} W Y Z] [HasSmallLocalizedHom.{w} W X Z]
    (α : SmallHom.{w} W X Y) (β : SmallHom.{w} W Y Z) :
    SmallHom.{w} W X Z 
goal: CategoryTheory.Localization.SmallHom W X Z

full_name: CategoryTheory.Localization.SmallHom.equiv_comp
code: lemma equiv_comp (L : C ⥤ D) [L.IsLocalization W] {X Y Z : C} [HasSmallLocalizedHom.{w} W X Y]
    [HasSmallLocalizedHom.{w} W Y Z] [HasSmallLocalizedHom.{w} W X Z]
    (α : SmallHom.{w} W X Y) (β : SmallHom.{w} W Y Z) :
    equiv W L (α.comp β) = equiv W L α ≫ equiv W L β 
goal: (CategoryTheory.Localization.SmallHom.equiv W L) (α.comp β) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Localization.SmallHom.equiv W L) α)
    ((CategoryTheory.Localization.SmallHom.equiv W L) β)

full_name: CategoryTheory.Localization.SmallHom.mk_comp_mk
code: lemma mk_comp_mk [HasSmallLocalizedHom.{w} W X Y] [HasSmallLocalizedHom.{w} W Y Z]
    [HasSmallLocalizedHom.{w} W X Z] (f : X ⟶ Y) (g : Y ⟶ Z) :
    (mk W f).comp (mk W g) = mk W (f ≫ g) 
goal: (CategoryTheory.Localization.SmallHom.mk W f).comp (CategoryTheory.Localization.SmallHom.mk W g) =
  CategoryTheory.Localization.SmallHom.mk W (CategoryTheory.CategoryStruct.comp f g)

full_name: CategoryTheory.Localization.SmallHom.comp_mk_id
code: @[simp]
lemma comp_mk_id [HasSmallLocalizedHom.{w} W X Y] [HasSmallLocalizedHom.{w} W Y Y]
    (α : SmallHom.{w} W X Y)  :
    α.comp (mk W (𝟙 Y)) = α 
goal: α.comp (CategoryTheory.Localization.SmallHom.mk W (CategoryTheory.CategoryStruct.id Y)) = α

full_name: CategoryTheory.Localization.SmallHom.mk_id_comp
code: @[simp]
lemma mk_id_comp [HasSmallLocalizedHom.{w} W X Y] [HasSmallLocalizedHom.{w} W X X]
    (α : SmallHom.{w} W X Y) :
    (mk W (𝟙 X)).comp α = α 
goal: (CategoryTheory.Localization.SmallHom.mk W (CategoryTheory.CategoryStruct.id X)).comp α = α

full_name: CategoryTheory.Localization.SmallHom.comp_assoc
code: @[simp]
lemma comp_assoc [HasSmallLocalizedHom.{w} W X Y] [HasSmallLocalizedHom.{w} W X Z]
    [HasSmallLocalizedHom.{w} W X T] [HasSmallLocalizedHom.{w} W Y Z]
    [HasSmallLocalizedHom.{w} W Y T] [HasSmallLocalizedHom.{w} W Z T]
    (α : SmallHom.{w} W X Y) (β : SmallHom.{w} W Y Z) (γ : SmallHom.{w} W Z T) :
    (α.comp β).comp γ = α.comp (β.comp γ) 
goal: (α.comp β).comp γ = α.comp (β.comp γ)

full_name: CategoryTheory.Localization.SmallHom.mk_comp_mkInv
code: @[simp]
lemma mk_comp_mkInv [HasSmallLocalizedHom.{w} W X Y] [HasSmallLocalizedHom.{w} W Y X]
    [HasSmallLocalizedHom.{w} W Y Y] (f : Y ⟶ X) (hf : W f) :
    (mk W f).comp (mkInv f hf) = mk W (𝟙 Y) 
goal: (CategoryTheory.Localization.SmallHom.mk W f).comp (CategoryTheory.Localization.SmallHom.mkInv f hf) =
  CategoryTheory.Localization.SmallHom.mk W (CategoryTheory.CategoryStruct.id Y)

full_name: CategoryTheory.Localization.SmallHom.mkInv_comp_mk
code: @[simp]
lemma mkInv_comp_mk [HasSmallLocalizedHom.{w} W X X] [HasSmallLocalizedHom.{w} W X Y]
    [HasSmallLocalizedHom.{w} W Y X] (f : Y ⟶ X) (hf : W f) :
    (mkInv f hf).comp (mk W f) = mk W (𝟙 X) 
goal: (CategoryTheory.Localization.SmallHom.mkInv f hf).comp (CategoryTheory.Localization.SmallHom.mk W f) =
  CategoryTheory.Localization.SmallHom.mk W (CategoryTheory.CategoryStruct.id X)

full_name: CategoryTheory.LocalizerMorphism.smallHomMap
code: /-- The action of a localizer morphism on `SmallHom`. -/
noncomputable def smallHomMap (f : SmallHom.{w} W₁ X Y) :
    SmallHom.{w'} W₂ (Φ.functor.obj X) (Φ.functor.obj Y) 
goal: CategoryTheory.Localization.SmallHom W₂ (Φ.functor.obj X) (Φ.functor.obj Y)

full_name: CategoryTheory.LocalizerMorphism.equiv_smallHomMap
code: lemma equiv_smallHomMap (G : D₁ ⥤ D₂) (e : Φ.functor ⋙ L₂ ≅ L₁ ⋙ G)
    (f : SmallHom.{w} W₁ X Y) :
    (SmallHom.equiv W₂ L₂) (Φ.smallHomMap f) =
      e.hom.app X ≫ G.map (SmallHom.equiv W₁ L₁ f) ≫ e.inv.app Y 
goal: (CategoryTheory.Localization.SmallHom.equiv W₂ L₂) (Φ.smallHomMap f) =
  CategoryTheory.CategoryStruct.comp (e.hom.app X)
    (CategoryTheory.CategoryStruct.comp (G.map ((CategoryTheory.Localization.SmallHom.equiv W₁ L₁) f)) (e.inv.app Y))

full_name: CategoryTheory.LocalizerMorphism.smallHomMap_comp
code: lemma smallHomMap_comp (f : SmallHom.{w} W₁ X Y) (g : SmallHom.{w} W₁ Y Z) :
    Φ.smallHomMap (f.comp g) = (Φ.smallHomMap f).comp (Φ.smallHomMap g) 
goal: Φ.smallHomMap (f.comp g) = (Φ.smallHomMap f).comp (Φ.smallHomMap g)