ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.BasedFunctor.isHomLift_iff
lemma isHomLift_iff : IsHomLift 𝒴.p f (F.map φ) ↔ IsHomLift 𝒳.p f φ 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴) {R S : 𝒮} {a b : 𝒳.obj} (f : R ⟶ S) (φ : a ⟶ b)
Goal: 𝒴.p.IsHomLift f (F.map φ) ↔ 𝒳.p.IsHomLift f φ
-- CategoryTheory.BasedNatTrans.isHomLift'
structure BasedNatTrans {𝒳 : BasedCategory.{v₂, u₂} 𝒮} {𝒴 : BasedCategory.{v₃, u₃} 𝒮}
    (F G : 𝒳 ⥤ᵇ 𝒴) extends CategoryTheory.NatTrans F.toFunctor G.toFunctor where
  isHomLift' : ∀ (a : 𝒳.obj), IsHomLift 𝒴.p (𝟙 (𝒳.p.obj a)) (toNatTrans.app a) := by aesop_cat
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} {F G : CategoryTheory.BasedFunctor 𝒳 𝒴} (self : CategoryTheory.BasedNatTrans F G) (a : 𝒳.obj)
Goal: 𝒴.p.IsHomLift (CategoryTheory.CategoryStruct.id (𝒳.p.obj a)) (self.app a)
-- CategoryTheory.BasedNatTrans.ext
@[ext]
lemma ext (β : BasedNatTrans F G) (h : α.toNatTrans = β.toNatTrans) : α = β 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} {F G : CategoryTheory.BasedFunctor 𝒳 𝒴} (α β : CategoryTheory.BasedNatTrans F G) (h : α.toNatTrans = β.toNatTrans)
Goal: α = β
-- CategoryTheory.BasedNatTrans.isHomLift
lemma isHomLift {a : 𝒳.obj} {S : 𝒮} (ha : 𝒳.p.obj a = S) :
    IsHomLift 𝒴.p (𝟙 S) (α.toNatTrans.app a) 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} {F G : CategoryTheory.BasedFunctor 𝒳 𝒴} (α : CategoryTheory.BasedNatTrans F G) {a : 𝒳.obj} {S : 𝒮} (ha : 𝒳.p.obj a = S)
Goal: 𝒴.p.IsHomLift (CategoryTheory.CategoryStruct.id S) (α.app a)
-- CategoryTheory.BasedNatTrans.id_toNatTrans
@[simps]
def id (F : 𝒳 ⥤ᵇ 𝒴) : BasedNatTrans F F 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴)
Goal: (CategoryTheory.BasedNatTrans.id F).toNatTrans = CategoryTheory.NatTrans.id F.toFunctor
-- CategoryTheory.BasedNatTrans.comp_toNatTrans
@[simps]
def comp {F G H : 𝒳 ⥤ᵇ 𝒴} (α : BasedNatTrans F G) (β : BasedNatTrans G H) : BasedNatTrans F H 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} {F G H : CategoryTheory.BasedFunctor 𝒳 𝒴} (α : CategoryTheory.BasedNatTrans F G) (β : CategoryTheory.BasedNatTrans G H)
Goal: (α.comp β).toNatTrans = α.vcomp β.toNatTrans
-- CategoryTheory.BasedNatTrans.homCategory_comp
@[simps]
instance homCategory (𝒳 : BasedCategory.{v₂, u₂} 𝒮) (𝒴 : BasedCategory.{v₃, u₃} 𝒮) :
    Category (𝒳 ⥤ᵇ 𝒴) 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] (𝒳 : CategoryTheory.BasedCategory 𝒮) (𝒴 : CategoryTheory.BasedCategory 𝒮)
Goal: ∀ {X Y Z : CategoryTheory.BasedFunctor 𝒳 𝒴} (α : CategoryTheory.BasedNatTrans X Y)
  (β : CategoryTheory.BasedNatTrans Y Z), CategoryTheory.CategoryStruct.comp α β = α.comp β
-- CategoryTheory.BasedNatTrans.homCategory_id
@[simps]
instance homCategory (𝒳 : BasedCategory.{v₂, u₂} 𝒮) (𝒴 : BasedCategory.{v₃, u₃} 𝒮) :
    Category (𝒳 ⥤ᵇ 𝒴) 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] (𝒳 : CategoryTheory.BasedCategory 𝒮) (𝒴 : CategoryTheory.BasedCategory 𝒮) (F : CategoryTheory.BasedFunctor 𝒳 𝒴)
