ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Functor.map_shiftFunctorCompIsoId_hom_app
@[simp, reassoc]
lemma map_shiftFunctorCompIsoId_hom_app [F.CommShift A] (X : C) (a b : A) (h : a + b = 0) :
    F.map ((shiftFunctorCompIsoId C a b h).hom.app X) =
      (F.commShiftIso b).hom.app (X⟦a⟧) ≫ ((F.commShiftIso a).hom.app X)⟦b⟧' ≫
        (shiftFunctorCompIsoId D a b h).hom.app (F.obj X) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_6, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_4} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [F.CommShift A] (X : C) (a b : A) (h : a + b = 0)
Goal: F.map ((CategoryTheory.shiftFunctorCompIsoId C a b h).hom.app X) =
  CategoryTheory.CategoryStruct.comp ((F.commShiftIso b).hom.app ((CategoryTheory.shiftFunctor C a).obj X))
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D b).map ((F.commShiftIso a).hom.app X))
      ((CategoryTheory.shiftFunctorCompIsoId D a b h).hom.app (F.obj X)))
-- CategoryTheory.Functor.map_shiftFunctorCompIsoId_inv_app
@[simp, reassoc]
lemma map_shiftFunctorCompIsoId_inv_app [F.CommShift A] (X : C) (a b : A) (h : a + b = 0) :
    F.map ((shiftFunctorCompIsoId C a b h).inv.app X) =
      (shiftFunctorCompIsoId D a b h).inv.app (F.obj X) ≫
        ((F.commShiftIso a).inv.app X)⟦b⟧' ≫ (F.commShiftIso b).inv.app (X⟦a⟧) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_6, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_4} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [F.CommShift A] (X : C) (a b : A) (h : a + b = 0)
Goal: F.map ((CategoryTheory.shiftFunctorCompIsoId C a b h).inv.app X) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorCompIsoId D a b h).inv.app (F.obj X))
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D b).map ((F.commShiftIso a).inv.app X))
      ((F.commShiftIso b).inv.app ((CategoryTheory.shiftFunctor C a).obj X)))
