Documentation

Mathlib.CategoryTheory.Shift.InducedShiftSequence

Induced shift sequences #

When G : C ⥤ A is a functor from a category equipped with a shift by a monoid M, we have defined in the file CategoryTheory.Shift.ShiftSequence a type class G.ShiftSequence M which provides functors G.shift a : C ⥤ A for all a : M, isomorphisms shiftFunctor C n ⋙ G.shift a ≅ G.shift a' when n + a = a', and isomorphisms G.isoShift a : shiftFunctor C a ⋙ G ≅ G.shift a for all a, all of which satisfy good coherence properties. The idea is that it allows to use functors G.shift a which may have better definitional properties than shiftFunctor C a ⋙ G. The typical example shall be [(homologyFunctor C (ComplexShape.up ℤ) 0).ShiftSequence ℤ] for any abelian category C (TODO).

Similarly as a shift on a category may induce a shift on a quotient or a localized category (see the file CategoryTheory.Shift.Induced), this file shows that under certain assumptions, there is an induced "shift sequence". The main application will be the construction of a shift sequence for the homology functor on the homotopy category of cochain complexes (TODO), and also on the derived category (TODO).

@[irreducible]
noncomputable def CategoryTheory.Functor.ShiftSequence.induced.isoZero {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] [CategoryTheory.Category.{u_7, u_3} A] {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D A} {G : CategoryTheory.Functor C A} (e : L.comp F G) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] :
F' 0 F

The isoZero field of the induced shift sequence.