Goal: CategoryTheory.CategoryStruct.id F = CategoryTheory.BasedNatTrans.id F
-- CategoryTheory.BasedNatTrans.homCategory.ext
@[ext]
lemma homCategory.ext {F G : 𝒳 ⥤ᵇ 𝒴} (α β : F ⟶ G) (h : α.toNatTrans = β.toNatTrans) : α = β 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} {F G : CategoryTheory.BasedFunctor 𝒳 𝒴} (α β : F ⟶ G) (h : α.toNatTrans = β.toNatTrans)
Goal: α = β
-- CategoryTheory.BasedNatTrans.forgetful_map
@[simps]
def forgetful (𝒳 : BasedCategory.{v₂, u₂} 𝒮) (𝒴 : BasedCategory.{v₃, u₃} 𝒮) :
    (𝒳 ⥤ᵇ 𝒴) ⥤ (𝒳.obj ⥤ 𝒴.obj) 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] (𝒳 : CategoryTheory.BasedCategory 𝒮) (𝒴 : CategoryTheory.BasedCategory 𝒮)
Goal: ∀ {X Y : CategoryTheory.BasedFunctor 𝒳 𝒴} (α : X ⟶ Y), (CategoryTheory.BasedNatTrans.forgetful 𝒳 𝒴).map α = α.toNatTrans
-- CategoryTheory.BasedNatTrans.forgetful_obj
@[simps]
def forgetful (𝒳 : BasedCategory.{v₂, u₂} 𝒮) (𝒴 : BasedCategory.{v₃, u₃} 𝒮) :
    (𝒳 ⥤ᵇ 𝒴) ⥤ (𝒳.obj ⥤ 𝒴.obj) 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] (𝒳 : CategoryTheory.BasedCategory 𝒮) (𝒴 : CategoryTheory.BasedCategory 𝒮) (F : CategoryTheory.BasedFunctor 𝒳 𝒴)
Goal: (CategoryTheory.BasedNatTrans.forgetful 𝒳 𝒴).obj F = F.toFunctor
-- CategoryTheory.BasedNatIso.id_inv
@[simps]
def id (F : 𝒳 ⥤ᵇ 𝒴) : F ≅ F 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴)
Goal: (CategoryTheory.BasedNatIso.id F).inv = CategoryTheory.CategoryStruct.id F
-- CategoryTheory.BasedNatIso.id_hom
@[simps]
def id (F : 𝒳 ⥤ᵇ 𝒴) : F ≅ F 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴)
Goal: (CategoryTheory.BasedNatIso.id F).hom = CategoryTheory.CategoryStruct.id F
-- CategoryTheory.BasedNatIso.isIso_of_toNatTrans_isIso
lemma isIso_of_toNatTrans_isIso (α : F ⟶ G) [IsIso (X := F.toFunctor) α.toNatTrans] : IsIso α 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} {F G : CategoryTheory.BasedFunctor 𝒳 𝒴} (α : F ⟶ G) [CategoryTheory.IsIso α.toNatTrans]
Goal: CategoryTheory.IsIso α
-- CategoryTheory.BasedCategory.whiskerLeft_toNatTrans
@[simps]
def whiskerLeft {𝒵 : BasedCategory.{v₄, u₄} 𝒮} (F : 𝒳 ⥤ᵇ 𝒴) {G H : 𝒴 ⥤ᵇ 𝒵} (α : G ⟶ H) :
    F ⋙ G ⟶ F ⋙ H 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} {𝒵 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴) {G H : CategoryTheory.BasedFunctor 𝒴 𝒵} (α : G ⟶ H)
Goal: (CategoryTheory.BasedCategory.whiskerLeft F α).toNatTrans = CategoryTheory.whiskerLeft F.toFunctor α.toNatTrans
-- CategoryTheory.BasedCategory.whiskerRight_toNatTrans
@[simps]
def whiskerRight {𝒵 : BasedCategory.{v₄, u₄} 𝒮} {F G : 𝒳 ⥤ᵇ 𝒴} (α : F ⟶ G) (H : 𝒴 ⥤ᵇ 𝒵) :
    F ⋙ H ⟶ G ⋙ H 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮} {𝒴 : CategoryTheory.BasedCategory 𝒮} {𝒵 : CategoryTheory.BasedCategory 𝒮} {F G : CategoryTheory.BasedFunctor 𝒳 𝒴} (α : F ⟶ G) (H : CategoryTheory.BasedFunctor 𝒴 𝒵)
