ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.CompleteLattice.limit_eq_iInf
theorem limit_eq_iInf (F : J ⥤ α) : limit F = iInf F.obj 
Arguments: {α : Type u} [CompleteLattice α] {J : Type u} [CategoryTheory.SmallCategory J] (F : J ⥤ α)
Goal: CategoryTheory.Limits.limit F = iInf F.obj
-- CategoryTheory.Limits.CompleteLattice.colimit_eq_iSup
theorem colimit_eq_iSup (F : J ⥤ α) : colimit F = iSup F.obj 
Arguments: {α : Type u} [CompleteLattice α] {J : Type u} [CategoryTheory.SmallCategory J] (F : J ⥤ α)
Goal: CategoryTheory.Limits.colimit F = iSup F.obj
-- CategoryTheory.Limits.HasEqualizersOfHasPullbacksAndBinaryProducts.pullbackFst_eq_pullback_snd
theorem pullbackFst_eq_pullback_snd (F : WalkingParallelPair ⥤ C) :
    pullbackFst F = pullback.snd _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryProducts C] [CategoryTheory.Limits.HasPullbacks C] (F : CategoryTheory.Limits.WalkingParallelPair ⥤ C)
Goal: CategoryTheory.Limits.HasEqualizersOfHasPullbacksAndBinaryProducts.pullbackFst F =
  CategoryTheory.Limits.pullback.snd
    (CategoryTheory.Limits.prod.lift (𝟙 (F.obj CategoryTheory.Limits.WalkingParallelPair.zero))
      (F.map CategoryTheory.Limits.WalkingParallelPairHom.left))
    (CategoryTheory.Limits.prod.lift (𝟙 (F.obj CategoryTheory.Limits.WalkingParallelPair.zero))
      (F.map CategoryTheory.Limits.WalkingParallelPairHom.right))
-- CategoryTheory.Limits.hasEqualizers_of_hasPullbacks_and_binary_products
theorem hasEqualizers_of_hasPullbacks_and_binary_products [HasBinaryProducts C] [HasPullbacks C] :
    HasEqualizers C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryProducts C] [CategoryTheory.Limits.HasPullbacks C]
Goal: CategoryTheory.Limits.HasEqualizers C
-- CategoryTheory.Limits.HasCoequalizersOfHasPushoutsAndBinaryCoproducts.pushoutInl_eq_pushout_inr
theorem pushoutInl_eq_pushout_inr (F : WalkingParallelPair ⥤ C) :
    pushoutInl F = pushout.inr _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryCoproducts C] [CategoryTheory.Limits.HasPushouts C] (F : CategoryTheory.Limits.WalkingParallelPair ⥤ C)
Goal: CategoryTheory.Limits.HasCoequalizersOfHasPushoutsAndBinaryCoproducts.pushoutInl F =
  CategoryTheory.Limits.pushout.inr
    (CategoryTheory.Limits.coprod.desc (𝟙 (F.obj CategoryTheory.Limits.WalkingParallelPair.one))
      (F.map CategoryTheory.Limits.WalkingParallelPairHom.left))
    (CategoryTheory.Limits.coprod.desc (𝟙 (F.obj CategoryTheory.Limits.WalkingParallelPair.one))
      (F.map CategoryTheory.Limits.WalkingParallelPairHom.right))
-- CategoryTheory.Limits.hasCoequalizers_of_hasPushouts_and_binary_coproducts
theorem hasCoequalizers_of_hasPushouts_and_binary_coproducts [HasBinaryCoproducts C]
    [HasPushouts C] : HasCoequalizers C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryCoproducts C] [CategoryTheory.Limits.HasPushouts C]
