File: Mathlib/CategoryTheory/Localization/SmallShiftedHom.lean

full_name: CategoryTheory.Localization.HasSmallLocalizedShiftedHom
code: /-- Given objects `X` and `Y` in a category `C`, this is the property that
all the types of morphisms from `X⟦a⟧` to `Y⟦b⟧` are `w`-small
in the localized category with respect to a class of morphisms `W`. -/
abbrev HasSmallLocalizedShiftedHom : Prop 
goal: Prop

full_name: CategoryTheory.Localization.hasSmallLocalizedShiftedHom_iff
code: lemma hasSmallLocalizedShiftedHom_iff
    (L : C ⥤ D) [L.IsLocalization W] [L.CommShift M] (X Y : C) :
    HasSmallLocalizedShiftedHom.{w} W M X Y ↔
      ∀ (a b : M), Small.{w} ((L.obj X)⟦a⟧ ⟶ (L.obj Y)⟦b⟧) 
goal: CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M X Y ↔
  ∀ (a b : M),
    Small.{w, v₂} ((CategoryTheory.shiftFunctor D a).obj (L.obj X) ⟶ (CategoryTheory.shiftFunctor D b).obj (L.obj Y))

full_name: CategoryTheory.Localization.hasSmallLocalizedHom_of_hasSmallLocalizedShiftedHom₀
code: lemma hasSmallLocalizedHom_of_hasSmallLocalizedShiftedHom₀ :
    HasSmallLocalizedHom.{w} W X Y 
goal: CategoryTheory.Localization.HasSmallLocalizedHom W X Y

full_name: CategoryTheory.Localization.instHasSmallLocalizedHomObjShiftFunctor
code: instance (m : M) : HasSmallLocalizedHom.{w} W X (Y⟦m⟧) 
goal: CategoryTheory.Localization.HasSmallLocalizedHom W X ((CategoryTheory.shiftFunctor C m).obj Y)

full_name: CategoryTheory.Localization.instHasSmallLocalizedHomObjShiftFunctor_1
code: instance (m : M) : HasSmallLocalizedHom.{w} W (X⟦m⟧) Y 
goal: CategoryTheory.Localization.HasSmallLocalizedHom W ((CategoryTheory.shiftFunctor C m).obj X) Y