Equations
Instances For
    theorem CategoryTheory.Functor.ShiftSequence.induced.isoZero_hom_app_obj {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] [CategoryTheory.Category.{u_5, u_3} A] {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D A} {G : CategoryTheory.Functor C A} (e : L.comp F G) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] (X : C) :
    (CategoryTheory.Functor.ShiftSequence.induced.isoZero e M F' e').hom.app (L.obj X) = CategoryTheory.CategoryStruct.comp ((e' 0).hom.app X) (CategoryTheory.CategoryStruct.comp ((G.isoShiftZero M).hom.app X) (e.inv.app X))
    @[irreducible]
    noncomputable def CategoryTheory.Functor.ShiftSequence.induced.shiftIso {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] [CategoryTheory.Category.{u_7, u_3} A] (L : CategoryTheory.Functor C D) (G : CategoryTheory.Functor C A) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] [L.CommShift M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] (n : M) (a : M) (a' : M) (ha' : n + a = a') :
    (CategoryTheory.shiftFunctor D n).comp (F' a) F' a'

    The shiftIso field of the induced shift sequence.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
      theorem CategoryTheory.Functor.ShiftSequence.induced.shiftIso_hom_app_obj {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] [CategoryTheory.Category.{u_5, u_3} A] (L : CategoryTheory.Functor C D) (G : CategoryTheory.Functor C A) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] [L.CommShift M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] (n : M) (a : M) (a' : M) (ha' : n + a = a') (X : C) :
      (CategoryTheory.Functor.ShiftSequence.induced.shiftIso L G M F' e' n a a' ha').hom.app (L.obj X) = CategoryTheory.CategoryStruct.comp ((F' a).map ((L.commShiftIso n).inv.app X)) (CategoryTheory.CategoryStruct.comp ((e' a).hom.app ((CategoryTheory.shiftFunctor C n).obj X)) (CategoryTheory.CategoryStruct.comp ((G.shiftIso n a a' ha').hom.app X) ((e' a').inv.app X)))
      noncomputable def CategoryTheory.Functor.ShiftSequence.induced {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] [CategoryTheory.Category.{u_7, u_3} A] {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D A} {G : CategoryTheory.Functor C A} (e : L.comp F G) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] [L.CommShift M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] :
      F.ShiftSequence M

      Given an isomorphism of functors e : L ⋙ F ≅ G relating functors L : C ⥤ D, F : D ⥤ A and G : C ⥤ A, an additive monoid M, a family of functors F' : M → D ⥤ A equipped with isomorphisms e' : ∀ m, L ⋙ F' m ≅ G.shift m, this is the shift sequence induced on F induced by a shift sequence for the functor G, provided that the functor (whiskeringLeft C D A).obj L of precomposition by L is fully faithful.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        theorem CategoryTheory.Functor.ShiftSequence.induced_isoShiftZero_hom_app_obj_assoc {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] [CategoryTheory.Category.{u_5, u_3} A] {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D A} {G : CategoryTheory.Functor C A} (e : L.comp F G) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] [L.CommShift M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] (X : C) {Z : A} (h : F.obj (L.obj X) Z) :
        CategoryTheory.CategoryStruct.comp ((F.isoShiftZero M).hom.app (L.obj X)) h = CategoryTheory.CategoryStruct.comp ((e' 0).hom.app X) (CategoryTheory.CategoryStruct.comp ((G.isoShiftZero M).hom.app X) (CategoryTheory.CategoryStruct.comp (e.inv.app X) h))
        @[simp]
        theorem CategoryTheory.Functor.ShiftSequence.induced_isoShiftZero_hom_app_obj {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] [CategoryTheory.Category.{u_5, u_3} A] {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D A} {G : CategoryTheory.Functor C A} (e : L.comp F G) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] [L.CommShift M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] (X : C) :
        (F.isoShiftZero M).hom.app (L.obj X) = CategoryTheory.CategoryStruct.comp ((e' 0).hom.app X) (CategoryTheory.CategoryStruct.comp ((G.isoShiftZero M).hom.app X) (e.inv.app X))
        theorem CategoryTheory.Functor.ShiftSequence.induced_shiftIso_hom_app_obj_assoc {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] [CategoryTheory.Category.{u_5, u_3} A] {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D A} {G : CategoryTheory.Functor C A} (e : L.comp F G) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] [L.CommShift M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] (n : M) (a : M) (a' : M) (ha' : n + a = a') (X : C) {Z : A} (h : (F.shift a').obj (L.obj X) Z) :
        CategoryTheory.CategoryStruct.comp ((F.shiftIso n a a' ha').hom.app (L.obj X)) h = CategoryTheory.CategoryStruct.comp ((F.shift a).map ((L.commShiftIso n).inv.app X)) (CategoryTheory.CategoryStruct.comp ((e' a).hom.app ((CategoryTheory.shiftFunctor C n).obj X)) (CategoryTheory.CategoryStruct.comp ((G.shiftIso n a a' ha').hom.app X) (CategoryTheory.CategoryStruct.comp ((e' a').inv.app X) h)))
        @[simp]
        theorem CategoryTheory.Functor.ShiftSequence.induced_shiftIso_hom_app_obj {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] [CategoryTheory.Category.{u_5, u_3} A] {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D A} {G : CategoryTheory.Functor C A} (e : L.comp F G) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] [L.CommShift M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] (n : M) (a : M) (a' : M) (ha' : n + a = a') (X : C) :
        (F.shiftIso n a a' ha').hom.app (L.obj X) = CategoryTheory.CategoryStruct.comp ((F.shift a).map ((L.commShiftIso n).inv.app X)) (CategoryTheory.CategoryStruct.comp ((e' a).hom.app ((CategoryTheory.shiftFunctor C n).obj X)) (CategoryTheory.CategoryStruct.comp ((G.shiftIso n a a' ha').hom.app X) ((e' a').inv.app X)))
        theorem CategoryTheory.Functor.ShiftSequence.induced_shiftMap_assoc {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] [CategoryTheory.Category.{u_6, u_3} A] {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D A} {G : CategoryTheory.Functor C A} (e : L.comp F G) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] [L.CommShift M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] {n : M} {X : C} {Y : C} (f : X (CategoryTheory.shiftFunctor C n).obj Y) (a : M) (a' : M) (h : n + a = a') {Z : A} (h : (F.shift a').obj (L.obj Y) Z) :
        CategoryTheory.CategoryStruct.comp (F.shiftMap (CategoryTheory.CategoryStruct.comp (L.map f) ((L.commShiftIso n).hom.app Y)) a a' h✝) h = CategoryTheory.CategoryStruct.comp ((e' a).hom.app X) (CategoryTheory.CategoryStruct.comp (G.shiftMap f a a' h✝) (CategoryTheory.CategoryStruct.comp ((e' a').inv.app Y) h))
        theorem CategoryTheory.Functor.ShiftSequence.induced_shiftMap {C : Type u_1} {D : Type u_2} {A : Type u_3} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] [CategoryTheory.Category.{u_6, u_3} A] {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D A} {G : CategoryTheory.Functor C A} (e : L.comp F G) (M : Type u_4) [AddMonoid M] [CategoryTheory.HasShift C M] [CategoryTheory.HasShift D M] [L.CommShift M] [G.ShiftSequence M] (F' : MCategoryTheory.Functor D A) (e' : (m : M) → L.comp (F' m) G.shift m) [((CategoryTheory.whiskeringLeft C D A).obj L).Full] [((CategoryTheory.whiskeringLeft C D A).obj L).Faithful] {n : M} {X : C} {Y : C} (f : X (CategoryTheory.shiftFunctor C n).obj Y) (a : M) (a' : M) (h : n + a = a') :
        F.shiftMap (CategoryTheory.CategoryStruct.comp (L.map f) ((L.commShiftIso n).hom.app Y)) a a' h = CategoryTheory.CategoryStruct.comp ((e' a).hom.app X) (CategoryTheory.CategoryStruct.comp (G.shiftMap f a a' h) ((e' a').inv.app Y))