Goal: CategoryTheory.Limits.HasCoequalizers C
-- CategoryTheory.Coyoneda.colimitCocone_pt
@[simps]
def colimitCocone (X : Cᵒᵖ) : Cocone (coyoneda.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : Cᵒᵖ)
Goal: (CategoryTheory.Coyoneda.colimitCocone X).pt = PUnit.{v + 1}
-- CategoryTheory.Coyoneda.colimitCocone_ι_app
@[simps]
def colimitCocone (X : Cᵒᵖ) : Cocone (coyoneda.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : Cᵒᵖ) (X_1 : C) (a : (CategoryTheory.coyoneda.obj X).obj X_1)
Goal: (CategoryTheory.Coyoneda.colimitCocone X).ι.app X_1 a = id PUnit.unit
-- CategoryTheory.Coyoneda.colimitCoconeIsColimit_desc
@[simps]
def colimitCoconeIsColimit (X : Cᵒᵖ) : IsColimit (colimitCocone X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (X : Cᵒᵖ) (s : CategoryTheory.Limits.Cocone (CategoryTheory.coyoneda.obj X))
Goal: ∀ (x : (CategoryTheory.Coyoneda.colimitCocone X).pt),
  (CategoryTheory.Coyoneda.colimitCoconeIsColimit X).desc s x = s.ι.app (Opposite.unop X) (𝟙 (Opposite.unop X))
-- CategoryTheory.Limits.coneOfSectionCompYoneda_pt
@[simps]
def Limits.coneOfSectionCompYoneda (F : J ⥤ Cᵒᵖ) (X : C)
    (s : (F ⋙ yoneda.obj X).sections) : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type w} [CategoryTheory.Category.{t, w} J] (F : J ⥤ Cᵒᵖ) (X : C) (s : ↑(F ⋙ CategoryTheory.yoneda.obj X).sections)
Goal: (CategoryTheory.Limits.coneOfSectionCompYoneda F X s).pt = Opposite.op X
-- CategoryTheory.Limits.coneOfSectionCompYoneda_π
@[simps]
def Limits.coneOfSectionCompYoneda (F : J ⥤ Cᵒᵖ) (X : C)
    (s : (F ⋙ yoneda.obj X).sections) : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type w} [CategoryTheory.Category.{t, w} J] (F : J ⥤ Cᵒᵖ) (X : C) (s : ↑(F ⋙ CategoryTheory.yoneda.obj X).sections)
Goal: (CategoryTheory.Limits.coneOfSectionCompYoneda F X s).π = (CategoryTheory.Limits.compYonedaSectionsEquiv F X) s
-- CategoryTheory.Limits.coneOfSectionCompCoyoneda_pt
@[simps]
def Limits.coneOfSectionCompCoyoneda (F : J ⥤ C) (X : Cᵒᵖ)
    (s : (F ⋙ coyoneda.obj X).sections) : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type w} [CategoryTheory.Category.{t, w} J] (F : J ⥤ C) (X : Cᵒᵖ) (s : ↑(F ⋙ CategoryTheory.coyoneda.obj X).sections)
Goal: (CategoryTheory.Limits.coneOfSectionCompCoyoneda F X s).pt = Opposite.unop X
-- CategoryTheory.Limits.coneOfSectionCompCoyoneda_π
@[simps]
def Limits.coneOfSectionCompCoyoneda (F : J ⥤ C) (X : Cᵒᵖ)
    (s : (F ⋙ coyoneda.obj X).sections) : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type w} [CategoryTheory.Category.{t, w} J] (F : J ⥤ C) (X : Cᵒᵖ) (s : ↑(F ⋙ CategoryTheory.coyoneda.obj X).sections)
Goal: (CategoryTheory.Limits.coneOfSectionCompCoyoneda F X s).π =
  (CategoryTheory.Limits.compCoyonedaSectionsEquiv F (Opposite.unop X)) s