-- CategoryTheory.NatTrans.CommShift.comm'
class CommShift : Prop :=
  comm' (a : A) : (F₁.commShiftIso a).hom ≫ whiskerRight τ _ =
    whiskerLeft _ τ ≫ (F₂.commShiftIso a).hom
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_6, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] {F₁ F₂ : CategoryTheory.Functor C D} {τ : F₁ ⟶ F₂} {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [F₁.CommShift A] [F₂.CommShift A] [self : CategoryTheory.NatTrans.CommShift τ A] (a : A)
Goal: CategoryTheory.CategoryStruct.comp (F₁.commShiftIso a).hom
    (CategoryTheory.whiskerRight τ (CategoryTheory.shiftFunctor D a)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft (CategoryTheory.shiftFunctor C a) τ)
    (F₂.commShiftIso a).hom
-- CategoryTheory.NatTrans.CommShift.comm
lemma comm (a : A) : (F₁.commShiftIso a).hom ≫ whiskerRight τ _ =
    whiskerLeft _ τ ≫ (F₂.commShiftIso a).hom 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] {F₁ F₂ : CategoryTheory.Functor C D} (τ : F₁ ⟶ F₂) {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [F₁.CommShift A] [F₂.CommShift A] [CategoryTheory.NatTrans.CommShift τ A] (a : A)
Goal: CategoryTheory.CategoryStruct.comp (F₁.commShiftIso a).hom
    (CategoryTheory.whiskerRight τ (CategoryTheory.shiftFunctor D a)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft (CategoryTheory.shiftFunctor C a) τ)
    (F₂.commShiftIso a).hom
-- CategoryTheory.NatTrans.CommShift.comm_app
@[reassoc]
lemma comm_app (a : A) (X : C) :
    (F₁.commShiftIso a).hom.app X ≫ (τ.app X)⟦a⟧' =
      τ.app (X⟦a⟧) ≫ (F₂.commShiftIso a).hom.app X 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] {F₁ F₂ : CategoryTheory.Functor C D} (τ : F₁ ⟶ F₂) {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [F₁.CommShift A] [F₂.CommShift A] [CategoryTheory.NatTrans.CommShift τ A] (a : A) (X : C)
Goal: CategoryTheory.CategoryStruct.comp ((F₁.commShiftIso a).hom.app X) ((CategoryTheory.shiftFunctor D a).map (τ.app X)) =
  CategoryTheory.CategoryStruct.comp (τ.app ((CategoryTheory.shiftFunctor C a).obj X)) ((F₂.commShiftIso a).hom.app X)
-- CategoryTheory.NatTrans.CommShift.shift_app
@[reassoc]
lemma shift_app (a : A) (X : C) :
    (τ.app X)⟦a⟧' = (F₁.commShiftIso a).inv.app X ≫
      τ.app (X⟦a⟧) ≫ (F₂.commShiftIso a).hom.app X 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] {F₁ F₂ : CategoryTheory.Functor C D} (τ : F₁ ⟶ F₂) {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [F₁.CommShift A] [F₂.CommShift A] [CategoryTheory.NatTrans.CommShift τ A] (a : A) (X : C)
Goal: (CategoryTheory.shiftFunctor D a).map (τ.app X) =
  CategoryTheory.CategoryStruct.comp ((F₁.commShiftIso a).inv.app X)
    (CategoryTheory.CategoryStruct.comp (τ.app ((CategoryTheory.shiftFunctor C a).obj X))
      ((F₂.commShiftIso a).hom.app X))
-- CategoryTheory.NatTrans.CommShift.app_shift
@[reassoc]
lemma app_shift (a : A) (X : C) :
    τ.app (X⟦a⟧) = (F₁.commShiftIso a).hom.app X ≫ (τ.app X)⟦a⟧' ≫
      (F₂.commShiftIso a).inv.app X 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] {F₁ F₂ : CategoryTheory.Functor C D} (τ : F₁ ⟶ F₂) {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [F₁.CommShift A] [F₂.CommShift A] [CategoryTheory.NatTrans.CommShift τ A] (a : A) (X : C)
Goal: τ.app ((CategoryTheory.shiftFunctor C a).obj X) =
  CategoryTheory.CategoryStruct.comp ((F₁.commShiftIso a).hom.app X)
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D a).map (τ.app X))
      ((F₂.commShiftIso a).inv.app X))
