File: Mathlib/CategoryTheory/Shift/Localization.lean

full_name: CategoryTheory.MorphismProperty.IsCompatibleWithShift
code: /-- A morphism property `W` on a category `C` is compatible with the shift by a
monoid `A` when for all `a : A`, a morphism `f` belongs to `W`
if and only if `f⟦a⟧'` does. -/
class IsCompatibleWithShift : Prop :=
  /-- the condition that for all `a : A`, the morphism property `W` is not changed when
  we take its inverse image by the shift functor by `a` -/
  condition : ∀ (a : A), W.inverseImage (shiftFunctor C a) = W
goal: Prop

full_name: CategoryTheory.MorphismProperty.IsCompatibleWithShift.condition
code: /-- A morphism property `W` on a category `C` is compatible with the shift by a
monoid `A` when for all `a : A`, a morphism `f` belongs to `W`
if and only if `f⟦a⟧'` does. -/
class IsCompatibleWithShift : Prop :=
  /-- the condition that for all `a : A`, the morphism property `W` is not changed when
  we take its inverse image by the shift functor by `a` -/
  condition : ∀ (a : A), W.inverseImage (shiftFunctor C a) = W
goal: W.inverseImage (CategoryTheory.shiftFunctor C a) = W

full_name: CategoryTheory.MorphismProperty.IsCompatibleWithShift.iff
code: lemma iff {X Y : C} (f : X ⟶ Y) (a : A) : W (f⟦a⟧') ↔ W f 
goal: W ((CategoryTheory.shiftFunctor C a).map f) ↔ W f

full_name: CategoryTheory.MorphismProperty.IsCompatibleWithShift.shiftFunctor_comp_inverts
code: lemma shiftFunctor_comp_inverts (a : A) :
    W.IsInvertedBy (shiftFunctor C a ⋙ L) 
goal: W.IsInvertedBy ((CategoryTheory.shiftFunctor C a).comp L)

full_name: CategoryTheory.MorphismProperty.shiftLocalizerMorphism
code: /-- The morphism of localizer from `W` to `W` given by the functor `shiftFunctor C a`
when `a : A` and `W` is compatible with the shift by `A`. -/
abbrev shiftLocalizerMorphism (a : A) : LocalizerMorphism W W 
goal: CategoryTheory.LocalizerMorphism W W

full_name: CategoryTheory.HasShift.localized
code: /-- When `L : C ⥤ D` is a localization functor with respect to a morphism property `W`
that is compatible with the shift by a monoid `A` on `C`, this is the induced
shift on the category `D`. -/
noncomputable def HasShift.localized : HasShift D A 
goal: CategoryTheory.HasShift D A

full_name: CategoryTheory.Functor.CommShift.localized
code: /-- The localization functor `L : C ⥤ D` is compatible with the shift. -/
@[nolint unusedHavesSuffices]
noncomputable def Functor.CommShift.localized :
    @Functor.CommShift _ _ _ _ L A _ _ (HasShift.localized L W A) 
goal: L.CommShift A

full_name: CategoryTheory.HasShift.localization
code: /-- The localized category `W.Localization` is endowed with the induced shift.  -/
noncomputable instance HasShift.localization :
    HasShift W.Localization A 
goal: CategoryTheory.HasShift W.Localization A

full_name: CategoryTheory.MorphismProperty.commShift_Q
code: /-- The localization functor `W.Q : C ⥤ W.Localization` is compatible with the shift. -/
noncomputable instance MorphismProperty.commShift_Q :
    W.Q.CommShift A 
goal: W.Q.CommShift A

full_name: CategoryTheory.HasShift.localization'
code: /-- The localized category `W.Localization'` is endowed with the induced shift.  -/
noncomputable instance HasShift.localization' :
    HasShift W.Localization' A 
goal: CategoryTheory.HasShift W.Localization' A

full_name: CategoryTheory.MorphismProperty.commShift_Q'
code: /-- The localization functor `W.Q' : C ⥤ W.Localization'` is compatible with the shift. -/
noncomputable instance MorphismProperty.commShift_Q' :
    W.Q'.CommShift A 
goal: W.Q'.CommShift A

full_name: CategoryTheory.Functor.commShiftOfLocalization.iso
code: /-- Auxiliary definition for `Functor.commShiftOfLocalization`. -/
noncomputable def iso (a : A) :
    shiftFunctor D a ⋙ F' ≅ F' ⋙ shiftFunctor E a 
goal: (CategoryTheory.shiftFunctor D a).comp F' ≅ F'.comp (CategoryTheory.shiftFunctor E a)

full_name: CategoryTheory.Functor.commShiftOfLocalization.iso_hom_app
code: @[simp, reassoc]
lemma iso_hom_app (a : A) (X : C) :
    (commShiftOfLocalization.iso L W F F' a).hom.app (L.obj X) =
      F'.map ((L.commShiftIso a).inv.app X) ≫
      (Lifting.iso L W F F').hom.app (X⟦a⟧) ≫
        (F.commShiftIso a).hom.app X ≫
          (shiftFunctor E a).map ((Lifting.iso L W F F').inv.app X) 
goal: (CategoryTheory.Functor.commShiftOfLocalization.iso L W F F' a).hom.app (L.obj X) =
  CategoryTheory.CategoryStruct.comp (F'.map ((L.commShiftIso a).inv.app X))
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.Localization.Lifting.iso L W F F').hom.app ((CategoryTheory.shiftFunctor C a).obj X))
      (CategoryTheory.CategoryStruct.comp ((F.commShiftIso a).hom.app X)
        ((CategoryTheory.shiftFunctor E a).map ((CategoryTheory.Localization.Lifting.iso L W F F').inv.app X))))

full_name: CategoryTheory.Functor.commShiftOfLocalization.iso_inv_app
code: @[simp, reassoc]
lemma iso_inv_app (a : A) (X : C) :
    (commShiftOfLocalization.iso L W F F' a).inv.app (L.obj X) =
        (shiftFunctor E a).map ((Lifting.iso L W F F').hom.app X) ≫
        (F.commShiftIso a).inv.app X ≫
      (Lifting.iso L W F F').inv.app (X⟦a⟧) ≫
      F'.map ((L.commShiftIso a).hom.app X) 
goal: (CategoryTheory.Functor.commShiftOfLocalization.iso L W F F' a).inv.app (L.obj X) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor E a).map ((CategoryTheory.Localization.Lifting.iso L W F F').hom.app X))
    (CategoryTheory.CategoryStruct.comp ((F.commShiftIso a).inv.app X)
      (CategoryTheory.CategoryStruct.comp
        ((CategoryTheory.Localization.Lifting.iso L W F F').inv.app ((CategoryTheory.shiftFunctor C a).obj X))
        (F'.map ((L.commShiftIso a).hom.app X))))

full_name: CategoryTheory.Functor.commShiftOfLocalization
code: /-- In the context of localization of categories, if a functor
is induced by a functor which commutes with the shift, then
this functor commutes with the shift.  -/
noncomputable def commShiftOfLocalization : F'.CommShift A 
goal: F'.CommShift A

full_name: CategoryTheory.Functor.commShiftOfLocalization_iso_hom_app
code: lemma commShiftOfLocalization_iso_hom_app (a : A) (X : C) :
    letI := Functor.commShiftOfLocalization L W A F F'
    (F'.commShiftIso a).hom.app (L.obj X) =
      F'.map ((L.commShiftIso a).inv.app X) ≫ (Lifting.iso L W F F').hom.app (X⟦a⟧) ≫
        (F.commShiftIso a).hom.app X ≫
          (shiftFunctor E a).map ((Lifting.iso L W F F').inv.app X) 
goal: (F'.commShiftIso a).hom.app (L.obj X) =
  CategoryTheory.CategoryStruct.comp (F'.map ((L.commShiftIso a).inv.app X))
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.Localization.Lifting.iso L W F F').hom.app ((CategoryTheory.shiftFunctor C a).obj X))
      (CategoryTheory.CategoryStruct.comp ((F.commShiftIso a).hom.app X)
        ((CategoryTheory.shiftFunctor E a).map ((CategoryTheory.Localization.Lifting.iso L W F F').inv.app X))))

full_name: CategoryTheory.Functor.commShiftOfLocalization_iso_inv_app
code: lemma commShiftOfLocalization_iso_inv_app (a : A) (X : C) :
    letI := Functor.commShiftOfLocalization L W A F F'
    (F'.commShiftIso a).inv.app (L.obj X) =
      (shiftFunctor E a).map ((Lifting.iso L W F F').hom.app X) ≫
      (F.commShiftIso a).inv.app X ≫ (Lifting.iso L W F F').inv.app (X⟦a⟧) ≫
     F'.map ((L.commShiftIso a).hom.app X) 
goal: (F'.commShiftIso a).inv.app (L.obj X) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor E a).map ((CategoryTheory.Localization.Lifting.iso L W F F').hom.app X))
    (CategoryTheory.CategoryStruct.comp ((F.commShiftIso a).inv.app X)
      (CategoryTheory.CategoryStruct.comp
        ((CategoryTheory.Localization.Lifting.iso L W F F').inv.app ((CategoryTheory.shiftFunctor C a).obj X))
        (F'.map ((L.commShiftIso a).hom.app X))))

full_name: CategoryTheory.NatTrans.commShift_iso_hom_of_localization
code: instance NatTrans.commShift_iso_hom_of_localization :
    letI := Functor.commShiftOfLocalization L W A F F'
    NatTrans.CommShift (Lifting.iso L W F F').hom A 
goal: CategoryTheory.NatTrans.CommShift (CategoryTheory.Localization.Lifting.iso L W F F').hom A