-- CategoryTheory.hasInitial_of_equivalence
theorem hasInitial_of_equivalence (e : D ⥤ C) [e.IsEquivalence] [HasInitial C] : HasInitial D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : D ⥤ C) [e.IsEquivalence] [CategoryTheory.Limits.HasInitial C]
Goal: CategoryTheory.Limits.HasInitial D
-- CategoryTheory.Equivalence.hasInitial_iff
theorem Equivalence.hasInitial_iff (e : C ≌ D) : HasInitial C ↔ HasInitial D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: CategoryTheory.Limits.HasInitial C ↔ CategoryTheory.Limits.HasInitial D
-- CategoryTheory.hasTerminal_of_equivalence
theorem hasTerminal_of_equivalence (e : D ⥤ C) [e.IsEquivalence] [HasTerminal C] : HasTerminal D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : D ⥤ C) [e.IsEquivalence] [CategoryTheory.Limits.HasTerminal C]
Goal: CategoryTheory.Limits.HasTerminal D
-- CategoryTheory.Equivalence.hasTerminal_iff
theorem Equivalence.hasTerminal_iff (e : C ≌ D) : HasTerminal C ↔ HasTerminal D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D)
Goal: CategoryTheory.Limits.HasTerminal C ↔ CategoryTheory.Limits.HasTerminal D
-- CategoryTheory.ShiftMkCore.assoc_hom_app
structure ShiftMkCore where
    F : A → C ⥤ C
    zero : F 0 ≅ 𝟭 C
    add : ∀ n m : A, F (n + m) ≅ F n ⋙ F m
    assoc_hom_app : ∀ (m₁ m₂ m₃ : A) (X : C),
    (add (m₁ + m₂) m₃).hom.app X ≫ (F m₃).map ((add m₁ m₂).hom.app X) =
      eqToHom (by rw [add_assoc]) ≫ (add m₁ (m₂ + m₃)).hom.app X ≫
        (add m₂ m₃).hom.app ((F m₁).obj X) := by aesop_cat
    zero_add_hom_app : ∀ (n : A) (X : C), (add 0 n).hom.app X =
    eqToHom (by dsimp; rw [zero_add]) ≫ (F n).map (zero.inv.app X) := by aesop_cat
    add_zero_hom_app : ∀ (n : A) (X : C), (add n 0).hom.app X =
    eqToHom (by dsimp; rw [add_zero]) ≫ zero.inv.app ((F n).obj X) := by aesop_cat
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] (self : CategoryTheory.ShiftMkCore C A) (m₁ m₂ m₃ : A) (X : C)
Goal: CategoryTheory.CategoryStruct.comp ((self.add (m₁ + m₂) m₃).hom.app X) ((self.F m₃).map ((self.add m₁ m₂).hom.app X)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    (CategoryTheory.CategoryStruct.comp ((self.add m₁ (m₂ + m₃)).hom.app X)
      ((self.add m₂ m₃).hom.app ((self.F m₁).obj X)))
-- CategoryTheory.ShiftMkCore.add_zero_hom_app
structure ShiftMkCore where
    F : A → C ⥤ C
    zero : F 0 ≅ 𝟭 C
    add : ∀ n m : A, F (n + m) ≅ F n ⋙ F m
    assoc_hom_app : ∀ (m₁ m₂ m₃ : A) (X : C),
    (add (m₁ + m₂) m₃).hom.app X ≫ (F m₃).map ((add m₁ m₂).hom.app X) =
      eqToHom (by rw [add_assoc]) ≫ (add m₁ (m₂ + m₃)).hom.app X ≫
        (add m₂ m₃).hom.app ((F m₁).obj X) := by aesop_cat
    zero_add_hom_app : ∀ (n : A) (X : C), (add 0 n).hom.app X =
    eqToHom (by dsimp; rw [zero_add]) ≫ (F n).map (zero.inv.app X) := by aesop_cat
    add_zero_hom_app : ∀ (n : A) (X : C), (add n 0).hom.app X =
    eqToHom (by dsimp; rw [add_zero]) ≫ zero.inv.app ((F n).obj X) := by aesop_cat
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] (self : CategoryTheory.ShiftMkCore C A) (n : A) (X : C)
Goal: (self.add n 0).hom.app X =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (self.zero.inv.app ((self.F n).obj X))
-- CategoryTheory.ShiftMkCore.zero_add_hom_app
structure ShiftMkCore where
    F : A → C ⥤ C
    zero : F 0 ≅ 𝟭 C
    add : ∀ n m : A, F (n + m) ≅ F n ⋙ F m
    assoc_hom_app : ∀ (m₁ m₂ m₃ : A) (X : C),
    (add (m₁ + m₂) m₃).hom.app X ≫ (F m₃).map ((add m₁ m₂).hom.app X) =
      eqToHom (by rw [add_assoc]) ≫ (add m₁ (m₂ + m₃)).hom.app X ≫
        (add m₂ m₃).hom.app ((F m₁).obj X) := by aesop_cat
    zero_add_hom_app : ∀ (n : A) (X : C), (add 0 n).hom.app X =
    eqToHom (by dsimp; rw [zero_add]) ≫ (F n).map (zero.inv.app X) := by aesop_cat
    add_zero_hom_app : ∀ (n : A) (X : C), (add n 0).hom.app X =
    eqToHom (by dsimp; rw [add_zero]) ≫ zero.inv.app ((F n).obj X) := by aesop_cat
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] (self : CategoryTheory.ShiftMkCore C A) (n : A) (X : C)
Goal: (self.add 0 n).hom.app X =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) ((self.F n).map (self.zero.inv.app X))
-- CategoryTheory.ShiftMkCore.assoc_inv_app
@[reassoc]
lemma assoc_inv_app (h : ShiftMkCore C A) (m₁ m₂ m₃ : A) (X : C) :
    (h.F m₃).map ((h.add m₁ m₂).inv.app X) ≫ (h.add (m₁ + m₂) m₃).inv.app X =
    (h.add m₂ m₃).inv.app ((h.F m₁).obj X) ≫ (h.add m₁ (m₂ + m₃)).inv.app X ≫
      eqToHom (by rw [add_assoc]) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] (h : CategoryTheory.ShiftMkCore C A) (m₁ m₂ m₃ : A) (X : C)