-- CategoryTheory.NatTrans.CommShift.of_isIso
lemma of_isIso [IsIso τ] [NatTrans.CommShift τ A] :
    NatTrans.CommShift (inv τ) A 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] {F₁ F₂ : CategoryTheory.Functor C D} (τ : F₁ ⟶ F₂) (A : Type u_5) [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [F₁.CommShift A] [F₂.CommShift A] [CategoryTheory.IsIso τ] [CategoryTheory.NatTrans.CommShift τ A]
Goal: CategoryTheory.NatTrans.CommShift (CategoryTheory.inv τ) A
-- CategoryTheory.Functor.CommShift.ofIso_compatibility
lemma ofIso_compatibility :
    letI := ofIso e A
    NatTrans.CommShift e.hom A 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_5, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] {F G : CategoryTheory.Functor C D} (e : F ≅ G) (A : Type u_4) [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [F.CommShift A]
Goal: CategoryTheory.NatTrans.CommShift e.hom A
-- CategoryTheory.NatTrans.CommShift.verticalComposition
lemma NatTrans.CommShift.verticalComposition {C₁ C₂ C₃ D₁ D₂ D₃ : Type*}
    [Category C₁] [Category C₂] [Category C₃] [Category D₁] [Category D₂] [Category D₃]
    {F₁₂ : C₁ ⥤ C₂} {F₂₃ : C₂ ⥤ C₃} {F₁₃ : C₁ ⥤ C₃} (α : F₁₃ ⟶ F₁₂ ⋙ F₂₃)
    {G₁₂ : D₁ ⥤ D₂} {G₂₃ : D₂ ⥤ D₃} {G₁₃ : D₁ ⥤ D₃} (β : G₁₂ ⋙ G₂₃ ⟶ G₁₃)
    {L₁ : C₁ ⥤ D₁} {L₂ : C₂ ⥤ D₂} {L₃ : C₃ ⥤ D₃}
    (e₁₂ : F₁₂ ⋙ L₂ ⟶ L₁ ⋙ G₁₂) (e₂₃ : F₂₃ ⋙ L₃ ⟶ L₂ ⋙ G₂₃) (e₁₃ : F₁₃ ⋙ L₃ ⟶ L₁ ⋙ G₁₃)
    (A : Type*) [AddMonoid A] [HasShift C₁ A] [HasShift C₂ A] [HasShift C₃ A]
    [HasShift D₁ A] [HasShift D₂ A] [HasShift D₃ A]
    [F₁₂.CommShift A] [F₂₃.CommShift A] [F₁₃.CommShift A] [CommShift α A]
    [G₁₂.CommShift A] [G₂₃.CommShift A] [G₁₃.CommShift A] [CommShift β A]
    [L₁.CommShift A] [L₂.CommShift A] [L₃.CommShift A]
    [CommShift e₁₂ A] [CommShift e₂₃ A]
    (h₁₃ : e₁₃ = CategoryTheory.whiskerRight α L₃ ≫ (Functor.associator _ _ _).hom ≫
      CategoryTheory.whiskerLeft F₁₂ e₂₃ ≫ (Functor.associator _ _ _).inv ≫
        CategoryTheory.whiskerRight e₁₂ G₂₃ ≫ (Functor.associator _ _ _).hom ≫
          CategoryTheory.whiskerLeft L₁ β) : CommShift e₁₃ A 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : Type u_6} [CategoryTheory.Category.{u_8, u_1} C₁] [CategoryTheory.Category.{u_9, u_2} C₂] [CategoryTheory.Category.{u_10, u_3} C₃] [CategoryTheory.Category.{u_11, u_4} D₁] [CategoryTheory.Category.{u_12, u_5} D₂] [CategoryTheory.Category.{u_13, u_6} D₃] {F₁₂ : CategoryTheory.Functor C₁ C₂} {F₂₃ : CategoryTheory.Functor C₂ C₃} {F₁₃ : CategoryTheory.Functor C₁ C₃} (α : F₁₃ ⟶ F₁₂.comp F₂₃) {G₁₂ : CategoryTheory.Functor D₁ D₂} {G₂₃ : CategoryTheory.Functor D₂ D₃} {G₁₃ : CategoryTheory.Functor D₁ D₃} (β : G₁₂.comp G₂₃ ⟶ G₁₃) {L₁ : CategoryTheory.Functor C₁ D₁} {L₂ : CategoryTheory.Functor C₂ D₂} {L₃ : CategoryTheory.Functor C₃ D₃} (e₁₂ : F₁₂.comp L₂ ⟶ L₁.comp G₁₂) (e₂₃ : F₂₃.comp L₃ ⟶ L₂.comp G₂₃) (e₁₃ : F₁₃.comp L₃ ⟶ L₁.comp G₁₃) (A : Type u_7) [AddMonoid A] [CategoryTheory.HasShift C₁ A] [CategoryTheory.HasShift C₂ A] [CategoryTheory.HasShift C₃ A] [CategoryTheory.HasShift D₁ A] [CategoryTheory.HasShift D₂ A] [CategoryTheory.HasShift D₃ A] [F₁₂.CommShift A] [F₂₃.CommShift A] [F₁₃.CommShift A] [CategoryTheory.NatTrans.CommShift α A] [G₁₂.CommShift A] [G₂₃.CommShift A] [G₁₃.CommShift A] [CategoryTheory.NatTrans.CommShift β A] [L₁.CommShift A] [L₂.CommShift A] [L₃.CommShift A] [CategoryTheory.NatTrans.CommShift e₁₂ A] [CategoryTheory.NatTrans.CommShift e₂₃ A] (h₁₃ :
  e₁₃ =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight α L₃)
      (CategoryTheory.CategoryStruct.comp (F₁₂.associator F₂₃ L₃).hom
        (CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft F₁₂ e₂₃)
          (CategoryTheory.CategoryStruct.comp (F₁₂.associator L₂ G₂₃).inv
            (CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight e₁₂ G₂₃)
              (CategoryTheory.CategoryStruct.comp (L₁.associator G₁₂ G₂₃).hom (CategoryTheory.whiskerLeft L₁ β)))))))