full_name: CategoryTheory.Localization.instHasSmallLocalizedHomObjShiftFunctor_2
code: instance (m m' n : M) : HasSmallLocalizedHom.{w} W (X⟦m⟧⟦m'⟧) (Y⟦n⟧) 
goal: CategoryTheory.Localization.HasSmallLocalizedHom W
  ((CategoryTheory.shiftFunctor C m').obj ((CategoryTheory.shiftFunctor C m).obj X))
  ((CategoryTheory.shiftFunctor C n).obj Y)

full_name: CategoryTheory.Localization.instHasSmallLocalizedHomObjShiftFunctor_3
code: instance (m n n' : M) : HasSmallLocalizedHom.{w} W (X⟦m⟧) (Y⟦n⟧⟦n'⟧) 
goal: CategoryTheory.Localization.HasSmallLocalizedHom W ((CategoryTheory.shiftFunctor C m).obj X)
  ((CategoryTheory.shiftFunctor C n').obj ((CategoryTheory.shiftFunctor C n).obj Y))

full_name: CategoryTheory.Localization.SmallHom.shift
code: /-- Given `f : SmallHom W X Y` and `a : M`, this is the element
in `SmallHom W (X⟦a⟧) (Y⟦a⟧)` obtained by shifting by `a`. -/
noncomputable def shift : SmallHom.{w} W (X⟦a⟧) (Y⟦a⟧) 
goal: CategoryTheory.Localization.SmallHom W ((CategoryTheory.shiftFunctor C a).obj X)
  ((CategoryTheory.shiftFunctor C a).obj Y)

full_name: CategoryTheory.Localization.SmallHom.equiv_shift
code: lemma equiv_shift : equiv W L (f.shift a) =
    (L.commShiftIso a).hom.app X ≫ (equiv W L f)⟦a⟧' ≫ (L.commShiftIso a).inv.app Y 
goal: (CategoryTheory.Localization.SmallHom.equiv W L) (f.shift a) =
  CategoryTheory.CategoryStruct.comp ((L.commShiftIso a).hom.app X)
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.shiftFunctor D a).map ((CategoryTheory.Localization.SmallHom.equiv W L) f))
      ((L.commShiftIso a).inv.app Y))

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

full_name: CategoryTheory.Localization.SmallShiftedHom.shift
code: /-- Given `f : SmallShiftedHom.{w} W X Y a`, this is the element in
`SmallHom.{w} W (X⟦n⟧) (Y⟦a'⟧)` that is obtained by shifting by `n`
when `a + n = a'`. -/
noncomputable def shift {a : M} [HasSmallLocalizedShiftedHom.{w} W M X Y]
    [HasSmallLocalizedShiftedHom.{w} W M Y Y]
  (f : SmallShiftedHom.{w} W X Y a) (n a' : M) (h : a + n = a') :
    SmallHom.{w} W (X⟦n⟧) (Y⟦a'⟧) 
goal: CategoryTheory.Localization.SmallHom W ((CategoryTheory.shiftFunctor C n).obj X)
  ((CategoryTheory.shiftFunctor C a').obj Y)

full_name: CategoryTheory.Localization.SmallShiftedHom.comp
code: /-- The composition on `SmallShiftedHom W`. -/
noncomputable def comp {a b c : M} [HasSmallLocalizedShiftedHom.{w} W M X Y]
    [HasSmallLocalizedShiftedHom.{w} W M Y Z] [HasSmallLocalizedShiftedHom.{w} W M X Z]
    [HasSmallLocalizedShiftedHom.{w} W M Z Z]
    (f : SmallShiftedHom.{w} W X Y a) (g : SmallShiftedHom.{w} W Y Z b) (h : b + a = c) :
    SmallShiftedHom.{w} W X Z c 
goal: CategoryTheory.Localization.SmallShiftedHom W X Z c

full_name: CategoryTheory.Localization.SmallShiftedHom.mk₀
code: /-- The canonical map `(X ⟶ Y) → SmallShiftedHom.{w} W X Y m₀` when `m₀ = 0` and
`[HasSmallLocalizedShiftedHom.{w} W M X Y]` holds. -/
noncomputable def mk₀ [HasSmallLocalizedShiftedHom.{w} W M X Y]
    (m₀ : M) (hm₀ : m₀ = 0) (f : X ⟶ Y) :
    SmallShiftedHom.{w} W X Y m₀ 
goal: CategoryTheory.Localization.SmallShiftedHom W X Y m₀

full_name: CategoryTheory.Localization.SmallShiftedHom.equiv
code: /-- The bijection `SmallShiftedHom.{w} W X Y m ≃ ShiftedHom (L.obj X) (L.obj Y) m`
for all `m : M`, and `X` and `Y` in `C` when `L : C ⥤ D` is a localization functor for
`W : MorphismProperty C` such that the category `D` is equipped with a shift by `M`
and `L` commutes with the shifts. -/
noncomputable def equiv [HasSmallLocalizedShiftedHom.{w} W M X Y] {m : M} :
    SmallShiftedHom.{w} W X Y m ≃ ShiftedHom (L.obj X) (L.obj Y) m 
goal: CategoryTheory.Localization.SmallShiftedHom W X Y m ≃ CategoryTheory.ShiftedHom (L.obj X) (L.obj Y) m

full_name: CategoryTheory.Localization.SmallShiftedHom.equiv_shift'
code: lemma equiv_shift' {a : M} [HasSmallLocalizedShiftedHom.{w} W M X Y]
    [HasSmallLocalizedShiftedHom.{w} W M Y Y]
    (f : SmallShiftedHom.{w} W X Y a) (n a' : M) (h : a + n = a') :
    SmallHom.equiv W L (f.shift n a' h) = (L.commShiftIso n).hom.app X ≫
      (SmallHom.equiv W L f)⟦n⟧' ≫ ((L.commShiftIso a).hom.app Y)⟦n⟧' ≫
        (shiftFunctorAdd' D a n a' h).inv.app (L.obj Y) ≫ (L.commShiftIso a').inv.app Y 
goal: (CategoryTheory.Localization.SmallHom.equiv W L) (f.shift n a' h) =
  CategoryTheory.CategoryStruct.comp ((L.commShiftIso n).hom.app X)
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.shiftFunctor D n).map ((CategoryTheory.Localization.SmallHom.equiv W L) f))
      (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D n).map ((L.commShiftIso a).hom.app Y))
        (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd' D a n a' h).inv.app (L.obj Y))
          ((L.commShiftIso a').inv.app Y))))

full_name: CategoryTheory.Localization.SmallShiftedHom.equiv_shift
code: lemma equiv_shift {a : M} [HasSmallLocalizedShiftedHom.{w} W M X Y]
    [HasSmallLocalizedShiftedHom.{w} W M Y Y]
    (f : SmallShiftedHom.{w} W X Y a) (n a' : M) (h : a + n = a') :
    equiv W L (f.shift n a' h) = (L.commShiftIso n).hom.app X ≫ (equiv W L f)⟦n⟧' ≫
      (shiftFunctorAdd' D a n a' h).inv.app (L.obj Y) 
goal: (CategoryTheory.Localization.SmallShiftedHom.equiv W L) (f.shift n a' h) =
  CategoryTheory.CategoryStruct.comp ((L.commShiftIso n).hom.app X)
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.shiftFunctor D n).map ((CategoryTheory.Localization.SmallShiftedHom.equiv W L) f))
      ((CategoryTheory.shiftFunctorAdd' D a n a' h).inv.app (L.obj Y)))

full_name: CategoryTheory.Localization.SmallShiftedHom.equiv_comp
code: lemma equiv_comp [HasSmallLocalizedShiftedHom.{w} W M X Y]
    [HasSmallLocalizedShiftedHom.{w} W M Y Z] [HasSmallLocalizedShiftedHom.{w} W M X Z]
    [HasSmallLocalizedShiftedHom.{w} W M Z Z] {a b c : M}
    (f : SmallShiftedHom.{w} W X Y a) (g : SmallShiftedHom.{w} W Y Z b) (h : b + a = c) :
    equiv W L (f.comp g h) = (equiv W L f).comp (equiv W L g) h 
goal: (CategoryTheory.Localization.SmallShiftedHom.equiv W L) (f.comp g h) =
  ((CategoryTheory.Localization.SmallShiftedHom.equiv W L) f).comp
    ((CategoryTheory.Localization.SmallShiftedHom.equiv W L) g) h

full_name: CategoryTheory.Localization.SmallShiftedHom.equiv_mk₀
code: @[simp]
lemma equiv_mk₀ [HasSmallLocalizedShiftedHom.{w} W M X Y]
    (m₀ : M) (hm₀ : m₀ = 0) (f : X ⟶ Y) :
    equiv W L (SmallShiftedHom.mk₀ W m₀ hm₀ f) =
      ShiftedHom.mk₀ m₀ hm₀ (L.map f) 
goal: (CategoryTheory.Localization.SmallShiftedHom.equiv W L) (CategoryTheory.Localization.SmallShiftedHom.mk₀ W m₀ hm₀ f) =
  CategoryTheory.ShiftedHom.mk₀ m₀ hm₀ (L.map f)

full_name: CategoryTheory.Localization.SmallShiftedHom.comp_assoc
code: lemma comp_assoc {X Y Z T : C} {a₁ a₂ a₃ a₁₂ a₂₃ a : M}
    [HasSmallLocalizedShiftedHom.{w} W M X Y] [HasSmallLocalizedShiftedHom.{w} W M X Z]
    [HasSmallLocalizedShiftedHom.{w} W M X T] [HasSmallLocalizedShiftedHom.{w} W M Y Z]
    [HasSmallLocalizedShiftedHom.{w} W M Y T] [HasSmallLocalizedShiftedHom.{w} W M Z T]
    [HasSmallLocalizedShiftedHom.{w} W M Z Z] [HasSmallLocalizedShiftedHom.{w} W M T T]
    (α : SmallShiftedHom.{w} W X Y a₁) (β : SmallShiftedHom.{w} W Y Z a₂)
    (γ : SmallShiftedHom.{w} W Z T a₃)
    (h₁₂ : a₂ + a₁ = a₁₂) (h₂₃ : a₃ + a₂ = a₂₃) (h : a₃ + a₂ + a₁ = a) :
    (α.comp β h₁₂).comp γ (show a₃ + a₁₂ = a by rw [← h₁₂, ← add_assoc, h]) =
      α.comp (β.comp γ h₂₃) (by rw [← h₂₃, h]) 
goal: (α.comp β h₁₂).comp γ ⋯ = α.comp (β.comp γ h₂₃) ⋯