Goal: CategoryTheory.CategoryStruct.comp ((h.F m₃).map ((h.add m₁ m₂).inv.app X)) ((h.add (m₁ + m₂) m₃).inv.app X) =
  CategoryTheory.CategoryStruct.comp ((h.add m₂ m₃).inv.app ((h.F m₁).obj X))
    (CategoryTheory.CategoryStruct.comp ((h.add m₁ (m₂ + m₃)).inv.app X) (CategoryTheory.eqToHom ⋯))
-- CategoryTheory.ShiftMkCore.zero_add_inv_app
lemma zero_add_inv_app (h : ShiftMkCore C A) (n : A) (X : C) :
    (h.add 0 n).inv.app X = (h.F n).map (h.zero.hom.app X) ≫
      eqToHom (by dsimp; rw [zero_add]) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] (h : CategoryTheory.ShiftMkCore C A) (n : A) (X : C)
Goal: (h.add 0 n).inv.app X = CategoryTheory.CategoryStruct.comp ((h.F n).map (h.zero.hom.app X)) (CategoryTheory.eqToHom ⋯)
-- CategoryTheory.ShiftMkCore.add_zero_inv_app
lemma add_zero_inv_app (h : ShiftMkCore C A) (n : A) (X : C) :
    (h.add n 0).inv.app X = h.zero.hom.app ((h.F n).obj X) ≫
      eqToHom (by dsimp; rw [add_zero]) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] (h : CategoryTheory.ShiftMkCore C A) (n : A) (X : C)
Goal: (h.add n 0).inv.app X = CategoryTheory.CategoryStruct.comp (h.zero.hom.app ((h.F n).obj X)) (CategoryTheory.eqToHom ⋯)
-- CategoryTheory.hasShiftMk_shift_toLaxMonoidalFunctor_toFunctor
@[simps]
def hasShiftMk (h : ShiftMkCore C A) : HasShift C A 
Arguments: (C : Type u) (A : Type u_1) [CategoryTheory.Category.{v, u} C] [AddMonoid A] (h : CategoryTheory.ShiftMkCore C A)
Goal: CategoryTheory.HasShift.shift.toFunctor = CategoryTheory.Discrete.functor h.F
-- CategoryTheory.hasShiftMk_shift_toLaxMonoidalFunctor_μ
@[simps]
def hasShiftMk (h : ShiftMkCore C A) : HasShift C A 
Arguments: (C : Type u) (A : Type u_1) [CategoryTheory.Category.{v, u} C] [AddMonoid A] (h : CategoryTheory.ShiftMkCore C A) (m n : CategoryTheory.Discrete A)
Goal: CategoryTheory.HasShift.shift.μ m n = (h.add m.as n.as).inv
-- CategoryTheory.hasShiftMk_shift_toLaxMonoidalFunctor_ε
@[simps]
def hasShiftMk (h : ShiftMkCore C A) : HasShift C A 
Arguments: (C : Type u) (A : Type u_1) [CategoryTheory.Category.{v, u} C] [AddMonoid A] (h : CategoryTheory.ShiftMkCore C A)
Goal: CategoryTheory.HasShift.shift.ε = h.zero.inv
-- CategoryTheory.shiftFunctorAdd'_eq_shiftFunctorAdd
lemma shiftFunctorAdd'_eq_shiftFunctorAdd (i j : A) :
    shiftFunctorAdd' C i j (i+j) rfl = shiftFunctorAdd C i j 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (i j : A)