Goal: CategoryTheory.NatTrans.CommShift e₁₃ A
-- CategoryTheory.HasShift.Induced.zero_hom_app_obj
@[simp]
lemma zero_hom_app_obj (X : C) :
    (zero F s i).hom.app (F.obj X) =
      (i 0).hom.app X ≫ F.map ((shiftFunctorZero C A).hom.app X) 
Arguments: {C : Type u_5} {D : Type u_2} [CategoryTheory.Category.{u_4, u_5} C] [CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_3} [AddMonoid A] [CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D) (i : (a : A) → F.comp (s a) ≅ (CategoryTheory.shiftFunctor C a).comp F) [((CategoryTheory.whiskeringLeft C D D).obj F).Full] [((CategoryTheory.whiskeringLeft C D D).obj F).Faithful] (X : C)
Goal: (CategoryTheory.HasShift.Induced.zero F s i).hom.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((i 0).hom.app X) (F.map ((CategoryTheory.shiftFunctorZero C A).hom.app X))
-- CategoryTheory.HasShift.Induced.zero_inv_app_obj
@[simp]
lemma zero_inv_app_obj (X : C) :
    (zero F s i).inv.app (F.obj X) =
      F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X 
Arguments: {C : Type u_4} {D : Type u_2} [CategoryTheory.Category.{u_3, u_4} C] [CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D) (i : (a : A) → F.comp (s a) ≅ (CategoryTheory.shiftFunctor C a).comp F) [((CategoryTheory.whiskeringLeft C D D).obj F).Full] [((CategoryTheory.whiskeringLeft C D D).obj F).Faithful] (X : C)
Goal: (CategoryTheory.HasShift.Induced.zero F s i).inv.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorZero C A).inv.app X)) ((i 0).inv.app X)
-- CategoryTheory.HasShift.Induced.add_hom_app_obj
@[simp]
lemma add_hom_app_obj (a b : A) (X : C) :
    (add F s i a b).hom.app (F.obj X) =
      (i (a + b)).hom.app X ≫ F.map ((shiftFunctorAdd C a b).hom.app X) ≫
        (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X) 
Arguments: {C : Type u_5} {D : Type u_2} [CategoryTheory.Category.{u_4, u_5} C] [CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_3} [AddMonoid A] [CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D) (i : (a : A) → F.comp (s a) ≅ (CategoryTheory.shiftFunctor C a).comp F) [((CategoryTheory.whiskeringLeft C D D).obj F).Full] [((CategoryTheory.whiskeringLeft C D D).obj F).Faithful] (a b : A) (X : C)
Goal: (CategoryTheory.HasShift.Induced.add F s i a b).hom.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((i (a + b)).hom.app X)
    (CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorAdd C a b).hom.app X))
      (CategoryTheory.CategoryStruct.comp ((i b).inv.app ((CategoryTheory.shiftFunctor C a).obj X))
        ((s b).map ((i a).inv.app X))))