Goal: (CategoryTheory.BasedCategory.whiskerRight α H).toNatTrans = CategoryTheory.whiskerRight α.toNatTrans H.toFunctor
-- CategoryTheory.BasedCategory.instCategory_id
@[simps]
instance : Category (BasedCategory.{v₂, u₂} 𝒮) 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮] (𝒳 : CategoryTheory.BasedCategory 𝒮)
Goal: CategoryTheory.CategoryStruct.id 𝒳 = CategoryTheory.BasedFunctor.id 𝒳
-- CategoryTheory.BasedCategory.instCategory_comp
@[simps]
instance : Category (BasedCategory.{v₂, u₂} 𝒮) 
Arguments: {𝒮 : Type u₁} [CategoryTheory.Category.{v₁, u₁} 𝒮]
Goal: ∀ {X Y Z : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor X Y) (G : CategoryTheory.BasedFunctor Y Z),
  CategoryTheory.CategoryStruct.comp F G = F.comp G
-- CategoryTheory.Over.CreatesConnected.raiseCone_pt
@[simps]
def raiseCone [IsConnected J] {B : C} {F : J ⥤ Over B} (c : Cone (F ⋙ forget B)) :
    Cone F 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsConnected J] {B : C} {F : J ⥤ CategoryTheory.Over B} (c : CategoryTheory.Limits.Cone (F ⋙ CategoryTheory.Over.forget B))
Goal: (CategoryTheory.Over.CreatesConnected.raiseCone c).pt =
  CategoryTheory.Over.mk (c.π.app (Classical.arbitrary J) ≫ (F.obj (Classical.arbitrary J)).hom)
-- CategoryTheory.Over.CreatesConnected.raiseCone_π_app
@[simps]
def raiseCone [IsConnected J] {B : C} {F : J ⥤ Over B} (c : Cone (F ⋙ forget B)) :
    Cone F 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsConnected J] {B : C} {F : J ⥤ CategoryTheory.Over B} (c : CategoryTheory.Limits.Cone (F ⋙ CategoryTheory.Over.forget B)) (j : J)
Goal: (CategoryTheory.Over.CreatesConnected.raiseCone c).π.app j = CategoryTheory.Over.homMk (c.π.app j) ⋯
-- CategoryTheory.Over.CreatesConnected.raised_cone_lowers_to_original
theorem raised_cone_lowers_to_original [IsConnected J] {B : C} {F : J ⥤ Over B}
    (c : Cone (F ⋙ forget B)) :
    (forget B).mapCone (raiseCone c) = c 
Arguments: {J : Type v} [CategoryTheory.SmallCategory J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.IsConnected J] {B : C} {F : J ⥤ CategoryTheory.Over B} (c : CategoryTheory.Limits.Cone (F ⋙ CategoryTheory.Over.forget B))
Goal: (CategoryTheory.Over.forget B).mapCone (CategoryTheory.Over.CreatesConnected.raiseCone c) = c
-- CategoryTheory.Functor.CommShift.isoZero_inv_app
@[simps!]
noncomputable def isoZero : shiftFunctor C (0 : A) ⋙ F ≅ F ⋙ shiftFunctor D (0 : 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] (X : C)
Goal: (CategoryTheory.Functor.CommShift.isoZero F A).inv.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorZero D A).hom.app (F.obj X))
    (F.map ((CategoryTheory.shiftFunctorZero C A).inv.app X))
-- CategoryTheory.Functor.CommShift.isoZero_hom_app
@[simps!]
noncomputable def isoZero : shiftFunctor C (0 : A) ⋙ F ≅ F ⋙ shiftFunctor D (0 : 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] (X : C)
Goal: (CategoryTheory.Functor.CommShift.isoZero F A).hom.app X =
  CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorZero C A).hom.app X))
    ((CategoryTheory.shiftFunctorZero D A).inv.app (F.obj X))
