File: Mathlib/CategoryTheory/Shift/SingleFunctors.lean

full_name: CategoryTheory.SingleFunctors
code: /-- The type of families of functors `A → C ⥤ D` which are compatible with
the shift by `A` on the category `D`. -/
structure SingleFunctors where
  /-- a family of functors `C ⥤ D` indexed by the elements of the additive monoid `A` -/
  functor (a : A) : C ⥤ D
  /-- the isomorphism `functor a' ⋙ shiftFunctor D n ≅ functor a` when `n + a = a'` -/
  shiftIso (n a a' : A) (ha' : n + a = a') : functor a' ⋙ shiftFunctor D n ≅ functor a
  /-- `shiftIso 0` is the obvious isomorphism. -/
  shiftIso_zero (a : A) :
    shiftIso 0 a a (zero_add a) = isoWhiskerLeft _ (shiftFunctorZero D A)
  /-- `shiftIso (m + n)` is determined by `shiftIso m` and `shiftIso n`. -/
  shiftIso_add (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') :
    shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha'']) =
      isoWhiskerLeft _ (shiftFunctorAdd D m n) ≪≫ (Functor.associator _ _ _).symm ≪≫
        isoWhiskerRight (shiftIso m a' a'' ha'') _ ≪≫ shiftIso n a a' ha'
goal: Type (max (max (max (max u_1 u_2) u_5) u_6) u_7)

full_name: CategoryTheory.SingleFunctors.shiftIso_zero
code: /-- The type of families of functors `A → C ⥤ D` which are compatible with
the shift by `A` on the category `D`. -/
structure SingleFunctors where
  /-- a family of functors `C ⥤ D` indexed by the elements of the additive monoid `A` -/
  functor (a : A) : C ⥤ D
  /-- the isomorphism `functor a' ⋙ shiftFunctor D n ≅ functor a` when `n + a = a'` -/
  shiftIso (n a a' : A) (ha' : n + a = a') : functor a' ⋙ shiftFunctor D n ≅ functor a
  /-- `shiftIso 0` is the obvious isomorphism. -/
  shiftIso_zero (a : A) :
    shiftIso 0 a a (zero_add a) = isoWhiskerLeft _ (shiftFunctorZero D A)
  /-- `shiftIso (m + n)` is determined by `shiftIso m` and `shiftIso n`. -/
  shiftIso_add (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') :
    shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha'']) =
      isoWhiskerLeft _ (shiftFunctorAdd D m n) ≪≫ (Functor.associator _ _ _).symm ≪≫
        isoWhiskerRight (shiftIso m a' a'' ha'') _ ≪≫ shiftIso n a a' ha'
goal: self.shiftIso 0 a a ⋯ = CategoryTheory.isoWhiskerLeft (self.functor a) (CategoryTheory.shiftFunctorZero D A)

full_name: CategoryTheory.SingleFunctors.shiftIso_add
code: /-- The type of families of functors `A → C ⥤ D` which are compatible with
the shift by `A` on the category `D`. -/
structure SingleFunctors where
  /-- a family of functors `C ⥤ D` indexed by the elements of the additive monoid `A` -/
  functor (a : A) : C ⥤ D
  /-- the isomorphism `functor a' ⋙ shiftFunctor D n ≅ functor a` when `n + a = a'` -/
  shiftIso (n a a' : A) (ha' : n + a = a') : functor a' ⋙ shiftFunctor D n ≅ functor a
  /-- `shiftIso 0` is the obvious isomorphism. -/
  shiftIso_zero (a : A) :
    shiftIso 0 a a (zero_add a) = isoWhiskerLeft _ (shiftFunctorZero D A)
  /-- `shiftIso (m + n)` is determined by `shiftIso m` and `shiftIso n`. -/
  shiftIso_add (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') :
    shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha'']) =
      isoWhiskerLeft _ (shiftFunctorAdd D m n) ≪≫ (Functor.associator _ _ _).symm ≪≫
        isoWhiskerRight (shiftIso m a' a'' ha'') _ ≪≫ shiftIso n a a' ha'
goal: self.shiftIso (m + n) a a'' ⋯ =
  CategoryTheory.isoWhiskerLeft (self.functor a'') (CategoryTheory.shiftFunctorAdd D m n) ≪≫
    ((self.functor a'').associator (CategoryTheory.shiftFunctor D m) (CategoryTheory.shiftFunctor D n)).symm ≪≫
      CategoryTheory.isoWhiskerRight (self.shiftIso m a' a'' ha'') (CategoryTheory.shiftFunctor D n) ≪≫
        self.shiftIso n a a' ha'

full_name: CategoryTheory.SingleFunctors.shiftIso
code: /-- The type of families of functors `A → C ⥤ D` which are compatible with
the shift by `A` on the category `D`. -/
structure SingleFunctors where
  /-- a family of functors `C ⥤ D` indexed by the elements of the additive monoid `A` -/
  functor (a : A) : C ⥤ D
  /-- the isomorphism `functor a' ⋙ shiftFunctor D n ≅ functor a` when `n + a = a'` -/
  shiftIso (n a a' : A) (ha' : n + a = a') : functor a' ⋙ shiftFunctor D n ≅ functor a
  /-- `shiftIso 0` is the obvious isomorphism. -/
  shiftIso_zero (a : A) :
    shiftIso 0 a a (zero_add a) = isoWhiskerLeft _ (shiftFunctorZero D A)
  /-- `shiftIso (m + n)` is determined by `shiftIso m` and `shiftIso n`. -/
  shiftIso_add (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') :
    shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha'']) =
      isoWhiskerLeft _ (shiftFunctorAdd D m n) ≪≫ (Functor.associator _ _ _).symm ≪≫
        isoWhiskerRight (shiftIso m a' a'' ha'') _ ≪≫ shiftIso n a a' ha'
goal: self.functor a' ⋙ CategoryTheory.shiftFunctor D n ≅ self.functor a

full_name: CategoryTheory.SingleFunctors.functor
code: /-- The type of families of functors `A → C ⥤ D` which are compatible with
the shift by `A` on the category `D`. -/
structure SingleFunctors where
  /-- a family of functors `C ⥤ D` indexed by the elements of the additive monoid `A` -/
  functor (a : A) : C ⥤ D
  /-- the isomorphism `functor a' ⋙ shiftFunctor D n ≅ functor a` when `n + a = a'` -/
  shiftIso (n a a' : A) (ha' : n + a = a') : functor a' ⋙ shiftFunctor D n ≅ functor a
  /-- `shiftIso 0` is the obvious isomorphism. -/
  shiftIso_zero (a : A) :
    shiftIso 0 a a (zero_add a) = isoWhiskerLeft _ (shiftFunctorZero D A)
  /-- `shiftIso (m + n)` is determined by `shiftIso m` and `shiftIso n`. -/
  shiftIso_add (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') :
    shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha'']) =
      isoWhiskerLeft _ (shiftFunctorAdd D m n) ≪≫ (Functor.associator _ _ _).symm ≪≫
        isoWhiskerRight (shiftIso m a' a'' ha'') _ ≪≫ shiftIso n a a' ha'
goal: C ⥤ D

full_name: CategoryTheory.SingleFunctors.shiftIso_add_hom_app
code: lemma shiftIso_add_hom_app (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
    (F.shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha''])).hom.app X =
      (shiftFunctorAdd D m n).hom.app ((F.functor a'').obj X) ≫
        ((F.shiftIso m a' a'' ha'').hom.app X)⟦n⟧' ≫
        (F.shiftIso n a a' ha').hom.app X 
goal: (F.shiftIso (m + n) a a'' ⋯).hom.app X =
  (CategoryTheory.shiftFunctorAdd D m n).hom.app ((F.functor a'').obj X) ≫
    (CategoryTheory.shiftFunctor D n).map ((F.shiftIso m a' a'' ha'').hom.app X) ≫ (F.shiftIso n a a' ha').hom.app X

full_name: CategoryTheory.SingleFunctors.shiftIso_add_inv_app
code: lemma shiftIso_add_inv_app (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
    (F.shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha''])).inv.app X =
      (F.shiftIso n a a' ha').inv.app X ≫
      ((F.shiftIso m a' a'' ha'').inv.app X)⟦n⟧' ≫
      (shiftFunctorAdd D m n).inv.app ((F.functor a'').obj X) 
goal: (F.shiftIso (m + n) a a'' ⋯).inv.app X =
  (F.shiftIso n a a' ha').inv.app X ≫
    (CategoryTheory.shiftFunctor D n).map ((F.shiftIso m a' a'' ha'').inv.app X) ≫
      (CategoryTheory.shiftFunctorAdd D m n).inv.app ((F.functor a'').obj X)

full_name: CategoryTheory.SingleFunctors.shiftIso_add'
code: lemma shiftIso_add' (n m mn : A) (hnm : m + n = mn) (a a' a'' : A)
    (ha' : n + a = a') (ha'' : m + a' = a'') :
    F.shiftIso mn a a'' (by rw [← hnm, ← ha'', ← ha', add_assoc]) =
      isoWhiskerLeft _ (shiftFunctorAdd' D m n mn hnm) ≪≫ (Functor.associator _ _ _).symm ≪≫
        isoWhiskerRight (F.shiftIso m a' a'' ha'') _ ≪≫ F.shiftIso n a a' ha' 
goal: F.shiftIso mn a a'' ⋯ =
  CategoryTheory.isoWhiskerLeft (F.functor a'') (CategoryTheory.shiftFunctorAdd' D m n mn hnm) ≪≫
    ((F.functor a'').associator (CategoryTheory.shiftFunctor D m) (CategoryTheory.shiftFunctor D n)).symm ≪≫
      CategoryTheory.isoWhiskerRight (F.shiftIso m a' a'' ha'') (CategoryTheory.shiftFunctor D n) ≪≫
        F.shiftIso n a a' ha'

full_name: CategoryTheory.SingleFunctors.shiftIso_add'_hom_app
code: lemma shiftIso_add'_hom_app (n m mn : A) (hnm : m + n = mn) (a a' a'' : A)
    (ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
    (F.shiftIso mn a a'' (by rw [← hnm, ← ha'', ← ha', add_assoc])).hom.app X =
      (shiftFunctorAdd' D m n mn hnm).hom.app ((F.functor a'').obj X) ≫
        ((F.shiftIso m a' a'' ha'').hom.app X)⟦n⟧' ≫ (F.shiftIso n a a' ha').hom.app X 
goal: (F.shiftIso mn a a'' ⋯).hom.app X =
  (CategoryTheory.shiftFunctorAdd' D m n mn hnm).hom.app ((F.functor a'').obj X) ≫
    (CategoryTheory.shiftFunctor D n).map ((F.shiftIso m a' a'' ha'').hom.app X) ≫ (F.shiftIso n a a' ha').hom.app X

full_name: CategoryTheory.SingleFunctors.shiftIso_add'_inv_app
code: lemma shiftIso_add'_inv_app (n m mn : A) (hnm : m + n = mn) (a a' a'' : A)
    (ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
    (F.shiftIso mn a a'' (by rw [← hnm, ← ha'', ← ha', add_assoc])).inv.app X =
        (F.shiftIso n a a' ha').inv.app X ≫
        ((F.shiftIso m a' a'' ha'').inv.app X)⟦n⟧' ≫
      (shiftFunctorAdd' D m n mn hnm).inv.app ((F.functor a'').obj X) 
goal: (F.shiftIso mn a a'' ⋯).inv.app X =
  (F.shiftIso n a a' ha').inv.app X ≫
    (CategoryTheory.shiftFunctor D n).map ((F.shiftIso m a' a'' ha'').inv.app X) ≫
      (CategoryTheory.shiftFunctorAdd' D m n mn hnm).inv.app ((F.functor a'').obj X)

full_name: CategoryTheory.SingleFunctors.shiftIso_zero_hom_app
code: @[simp]
lemma shiftIso_zero_hom_app (a : A) (X : C) :
    (F.shiftIso 0 a a (zero_add a)).hom.app X = (shiftFunctorZero D A).hom.app _ 
goal: (F.shiftIso 0 a a ⋯).hom.app X = (CategoryTheory.shiftFunctorZero D A).hom.app ((F.functor a).obj X)

full_name: CategoryTheory.SingleFunctors.shiftIso_zero_inv_app
code: @[simp]
lemma shiftIso_zero_inv_app (a : A) (X : C) :
    (F.shiftIso 0 a a (zero_add a)).inv.app X = (shiftFunctorZero D A).inv.app _ 
goal: (F.shiftIso 0 a a ⋯).inv.app X = (CategoryTheory.shiftFunctorZero D A).inv.app ((F.functor a).toPrefunctor.1 X)

full_name: CategoryTheory.SingleFunctors.Hom.hom
code: /-- The morphisms in the category `SingleFunctors C D A` -/
@[ext]
structure Hom where
  /-- a family of natural transformations `F.functor a ⟶ G.functor a` -/
  hom (a : A) : F.functor a ⟶ G.functor a
  comm (n a a' : A) (ha' : n + a = a') : (F.shiftIso n a a' ha').hom ≫ hom a =
    whiskerRight (hom a') (shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom := by aesop_cat
goal: F.functor a ⟶ G.functor a

full_name: CategoryTheory.SingleFunctors.Hom
code: /-- The morphisms in the category `SingleFunctors C D A` -/
@[ext]
structure Hom where
  /-- a family of natural transformations `F.functor a ⟶ G.functor a` -/
  hom (a : A) : F.functor a ⟶ G.functor a
  comm (n a a' : A) (ha' : n + a = a') : (F.shiftIso n a a' ha').hom ≫ hom a =
    whiskerRight (hom a') (shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom := by aesop_cat
goal: Type (max (max u_1 u_5) u_7)

full_name: CategoryTheory.SingleFunctors.Hom.comm
code: /-- The morphisms in the category `SingleFunctors C D A` -/
@[ext]
structure Hom where
  /-- a family of natural transformations `F.functor a ⟶ G.functor a` -/
  hom (a : A) : F.functor a ⟶ G.functor a
  comm (n a a' : A) (ha' : n + a = a') : (F.shiftIso n a a' ha').hom ≫ hom a =
    whiskerRight (hom a') (shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom := by aesop_cat
goal: (F.shiftIso n a a' ha').hom ≫ self.hom a =
  CategoryTheory.whiskerRight (self.hom a') (CategoryTheory.shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom

full_name: CategoryTheory.SingleFunctors.Hom.id
code: /-- The identity morphism in `SingleFunctors C D A`. -/
@[simps]
def id : Hom F F 
goal: F.Hom F

full_name: CategoryTheory.SingleFunctors.Hom.id_hom
code: /-- The identity morphism in `SingleFunctors C D A`. -/
@[simps]
def id : Hom F F 
goal: (CategoryTheory.SingleFunctors.Hom.id F).hom a = 𝟙 (F.functor a)

full_name: CategoryTheory.SingleFunctors.Hom.comp_hom
code: /-- The composition of morphisms in `SingleFunctors C D A`. -/
@[simps]
def comp (α : Hom F G) (β : Hom G H) : Hom F H 
goal: (α.comp β).hom a = α.hom a ≫ β.hom a

full_name: CategoryTheory.SingleFunctors.Hom.comp
code: /-- The composition of morphisms in `SingleFunctors C D A`. -/
@[simps]
def comp (α : Hom F G) (β : Hom G H) : Hom F H 
goal: F.Hom H

full_name: CategoryTheory.SingleFunctors.instCategory
code: instance : Category (SingleFunctors C D A) 
goal: CategoryTheory.Category.{max (max u_1 u_5) u_7, max (max (max (max u_7 u_6) u_5) u_2) u_1}
  (CategoryTheory.SingleFunctors C D A)

full_name: CategoryTheory.SingleFunctors.id_hom
code: @[simp]
lemma id_hom (a : A) : Hom.hom (𝟙 F) a = 𝟙 _ 
goal: (𝟙 F).hom a = 𝟙 (F.functor a)

full_name: CategoryTheory.SingleFunctors.comp_hom
code: @[simp, reassoc]
lemma comp_hom (f : F ⟶ G) (g : G ⟶ H) (a : A) : (f ≫ g).hom a = f.hom a ≫ g.hom a 
goal: (f ≫ g).hom a = f.hom a ≫ g.hom a

full_name: CategoryTheory.SingleFunctors.hom_ext
code: @[ext]
lemma hom_ext (f g : F ⟶ G) (h : f.hom = g.hom) : f = g 
goal: f = g

full_name: CategoryTheory.SingleFunctors.isoMk_inv_hom
code: /-- Construct an isomorphism in `SingleFunctors C D A` by giving
level-wise isomorphisms and checking compatibility only in the forward direction. -/
@[simps]
def isoMk (iso : ∀ a, (F.functor a ≅ G.functor a))
    (comm : ∀ (n a a' : A) (ha' : n + a = a'), (F.shiftIso n a a' ha').hom ≫ (iso a).hom =
      whiskerRight (iso a').hom (shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom) :
    F ≅ G 
goal: (CategoryTheory.SingleFunctors.isoMk iso comm).inv.hom a = (iso a).inv

full_name: CategoryTheory.SingleFunctors.isoMk_hom_hom
code: /-- Construct an isomorphism in `SingleFunctors C D A` by giving
level-wise isomorphisms and checking compatibility only in the forward direction. -/
@[simps]
def isoMk (iso : ∀ a, (F.functor a ≅ G.functor a))
    (comm : ∀ (n a a' : A) (ha' : n + a = a'), (F.shiftIso n a a' ha').hom ≫ (iso a).hom =
      whiskerRight (iso a').hom (shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom) :
    F ≅ G 
goal: (CategoryTheory.SingleFunctors.isoMk iso comm).hom.hom a = (iso a).hom

full_name: CategoryTheory.SingleFunctors.isoMk
code: /-- Construct an isomorphism in `SingleFunctors C D A` by giving
level-wise isomorphisms and checking compatibility only in the forward direction. -/
@[simps]
def isoMk (iso : ∀ a, (F.functor a ≅ G.functor a))
    (comm : ∀ (n a a' : A) (ha' : n + a = a'), (F.shiftIso n a a' ha').hom ≫ (iso a).hom =
      whiskerRight (iso a').hom (shiftFunctor D n) ≫ (G.shiftIso n a a' ha').hom) :
    F ≅ G 
goal: F ≅ G

full_name: CategoryTheory.SingleFunctors.evaluation_obj
code: /-- The evaluation `SingleFunctors C D A ⥤ C ⥤ D` for some `a : A`. -/
@[simps]
def evaluation (a : A) : SingleFunctors C D A ⥤ C ⥤ D 
goal: (CategoryTheory.SingleFunctors.evaluation C D a).obj F = F.functor a

full_name: CategoryTheory.SingleFunctors.evaluation_map
code: /-- The evaluation `SingleFunctors C D A ⥤ C ⥤ D` for some `a : A`. -/
@[simps]
def evaluation (a : A) : SingleFunctors C D A ⥤ C ⥤ D 
goal: (CategoryTheory.SingleFunctors.evaluation C D a).map φ = φ.hom a

full_name: CategoryTheory.SingleFunctors.evaluation
code: /-- The evaluation `SingleFunctors C D A ⥤ C ⥤ D` for some `a : A`. -/
@[simps]
def evaluation (a : A) : SingleFunctors C D A ⥤ C ⥤ D 
goal: CategoryTheory.SingleFunctors C D A ⥤ C ⥤ D

full_name: CategoryTheory.SingleFunctors.hom_inv_id_hom
code: @[reassoc (attr := simp)]
lemma hom_inv_id_hom (e : F ≅ G) (n : A) : e.hom.hom n ≫ e.inv.hom n = 𝟙 _ 
goal: e.hom.hom n ≫ e.inv.hom n = 𝟙 (F.functor n)

full_name: CategoryTheory.SingleFunctors.inv_hom_id_hom
code: @[reassoc (attr := simp)]
lemma inv_hom_id_hom (e : F ≅ G) (n : A) : e.inv.hom n ≫ e.hom.hom n = 𝟙 _ 
goal: e.inv.hom n ≫ e.hom.hom n = 𝟙 (G.functor n)

full_name: CategoryTheory.SingleFunctors.hom_inv_id_hom_app
code: @[reassoc (attr := simp)]
lemma hom_inv_id_hom_app (e : F ≅ G) (n : A) (X : C) :
    (e.hom.hom n).app X ≫ (e.inv.hom n).app X = 𝟙 _ 
goal: (e.hom.hom n).app X ≫ (e.inv.hom n).app X = 𝟙 ((F.functor n).obj X)

full_name: CategoryTheory.SingleFunctors.inv_hom_id_hom_app
code: @[reassoc (attr := simp)]
lemma inv_hom_id_hom_app (e : F ≅ G) (n : A) (X : C) :
    (e.inv.hom n).app X ≫ (e.hom.hom n).app X = 𝟙 _ 
goal: (e.inv.hom n).app X ≫ (e.hom.hom n).app X = 𝟙 ((G.functor n).obj X)

full_name: CategoryTheory.SingleFunctors.instIsIsoFunctorHom
code: instance (f : F ⟶ G) [IsIso f] (n : A) : IsIso (f.hom n) 
goal: CategoryTheory.IsIso (f.hom n)

full_name: CategoryTheory.SingleFunctors.postcomp_shiftIso_inv_app
code: /-- Given `F : SingleFunctors C D A`, and a functor `G : D ⥤ E` which commutes
with the shift by `A`, this is the "composition" of `F` and `G` in `SingleFunctors C E A`. -/
@[simps! functor shiftIso_hom_app shiftIso_inv_app]
def postcomp (G : D ⥤ E) [G.CommShift A] :
    SingleFunctors C E A 
goal: ((F.postcomp G).shiftIso n a a' ha').inv.app X =
  G.map ((F.shiftIso n a a' ha').inv.app X) ≫ (G.commShiftIso n).hom.app ((F.functor a').obj X)

full_name: CategoryTheory.SingleFunctors.postcomp_shiftIso_hom_app
code: /-- Given `F : SingleFunctors C D A`, and a functor `G : D ⥤ E` which commutes
with the shift by `A`, this is the "composition" of `F` and `G` in `SingleFunctors C E A`. -/
@[simps! functor shiftIso_hom_app shiftIso_inv_app]
def postcomp (G : D ⥤ E) [G.CommShift A] :
    SingleFunctors C E A 
goal: ((F.postcomp G).shiftIso n a a' ha').hom.app X =
  (G.commShiftIso n).inv.app ((F.functor a').obj X) ≫ G.map ((F.shiftIso n a a' ha').hom.app X)

full_name: CategoryTheory.SingleFunctors.postcomp_functor
code: /-- Given `F : SingleFunctors C D A`, and a functor `G : D ⥤ E` which commutes
with the shift by `A`, this is the "composition" of `F` and `G` in `SingleFunctors C E A`. -/
@[simps! functor shiftIso_hom_app shiftIso_inv_app]
def postcomp (G : D ⥤ E) [G.CommShift A] :
    SingleFunctors C E A 
goal: (F.postcomp G).functor a = F.functor a ⋙ G

full_name: CategoryTheory.SingleFunctors.postcomp
code: /-- Given `F : SingleFunctors C D A`, and a functor `G : D ⥤ E` which commutes
with the shift by `A`, this is the "composition" of `F` and `G` in `SingleFunctors C E A`. -/
@[simps! functor shiftIso_hom_app shiftIso_inv_app]
def postcomp (G : D ⥤ E) [G.CommShift A] :
    SingleFunctors C E A 
goal: CategoryTheory.SingleFunctors C E A

full_name: CategoryTheory.SingleFunctors.postcompFunctor
code: /-- The functor `SingleFunctors C D A ⥤ SingleFunctors C E A` given by the postcomposition
by a functor `G : D ⥤ E` which commutes with the shift. -/
def postcompFunctor (G : D ⥤ E) [G.CommShift A] :
    SingleFunctors C D A ⥤ SingleFunctors C E A 
goal: CategoryTheory.SingleFunctors C D A ⥤ CategoryTheory.SingleFunctors C E A

full_name: CategoryTheory.SingleFunctors.postcompPostcompIso_inv_hom_app
code: /-- The canonical isomorphism `(F.postcomp G).postcomp G' ≅ F.postcomp (G ⋙ G')`. -/
@[simps!]
def postcompPostcompIso (G : D ⥤ E) (G' : E ⥤ E') [G.CommShift A] [G'.CommShift A] :
    (F.postcomp G).postcomp G' ≅ F.postcomp (G ⋙ G') 
goal: ∀ (x : C), ((F.postcompPostcompIso G G').inv.hom a).app x = 𝟙 (G'.obj (G.obj ((F.functor a).obj x)))

full_name: CategoryTheory.SingleFunctors.postcompPostcompIso
code: /-- The canonical isomorphism `(F.postcomp G).postcomp G' ≅ F.postcomp (G ⋙ G')`. -/
@[simps!]
def postcompPostcompIso (G : D ⥤ E) (G' : E ⥤ E') [G.CommShift A] [G'.CommShift A] :
    (F.postcomp G).postcomp G' ≅ F.postcomp (G ⋙ G') 
goal: (F.postcomp G).postcomp G' ≅ F.postcomp (G ⋙ G')

full_name: CategoryTheory.SingleFunctors.postcompPostcompIso_hom_hom_app
code: /-- The canonical isomorphism `(F.postcomp G).postcomp G' ≅ F.postcomp (G ⋙ G')`. -/
@[simps!]
def postcompPostcompIso (G : D ⥤ E) (G' : E ⥤ E') [G.CommShift A] [G'.CommShift A] :
    (F.postcomp G).postcomp G' ≅ F.postcomp (G ⋙ G') 
goal: ∀ (x : C), ((F.postcompPostcompIso G G').hom.hom a).app x = 𝟙 (G'.obj (G.obj ((F.functor a).obj x)))

full_name: CategoryTheory.SingleFunctors.postcompIsoOfIso
code: /-- The isomorphism `F.postcomp G ≅ F.postcomp G'` induced by an isomorphism `e : G ≅ G'`
which commutes with the shift. -/
@[simps!]
def postcompIsoOfIso {G G' : D ⥤ E} (e : G ≅ G') [G.CommShift A] [G'.CommShift A]
    [NatTrans.CommShift e.hom A] :
    F.postcomp G ≅ F.postcomp G' 
goal: F.postcomp G ≅ F.postcomp G'

full_name: CategoryTheory.SingleFunctors.postcompIsoOfIso_hom_hom_app
code: /-- The isomorphism `F.postcomp G ≅ F.postcomp G'` induced by an isomorphism `e : G ≅ G'`
which commutes with the shift. -/
@[simps!]
def postcompIsoOfIso {G G' : D ⥤ E} (e : G ≅ G') [G.CommShift A] [G'.CommShift A]
    [NatTrans.CommShift e.hom A] :
    F.postcomp G ≅ F.postcomp G' 
goal: ((F.postcompIsoOfIso e).hom.hom a).app X = e.hom.app ((F.functor a).obj X)

full_name: CategoryTheory.SingleFunctors.postcompIsoOfIso_inv_hom_app
code: /-- The isomorphism `F.postcomp G ≅ F.postcomp G'` induced by an isomorphism `e : G ≅ G'`
which commutes with the shift. -/
@[simps!]
def postcompIsoOfIso {G G' : D ⥤ E} (e : G ≅ G') [G.CommShift A] [G'.CommShift A]
    [NatTrans.CommShift e.hom A] :
    F.postcomp G ≅ F.postcomp G' 
goal: ((F.postcompIsoOfIso e).inv.hom a).app X = e.inv.app ((F.functor a).obj X)