-- CategoryTheory.HasShift.Induced.add_inv_app_obj
@[simp]
lemma add_inv_app_obj (a b : A) (X : C) :
    (add F s i a b).inv.app (F.obj X) =
      (s b).map ((i a).hom.app X) ≫ (i b).hom.app ((shiftFunctor C a).obj X) ≫
        F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X 
Arguments: {C : Type u_4} {D : Type u_2} [CategoryTheory.Category.{u_3, u_4} C] [CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D) (i : (a : A) → F.comp (s a) ≅ (CategoryTheory.shiftFunctor C a).comp F) [((CategoryTheory.whiskeringLeft C D D).obj F).Full] [((CategoryTheory.whiskeringLeft C D D).obj F).Faithful] (a b : A) (X : C)
Goal: (CategoryTheory.HasShift.Induced.add F s i a b).inv.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((s b).map ((i a).hom.app X))
    (CategoryTheory.CategoryStruct.comp ((i b).hom.app ((CategoryTheory.shiftFunctor C a).obj X))
      (CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorAdd C a b).inv.app X))
        ((i (a + b)).inv.app X)))
-- CategoryTheory.shiftFunctor_of_induced
@[simp]
lemma shiftFunctor_of_induced (a : A) :
    letI := HasShift.induced F A s i
    shiftFunctor D a = s a 
Arguments: {C : Type u_4} {D : Type u_1} [CategoryTheory.Category.{u_5, u_4} C] [CategoryTheory.Category.{u_2, u_1} D] (F : CategoryTheory.Functor C D) {A : Type u_3} [AddMonoid A] [CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D) (i : (a : A) → F.comp (s a) ≅ (CategoryTheory.shiftFunctor C a).comp F) [((CategoryTheory.whiskeringLeft C D D).obj F).Full] [((CategoryTheory.whiskeringLeft C D D).obj F).Faithful] (a : A)
Goal: CategoryTheory.shiftFunctor D a = s a
-- CategoryTheory.shiftFunctorZero_hom_app_obj_of_induced
@[simp]
lemma shiftFunctorZero_hom_app_obj_of_induced (X : C) :
    letI := HasShift.induced F A s i
    (shiftFunctorZero D A).hom.app (F.obj X) =
      (i 0).hom.app X ≫ F.map ((shiftFunctorZero C A).hom.app X) 
Arguments: {C : Type u_4} {D : Type u_2} [CategoryTheory.Category.{u_5, u_4} C] [CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (A : Type u_3) [AddMonoid A] [CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D) (i : (a : A) → F.comp (s a) ≅ (CategoryTheory.shiftFunctor C a).comp F) [((CategoryTheory.whiskeringLeft C D D).obj F).Full] [((CategoryTheory.whiskeringLeft C D D).obj F).Faithful] (X : C)
Goal: (CategoryTheory.shiftFunctorZero D A).hom.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((i 0).hom.app X) (F.map ((CategoryTheory.shiftFunctorZero C A).hom.app X))
-- CategoryTheory.shiftFunctorZero_inv_app_obj_of_induced
@[simp]
lemma shiftFunctorZero_inv_app_obj_of_induced (X : C) :
    letI := HasShift.induced F A s i
    (shiftFunctorZero D A).inv.app (F.obj X) =
      F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X 
Arguments: {C : Type u_4} {D : Type u_2} [CategoryTheory.Category.{u_3, u_4} C] [CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (A : Type u_5) [AddMonoid A] [CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D) (i : (a : A) → F.comp (s a) ≅ (CategoryTheory.shiftFunctor C a).comp F) [((CategoryTheory.whiskeringLeft C D D).obj F).Full] [((CategoryTheory.whiskeringLeft C D D).obj F).Faithful] (X : C)
Goal: (CategoryTheory.shiftFunctorZero D A).inv.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorZero C A).inv.app X)) ((i 0).inv.app X)
-- CategoryTheory.shiftFunctorAdd_hom_app_obj_of_induced
@[simp]
lemma shiftFunctorAdd_hom_app_obj_of_induced (a b : A) (X : C) :
    letI := HasShift.induced F A s i
    (shiftFunctorAdd D a b).hom.app (F.obj X) =
      (i (a + b)).hom.app X ≫
        F.map ((shiftFunctorAdd C a b).hom.app X) ≫
        (i b).inv.app ((shiftFunctor C a).obj X) ≫
        (s b).map ((i a).inv.app X) 