-- CategoryTheory.Functor.CommShift.isoAdd'_hom_app
@[simps!]
noncomputable def isoAdd' {a b c : A} (h : a + b = c)
    (e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a)
    (e₂ : shiftFunctor C b ⋙ F ≅ F ⋙ shiftFunctor D b) :
    shiftFunctor C c ⋙ F ≅ F ⋙ shiftFunctor D c 
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] {a b c : A} (h : a + b = c) (e₁ : (CategoryTheory.shiftFunctor C a).comp F ≅ F.comp (CategoryTheory.shiftFunctor D a)) (e₂ : (CategoryTheory.shiftFunctor C b).comp F ≅ F.comp (CategoryTheory.shiftFunctor D b)) (X : C)
Goal: (CategoryTheory.Functor.CommShift.isoAdd' h e₁ e₂).hom.app X =
  CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorAdd' C a b c h).hom.app X))
    (CategoryTheory.CategoryStruct.comp (e₂.hom.app ((CategoryTheory.shiftFunctor C a).obj X))
      (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D b).map (e₁.hom.app X))
        ((CategoryTheory.shiftFunctorAdd' D a b c h).inv.app (F.obj X))))
-- CategoryTheory.Functor.CommShift.isoAdd'_inv_app
@[simps!]
noncomputable def isoAdd' {a b c : A} (h : a + b = c)
    (e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a)
    (e₂ : shiftFunctor C b ⋙ F ≅ F ⋙ shiftFunctor D b) :
    shiftFunctor C c ⋙ F ≅ F ⋙ shiftFunctor D c 
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] {a b c : A} (h : a + b = c) (e₁ : (CategoryTheory.shiftFunctor C a).comp F ≅ F.comp (CategoryTheory.shiftFunctor D a)) (e₂ : (CategoryTheory.shiftFunctor C b).comp F ≅ F.comp (CategoryTheory.shiftFunctor D b)) (X : C)
Goal: (CategoryTheory.Functor.CommShift.isoAdd' h e₁ e₂).inv.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd' D a b c h).hom.app (F.obj X))
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D b).map (e₁.inv.app X))
      (CategoryTheory.CategoryStruct.comp (e₂.inv.app ((CategoryTheory.shiftFunctor C a).obj X))
        (F.map ((CategoryTheory.shiftFunctorAdd' C a b c h).inv.app X))))
-- CategoryTheory.Functor.CommShift.isoAdd_hom_app
@[simp]
lemma isoAdd_hom_app {a b : A}
    (e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a)
    (e₂ : shiftFunctor C b ⋙ F ≅ F ⋙ shiftFunctor D b) (X : C) :
      (CommShift.isoAdd e₁ e₂).hom.app X =
        F.map ((shiftFunctorAdd C a b).hom.app X) ≫ e₂.hom.app ((shiftFunctor C a).obj X) ≫
          (shiftFunctor D b).map (e₁.hom.app X) ≫ (shiftFunctorAdd D a b).inv.app (F.obj 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 : CategoryTheory.Functor C D} {A : Type u_4} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] {a b : A} (e₁ : (CategoryTheory.shiftFunctor C a).comp F ≅ F.comp (CategoryTheory.shiftFunctor D a)) (e₂ : (CategoryTheory.shiftFunctor C b).comp F ≅ F.comp (CategoryTheory.shiftFunctor D b)) (X : C)
Goal: (CategoryTheory.Functor.CommShift.isoAdd e₁ e₂).hom.app X =
  CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorAdd C a b).hom.app X))
    (CategoryTheory.CategoryStruct.comp (e₂.hom.app ((CategoryTheory.shiftFunctor C a).obj X))
      (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D b).map (e₁.hom.app X))
        ((CategoryTheory.shiftFunctorAdd D a b).inv.app (F.obj X))))
-- CategoryTheory.Functor.CommShift.isoAdd_inv_app
@[simp]
lemma isoAdd_inv_app {a b : A}
    (e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a)
    (e₂ : shiftFunctor C b ⋙ F ≅ F ⋙ shiftFunctor D b) (X : C) :
      (CommShift.isoAdd e₁ e₂).inv.app X = (shiftFunctorAdd D a b).hom.app (F.obj X) ≫
        (shiftFunctor D b).map (e₁.inv.app X) ≫ e₂.inv.app ((shiftFunctor C a).obj X) ≫
        F.map ((shiftFunctorAdd C a b).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 : CategoryTheory.Functor C D} {A : Type u_4} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] {a b : A} (e₁ : (CategoryTheory.shiftFunctor C a).comp F ≅ F.comp (CategoryTheory.shiftFunctor D a)) (e₂ : (CategoryTheory.shiftFunctor C b).comp F ≅ F.comp (CategoryTheory.shiftFunctor D b)) (X : C)