Goal: CategoryTheory.shiftFunctorAdd' C i j (i + j) ⋯ = CategoryTheory.shiftFunctorAdd C i j
-- CategoryTheory.ShiftMkCore.shiftFunctor_eq
lemma ShiftMkCore.shiftFunctor_eq (h : ShiftMkCore C A) (a : A) :
    letI := hasShiftMk C A h
    shiftFunctor C a = h.F a 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] (h : CategoryTheory.ShiftMkCore C A) (a : A)
Goal: CategoryTheory.shiftFunctor C a = h.F a
-- CategoryTheory.ShiftMkCore.shiftFunctorZero_eq
lemma ShiftMkCore.shiftFunctorZero_eq (h : ShiftMkCore C A) :
    letI := hasShiftMk C A h
    shiftFunctorZero C A = h.zero 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] (h : CategoryTheory.ShiftMkCore C A)
Goal: CategoryTheory.shiftFunctorZero C A = h.zero
-- CategoryTheory.ShiftMkCore.shiftFunctorAdd_eq
lemma ShiftMkCore.shiftFunctorAdd_eq (h : ShiftMkCore C A) (a b : A) :
    letI := hasShiftMk C A h
    shiftFunctorAdd C a b = h.add a b 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] (h : CategoryTheory.ShiftMkCore C A) (a b : A)
Goal: CategoryTheory.shiftFunctorAdd C a b = h.add a b
-- CategoryTheory.shiftFunctorAdd'_zero_add
lemma shiftFunctorAdd'_zero_add (a : A) :
    shiftFunctorAdd' C 0 a a (zero_add a) = (Functor.leftUnitor _).symm ≪≫
    isoWhiskerRight (shiftFunctorZero C A).symm (shiftFunctor C a) 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a : A)
Goal: CategoryTheory.shiftFunctorAdd' C 0 a a ⋯ =
  (CategoryTheory.shiftFunctor C a).leftUnitor.symm ≪≫
    CategoryTheory.isoWhiskerRight (CategoryTheory.shiftFunctorZero C A).symm (CategoryTheory.shiftFunctor C a)
-- CategoryTheory.shiftFunctorAdd'_add_zero
lemma shiftFunctorAdd'_add_zero (a : A) :
    shiftFunctorAdd' C a 0 a (add_zero a) = (Functor.rightUnitor _).symm ≪≫
    isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a : A)
Goal: CategoryTheory.shiftFunctorAdd' C a 0 a ⋯ =
  (CategoryTheory.shiftFunctor C a).rightUnitor.symm ≪≫
    CategoryTheory.isoWhiskerLeft (CategoryTheory.shiftFunctor C a) (CategoryTheory.shiftFunctorZero C A).symm
-- CategoryTheory.shiftFunctorAdd'_assoc
lemma shiftFunctorAdd'_assoc (a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A)
    (h₁₂ : a₁ + a₂ = a₁₂) (h₂₃ : a₂ + a₃ = a₂₃) (h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃) :
    shiftFunctorAdd' C a₁₂ a₃ a₁₂₃ (by rw [← h₁₂, h₁₂₃]) ≪≫
      isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂) _ ≪≫ Functor.associator _ _ _ =
    shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ (by rw [← h₂₃, ← add_assoc, h₁₂₃]) ≪≫
      isoWhiskerLeft _ (shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃) 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A) (h₁₂ : a₁ + a₂ = a₁₂) (h₂₃ : a₂ + a₃ = a₂₃) (h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃)
Goal: CategoryTheory.shiftFunctorAdd' C a₁₂ a₃ a₁₂₃ ⋯ ≪≫
    CategoryTheory.isoWhiskerRight (CategoryTheory.shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂)
        (CategoryTheory.shiftFunctor C a₃) ≪≫
      (CategoryTheory.shiftFunctor C a₁).associator (CategoryTheory.shiftFunctor C a₂)
        (CategoryTheory.shiftFunctor C a₃) =
  CategoryTheory.shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ ⋯ ≪≫
    CategoryTheory.isoWhiskerLeft (CategoryTheory.shiftFunctor C a₁) (CategoryTheory.shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃)