Arguments: {C : Type u_4} {D : Type u_2} [CategoryTheory.Category.{u_5, u_4} C] [CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_3} [AddMonoid A] [CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D) (i : (a : A) → F.comp (s a) ≅ (CategoryTheory.shiftFunctor C a).comp F) [((CategoryTheory.whiskeringLeft C D D).obj F).Full] [((CategoryTheory.whiskeringLeft C D D).obj F).Faithful] (a b : A) (X : C)
Goal: (CategoryTheory.shiftFunctorAdd D a b).hom.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((i (a + b)).hom.app X)
    (CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorAdd C a b).hom.app X))
      (CategoryTheory.CategoryStruct.comp ((i b).inv.app ((CategoryTheory.shiftFunctor C a).obj X))
        ((s b).map ((i a).inv.app X))))
-- CategoryTheory.shiftFunctorAdd_inv_app_obj_of_induced
@[simp]
lemma shiftFunctorAdd_inv_app_obj_of_induced (a b : A) (X : C) :
    letI := HasShift.induced F A s i
    (shiftFunctorAdd D a b).inv.app (F.obj X) =
      (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫
      F.map ((shiftFunctorAdd C a b).inv.app X) ≫
      (i (a + b)).inv.app X 
Arguments: {C : Type u_4} {D : Type u_2} [CategoryTheory.Category.{u_5, u_4} C] [CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_3} [AddMonoid A] [CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D) (i : (a : A) → F.comp (s a) ≅ (CategoryTheory.shiftFunctor C a).comp F) [((CategoryTheory.whiskeringLeft C D D).obj F).Full] [((CategoryTheory.whiskeringLeft C D D).obj F).Faithful] (a b : A) (X : C)
Goal: (CategoryTheory.shiftFunctorAdd D a b).inv.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((s b).map ((i a).hom.app X))
    (CategoryTheory.CategoryStruct.comp ((i b).hom.app ((CategoryTheory.shiftFunctor C a).obj X))
      (CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorAdd C a b).inv.app X))
        ((i (a + b)).inv.app X)))
-- CategoryTheory.Functor.commShiftIso_eq_ofInduced
lemma Functor.commShiftIso_eq_ofInduced (a : A) :
    letI := HasShift.induced F A s i
    letI := Functor.CommShift.ofInduced F A s i
    F.commShiftIso a = (i a).symm 