Goal: (CategoryTheory.Functor.CommShift.isoAdd e₁ e₂).inv.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd D a b).hom.app (F.obj X))
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D b).map (e₁.inv.app X))
      (CategoryTheory.CategoryStruct.comp (e₂.inv.app ((CategoryTheory.shiftFunctor C a).obj X))
        (F.map ((CategoryTheory.shiftFunctorAdd C a b).inv.app X))))
-- CategoryTheory.Functor.CommShift.zero
class CommShift where
  iso (a : A) : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a
  zero : iso 0 = CommShift.isoZero F A := by aesop_cat
  add (a b : A) : iso (a + b) = CommShift.isoAdd (iso a) (iso b) := by aesop_cat
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] [self : F.CommShift A]
Goal: CategoryTheory.Functor.CommShift.iso 0 = CategoryTheory.Functor.CommShift.isoZero F A
-- CategoryTheory.Functor.CommShift.add
class CommShift where
  iso (a : A) : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a
  zero : iso 0 = CommShift.isoZero F A := by aesop_cat
  add (a b : A) : iso (a + b) = CommShift.isoAdd (iso a) (iso b) := by aesop_cat
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] [self : F.CommShift A] (a b : A)
Goal: CategoryTheory.Functor.CommShift.iso (a + b) =
  CategoryTheory.Functor.CommShift.isoAdd (CategoryTheory.Functor.CommShift.iso a)
    (CategoryTheory.Functor.CommShift.iso b)
-- CategoryTheory.Functor.commShiftIso_hom_naturality
@[reassoc (attr := simp)]
lemma commShiftIso_hom_naturality {X Y : C} (f : X ⟶ Y) (a : A) :
    F.map (f⟦a⟧') ≫ (F.commShiftIso a).hom.app Y =
      (F.commShiftIso a).hom.app X ≫ (F.map f)⟦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 Y : C} (f : X ⟶ Y) (a : A)
Goal: CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctor C a).map f)) ((F.commShiftIso a).hom.app Y) =
  CategoryTheory.CategoryStruct.comp ((F.commShiftIso a).hom.app X) ((CategoryTheory.shiftFunctor D a).map (F.map f))
-- CategoryTheory.Functor.commShiftIso_inv_naturality
@[reassoc (attr := simp)]
lemma commShiftIso_inv_naturality {X Y : C} (f : X ⟶ Y) (a : A) :
    (F.map f)⟦a⟧' ≫ (F.commShiftIso a).inv.app Y =
      (F.commShiftIso a).inv.app X ≫ F.map (f⟦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 Y : C} (f : X ⟶ Y) (a : A)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D a).map (F.map f)) ((F.commShiftIso a).inv.app Y) =
  CategoryTheory.CategoryStruct.comp ((F.commShiftIso a).inv.app X) (F.map ((CategoryTheory.shiftFunctor C a).map f))
-- CategoryTheory.Functor.commShiftIso_zero
lemma commShiftIso_zero :
    F.commShiftIso (0 : A) = CommShift.isoZero F 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 : CategoryTheory.Functor C D) (A : Type u_4) [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [F.CommShift A]
Goal: F.commShiftIso 0 = CategoryTheory.Functor.CommShift.isoZero F A
-- CategoryTheory.Functor.commShiftIso_add
lemma commShiftIso_add (a b : A) :
    F.commShiftIso (a + b) = CommShift.isoAdd (F.commShiftIso a) (F.commShiftIso b) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, 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] (a b : A)
Goal: F.commShiftIso (a + b) = CategoryTheory.Functor.CommShift.isoAdd (F.commShiftIso a) (F.commShiftIso b)
-- CategoryTheory.Functor.commShiftIso_add'
lemma commShiftIso_add' {a b c : A} (h : a + b = c) :
    F.commShiftIso c = CommShift.isoAdd' h (F.commShiftIso a) (F.commShiftIso b) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, 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] {a b c : A} (h : a + b = c)