-- CategoryTheory.shiftFunctorAdd_assoc
lemma shiftFunctorAdd_assoc (a₁ a₂ a₃ : A) :
    shiftFunctorAdd C (a₁ + a₂) a₃ ≪≫
      isoWhiskerRight (shiftFunctorAdd C a₁ a₂) _ ≪≫ Functor.associator _ _ _ =
    shiftFunctorAdd' C a₁ (a₂ + a₃) _ (add_assoc a₁ a₂ a₃).symm ≪≫
      isoWhiskerLeft _ (shiftFunctorAdd C a₂ a₃) 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a₁ a₂ a₃ : A)
Goal: CategoryTheory.shiftFunctorAdd C (a₁ + a₂) a₃ ≪≫
    CategoryTheory.isoWhiskerRight (CategoryTheory.shiftFunctorAdd C a₁ a₂) (CategoryTheory.shiftFunctor C a₃) ≪≫
      (CategoryTheory.shiftFunctor C a₁).associator (CategoryTheory.shiftFunctor C a₂)
        (CategoryTheory.shiftFunctor C a₃) =
  CategoryTheory.shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯ ≪≫
    CategoryTheory.isoWhiskerLeft (CategoryTheory.shiftFunctor C a₁) (CategoryTheory.shiftFunctorAdd C a₂ a₃)
-- CategoryTheory.shiftFunctorAdd'_zero_add_hom_app
lemma shiftFunctorAdd'_zero_add_hom_app (a : A) (X : C) :
    (shiftFunctorAdd' C 0 a a (zero_add a)).hom.app X =
    ((shiftFunctorZero C A).inv.app X)⟦a⟧' 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: (CategoryTheory.shiftFunctorAdd' C 0 a a ⋯).hom.app X =
  (CategoryTheory.shiftFunctor C a).map ((CategoryTheory.shiftFunctorZero C A).inv.app X)
-- CategoryTheory.shiftFunctorAdd_zero_add_hom_app
lemma shiftFunctorAdd_zero_add_hom_app (a : A) (X : C) :
    (shiftFunctorAdd C 0 a).hom.app X =
    eqToHom (by dsimp; rw [zero_add]) ≫ ((shiftFunctorZero C A).inv.app X)⟦a⟧' 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: (CategoryTheory.shiftFunctorAdd C 0 a).hom.app X =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    ((CategoryTheory.shiftFunctor C a).map ((CategoryTheory.shiftFunctorZero C A).inv.app X))
-- CategoryTheory.shiftFunctorAdd'_zero_add_inv_app
lemma shiftFunctorAdd'_zero_add_inv_app (a : A) (X : C) :
    (shiftFunctorAdd' C 0 a a (zero_add a)).inv.app X =
    ((shiftFunctorZero C A).hom.app X)⟦a⟧' 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: (CategoryTheory.shiftFunctorAdd' C 0 a a ⋯).inv.app X =
  (CategoryTheory.shiftFunctor C a).map ((CategoryTheory.shiftFunctorZero C A).hom.app X)
-- CategoryTheory.shiftFunctorAdd_zero_add_inv_app
lemma shiftFunctorAdd_zero_add_inv_app (a : A) (X : C) : (shiftFunctorAdd C 0 a).inv.app X =
    ((shiftFunctorZero C A).hom.app X)⟦a⟧' ≫ eqToHom (by dsimp; rw [zero_add]) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: (CategoryTheory.shiftFunctorAdd C 0 a).inv.app X =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor C a).map ((CategoryTheory.shiftFunctorZero C A).hom.app X)) (CategoryTheory.eqToHom ⋯)