Arguments: {C : Type u_1} {D : Type u_3} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D) (A : Type u_5) [AddMonoid A] [CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D) (i : (a : A) → F.comp (s a) ≅ (CategoryTheory.shiftFunctor C a).comp F) [((CategoryTheory.whiskeringLeft C D D).obj F).Full] [((CategoryTheory.whiskeringLeft C D D).obj F).Faithful] (a : A)
Goal: F.commShiftIso a = (i a).symm
-- CategoryTheory.Limits.zeroProdIso_hom
@[simp]
theorem zeroProdIso_hom (X : C) : (zeroProdIso X).hom = prod.snd 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
Goal: (CategoryTheory.Limits.zeroProdIso X).hom = CategoryTheory.Limits.prod.snd
-- CategoryTheory.Limits.zeroProdIso_inv_snd
@[simp]
theorem zeroProdIso_inv_snd (X : C) : (zeroProdIso X).inv ≫ prod.snd = 𝟙 X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
Goal: (CategoryTheory.Limits.zeroProdIso X).inv ≫ CategoryTheory.Limits.prod.snd = 𝟙 X
-- CategoryTheory.Limits.prodZeroIso_hom
@[simp]
theorem prodZeroIso_hom (X : C) : (prodZeroIso X).hom = prod.fst 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
Goal: (CategoryTheory.Limits.prodZeroIso X).hom = CategoryTheory.Limits.prod.fst
-- CategoryTheory.Limits.prodZeroIso_iso_inv_snd
@[simp]
theorem prodZeroIso_iso_inv_snd (X : C) : (prodZeroIso X).inv ≫ prod.fst = 𝟙 X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
Goal: (CategoryTheory.Limits.prodZeroIso X).inv ≫ CategoryTheory.Limits.prod.fst = 𝟙 X
-- CategoryTheory.Limits.inr_zeroCoprodIso_hom
@[simp]
theorem inr_zeroCoprodIso_hom (X : C) : coprod.inr ≫ (zeroCoprodIso X).hom = 𝟙 X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
Goal: CategoryTheory.Limits.coprod.inr ≫ (CategoryTheory.Limits.zeroCoprodIso X).hom = 𝟙 X
-- CategoryTheory.Limits.zeroCoprodIso_inv
@[simp]
theorem zeroCoprodIso_inv (X : C) : (zeroCoprodIso X).inv = coprod.inr 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
Goal: (CategoryTheory.Limits.zeroCoprodIso X).inv = CategoryTheory.Limits.coprod.inr
-- CategoryTheory.Limits.inr_coprodZeroIso_hom
@[simp]
theorem inr_coprodZeroIso_hom (X : C) : coprod.inl ≫ (coprodZeroIso X).hom = 𝟙 X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
Goal: CategoryTheory.Limits.coprod.inl ≫ (CategoryTheory.Limits.coprodZeroIso X).hom = 𝟙 X
-- CategoryTheory.Limits.coprodZeroIso_inv
@[simp]
theorem coprodZeroIso_inv (X : C) : (coprodZeroIso X).inv = coprod.inl 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X : C)
Goal: (CategoryTheory.Limits.coprodZeroIso X).inv = CategoryTheory.Limits.coprod.inl
-- CategoryTheory.Limits.pullbackZeroZeroIso_inv_fst
@[simp]
theorem pullbackZeroZeroIso_inv_fst (X Y : C) [HasBinaryProduct X Y] :
    (pullbackZeroZeroIso X Y).inv ≫ pullback.fst 0 0 = prod.fst 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [CategoryTheory.Limits.HasBinaryProduct X Y]
Goal: (CategoryTheory.Limits.pullbackZeroZeroIso X Y).inv ≫ CategoryTheory.Limits.pullback.fst 0 0 =
  CategoryTheory.Limits.prod.fst
-- CategoryTheory.Limits.pullbackZeroZeroIso_inv_snd
@[simp]
theorem pullbackZeroZeroIso_inv_snd (X Y : C) [HasBinaryProduct X Y] :
    (pullbackZeroZeroIso X Y).inv ≫ pullback.snd 0 0 = prod.snd 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [CategoryTheory.Limits.HasBinaryProduct X Y]
Goal: (CategoryTheory.Limits.pullbackZeroZeroIso X Y).inv ≫ CategoryTheory.Limits.pullback.snd 0 0 =
  CategoryTheory.Limits.prod.snd
-- CategoryTheory.Limits.pullbackZeroZeroIso_hom_fst
@[simp]
theorem pullbackZeroZeroIso_hom_fst (X Y : C) [HasBinaryProduct X Y] :
    (pullbackZeroZeroIso X Y).hom ≫ prod.fst = pullback.fst 0 0 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) [CategoryTheory.Limits.HasBinaryProduct X Y]
Goal: (CategoryTheory.Limits.pullbackZeroZeroIso X Y).hom ≫ CategoryTheory.Limits.prod.fst =
  CategoryTheory.Limits.pullback.fst 0 0