Goal: F.commShiftIso c = CategoryTheory.Functor.CommShift.isoAdd' h (F.commShiftIso a) (F.commShiftIso b)
-- CategoryTheory.Functor.commShiftIso_id_hom_app
@[simp]
lemma commShiftIso_id_hom_app (a : A) (X : C) :
    (commShiftIso (𝟭 C) a).hom.app X = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_6, u_1} C] {A : Type u_4} [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: ((CategoryTheory.Functor.id C).commShiftIso a).hom.app X =
  CategoryTheory.CategoryStruct.id (((CategoryTheory.shiftFunctor C a).comp (CategoryTheory.Functor.id C)).obj X)
-- CategoryTheory.Functor.commShiftIso_id_inv_app
@[simp]
lemma commShiftIso_id_inv_app (a : A) (X : C) :
    (commShiftIso (𝟭 C) a).inv.app X = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_6, u_1} C] {A : Type u_4} [AddMonoid A] [CategoryTheory.HasShift C A] (a : A) (X : C)
Goal: ((CategoryTheory.Functor.id C).commShiftIso a).inv.app X =
  CategoryTheory.CategoryStruct.id (((CategoryTheory.Functor.id C).comp (CategoryTheory.shiftFunctor C a)).obj X)
-- CategoryTheory.Functor.commShiftIso_comp_hom_app
lemma commShiftIso_comp_hom_app [F.CommShift A] [G.CommShift A] (a : A) (X : C) :
    (commShiftIso (F ⋙ G) a).hom.app X =
      G.map ((commShiftIso F a).hom.app X) ≫ (commShiftIso G a).hom.app (F.obj X) 
Arguments: {C : Type u_1} {D : Type u_2} {E : Type u_3} [CategoryTheory.Category.{u_6, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] [CategoryTheory.Category.{u_8, u_3} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) {A : Type u_4} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [CategoryTheory.HasShift E A] [F.CommShift A] [G.CommShift A] (a : A) (X : C)
Goal: ((F.comp G).commShiftIso a).hom.app X =
  CategoryTheory.CategoryStruct.comp (G.map ((F.commShiftIso a).hom.app X)) ((G.commShiftIso a).hom.app (F.obj X))
-- CategoryTheory.Functor.commShiftIso_comp_inv_app
lemma commShiftIso_comp_inv_app [F.CommShift A] [G.CommShift A] (a : A) (X : C) :
    (commShiftIso (F ⋙ G) a).inv.app X =
      (commShiftIso G a).inv.app (F.obj X) ≫ G.map ((commShiftIso F a).inv.app X) 
Arguments: {C : Type u_1} {D : Type u_2} {E : Type u_3} [CategoryTheory.Category.{u_6, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] [CategoryTheory.Category.{u_8, u_3} E] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) {A : Type u_4} [AddMonoid A] [CategoryTheory.HasShift C A] [CategoryTheory.HasShift D A] [CategoryTheory.HasShift E A] [F.CommShift A] [G.CommShift A] (a : A) (X : C)
Goal: ((F.comp G).commShiftIso a).inv.app X =
  CategoryTheory.CategoryStruct.comp ((G.commShiftIso a).inv.app (F.obj X)) (G.map ((F.commShiftIso a).inv.app X))
-- CategoryTheory.Functor.map_shiftFunctorComm_hom_app
lemma map_shiftFunctorComm_hom_app [F.CommShift B] (X : C) (a b : B) :
    F.map ((shiftFunctorComm C a b).hom.app X) = (F.commShiftIso b).hom.app (X⟦a⟧) ≫
      ((F.commShiftIso a).hom.app X)⟦b⟧' ≫ (shiftFunctorComm D a b).hom.app (F.obj X) ≫
      ((F.commShiftIso b).inv.app X)⟦a⟧' ≫ (F.commShiftIso a).inv.app (X⟦b⟧) 
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) {B : Type u_5} [AddCommMonoid B] [CategoryTheory.HasShift C B] [CategoryTheory.HasShift D B] [F.CommShift B] (X : C) (a b : B)
Goal: F.map ((CategoryTheory.shiftFunctorComm C a b).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.CategoryStruct.comp ((CategoryTheory.shiftFunctorComm D a b).hom.app (F.obj X))
        (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D a).map ((F.commShiftIso b).inv.app X))
          ((F.commShiftIso a).inv.app ((CategoryTheory.shiftFunctor C b).obj X)))))