-- CategoryTheory.shiftFunctorAdd'_add_zero_hom_app
lemma shiftFunctorAdd'_add_zero_hom_app (a : A) (X : C) :
    (shiftFunctorAdd' C a 0 a (add_zero a)).hom.app X =
    (shiftFunctorZero C A).inv.app (X⟦a⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: (CategoryTheory.shiftFunctorAdd' C a 0 a ⋯).hom.app X =
  (CategoryTheory.shiftFunctorZero C A).inv.app ((CategoryTheory.shiftFunctor C a).obj X)
-- CategoryTheory.shiftFunctorAdd_add_zero_hom_app
lemma shiftFunctorAdd_add_zero_hom_app (a : A) (X : C) : (shiftFunctorAdd C a 0).hom.app X =
    eqToHom (by dsimp; rw [add_zero]) ≫ (shiftFunctorZero C A).inv.app (X⟦a⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: (CategoryTheory.shiftFunctorAdd C a 0).hom.app X =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
    ((CategoryTheory.shiftFunctorZero C A).inv.app ((CategoryTheory.shiftFunctor C a).obj X))
-- CategoryTheory.shiftFunctorAdd'_add_zero_inv_app
lemma shiftFunctorAdd'_add_zero_inv_app (a : A) (X : C) :
    (shiftFunctorAdd' C a 0 a (add_zero a)).inv.app X =
    (shiftFunctorZero C A).hom.app (X⟦a⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: (CategoryTheory.shiftFunctorAdd' C a 0 a ⋯).inv.app X =
  (CategoryTheory.shiftFunctorZero C A).hom.app ((CategoryTheory.shiftFunctor C a).obj X)
-- CategoryTheory.shiftFunctorAdd_add_zero_inv_app
lemma shiftFunctorAdd_add_zero_inv_app (a : A) (X : C) : (shiftFunctorAdd C a 0).inv.app X =
    (shiftFunctorZero C A).hom.app (X⟦a⟧) ≫ eqToHom (by dsimp; rw [add_zero]) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: (CategoryTheory.shiftFunctorAdd C a 0).inv.app X =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctorZero C A).hom.app ((CategoryTheory.shiftFunctor C a).obj X)) (CategoryTheory.eqToHom ⋯)
-- CategoryTheory.shiftFunctorAdd'_assoc_hom_app
@[reassoc]
lemma shiftFunctorAdd'_assoc_hom_app (a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A)
    (h₁₂ : a₁ + a₂ = a₁₂) (h₂₃ : a₂ + a₃ = a₂₃) (h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃) (X : C) :
    (shiftFunctorAdd' C a₁₂ a₃ a₁₂₃ (by rw [← h₁₂, h₁₂₃])).hom.app X ≫
      ((shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂).hom.app X)⟦a₃⟧' =
    (shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ (by rw [← h₂₃, ← add_assoc, h₁₂₃])).hom.app X ≫
      (shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃).hom.app (X⟦a₁⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A) (h₁₂ : a₁ + a₂ = a₁₂) (h₂₃ : a₂ + a₃ = a₂₃) (h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃) (X : C)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd' C a₁₂ a₃ a₁₂₃ ⋯).hom.app X)
    ((CategoryTheory.shiftFunctor C a₃).map ((CategoryTheory.shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂).hom.app X)) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ ⋯).hom.app X)
    ((CategoryTheory.shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃).hom.app ((CategoryTheory.shiftFunctor C a₁).obj X))
-- CategoryTheory.shiftFunctorAdd'_assoc_inv_app
@[reassoc]
lemma shiftFunctorAdd'_assoc_inv_app (a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A)
    (h₁₂ : a₁ + a₂ = a₁₂) (h₂₃ : a₂ + a₃ = a₂₃) (h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃) (X : C) :
    ((shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂).inv.app X)⟦a₃⟧' ≫
      (shiftFunctorAdd' C a₁₂ a₃ a₁₂₃ (by rw [← h₁₂, h₁₂₃])).inv.app X =
    (shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃).inv.app (X⟦a₁⟧) ≫
      (shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ (by rw [← h₂₃, ← add_assoc, h₁₂₃])).inv.app X 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A) (h₁₂ : a₁ + a₂ = a₁₂) (h₂₃ : a₂ + a₃ = a₂₃) (h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃) (X : C)
Goal: CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor C a₃).map ((CategoryTheory.shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂).inv.app X))
    ((CategoryTheory.shiftFunctorAdd' C a₁₂ a₃ a₁₂₃ ⋯).inv.app X) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃).inv.app ((CategoryTheory.shiftFunctor C a₁).obj X))
    ((CategoryTheory.shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ ⋯).inv.app X)