ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.isTriangulated_of_essSurj_mapComposableArrows_two
lemma isTriangulated_of_essSurj_mapComposableArrows_two
    (F : C ⥤ D) [F.CommShift ℤ] [F.IsTriangulated]
    [(F.mapComposableArrows 2).EssSurj] [IsTriangulated C] :
    IsTriangulated D 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.HasShift C ℤ] [CategoryTheory.HasShift D ℤ] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Preadditive C] [CategoryTheory.Preadditive D] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [∀ (n : ℤ), (CategoryTheory.shiftFunctor D n).Additive] [CategoryTheory.Pretriangulated C] [CategoryTheory.Pretriangulated D] (F : CategoryTheory.Functor C D) [F.CommShift ℤ] [F.IsTriangulated] [(F.mapComposableArrows 2).EssSurj] [CategoryTheory.IsTriangulated C]
Goal: CategoryTheory.IsTriangulated D
-- CategoryTheory.bifunctorComp₁₂Obj_obj_obj
@[simps]
def bifunctorComp₁₂Obj (X₁ : C₁) : C₂ ⥤ C₃ ⥤ C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₁₂ : Type u_5} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_5} C₁₂] (F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂)) (G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)) (X₁ : C₁) (X₂ : C₂) (X₃ : C₃)
Goal: ((CategoryTheory.bifunctorComp₁₂Obj F₁₂ G X₁).obj X₂).obj X₃ = (G.obj ((F₁₂.obj X₁).obj X₂)).obj X₃
-- CategoryTheory.bifunctorComp₁₂Obj_map_app
@[simps]
def bifunctorComp₁₂Obj (X₁ : C₁) : C₂ ⥤ C₃ ⥤ C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₁₂ : Type u_5} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_5} C₁₂] (F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂)) (G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)) (X₁ : C₁) {X₂ Y₂ : C₂} (φ : X₂ ⟶ Y₂) (X₃ : C₃)
Goal: ((CategoryTheory.bifunctorComp₁₂Obj F₁₂ G X₁).map φ).app X₃ = (G.map ((F₁₂.obj X₁).map φ)).app X₃
-- CategoryTheory.bifunctorComp₁₂Obj_obj_map
@[simps]
def bifunctorComp₁₂Obj (X₁ : C₁) : C₂ ⥤ C₃ ⥤ C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₁₂ : Type u_5} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_5} C₁₂] (F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂)) (G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)) (X₁ : C₁) (X₂ : C₂) {X₃ Y₃ : C₃} (φ : X₃ ⟶ Y₃)
Goal: ((CategoryTheory.bifunctorComp₁₂Obj F₁₂ G X₁).obj X₂).map φ = (G.obj ((F₁₂.obj X₁).obj X₂)).map φ
-- CategoryTheory.bifunctorComp₁₂_map_app_app
@[simps]
def bifunctorComp₁₂ : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₁₂ : Type u_5} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_5} C₁₂] (F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂)) (G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)) {X₁ Y₁ : C₁} (φ : X₁ ⟶ Y₁) (X₂ : C₂) (X₃ : C₃)
Goal: (((CategoryTheory.bifunctorComp₁₂ F₁₂ G).map φ).app X₂).app X₃ = (G.map ((F₁₂.map φ).app X₂)).app X₃
-- CategoryTheory.bifunctorComp₁₂_obj
@[simps]
def bifunctorComp₁₂ : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₁₂ : Type u_5} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_5} C₁₂] (F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂)) (G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)) (X₁ : C₁)
Goal: (CategoryTheory.bifunctorComp₁₂ F₁₂ G).obj X₁ = CategoryTheory.bifunctorComp₁₂Obj F₁₂ G X₁
-- CategoryTheory.bifunctorComp₂₃Obj_obj_map
@[simps]
def bifunctorComp₂₃Obj (X₁ : C₁) : C₂ ⥤ C₃ ⥤ C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_6} C₂₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄)) (G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) (X₁ : C₁) (X₂ : C₂) {X₃ Y₃ : C₃} (φ : X₃ ⟶ Y₃)
Goal: ((CategoryTheory.bifunctorComp₂₃Obj F G₂₃ X₁).obj X₂).map φ = (F.obj X₁).map ((G₂₃.obj X₂).map φ)
-- CategoryTheory.bifunctorComp₂₃Obj_map_app
@[simps]
def bifunctorComp₂₃Obj (X₁ : C₁) : C₂ ⥤ C₃ ⥤ C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_6} C₂₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄)) (G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) (X₁ : C₁) {X₂ Y₂ : C₂} (φ : X₂ ⟶ Y₂) (X₃ : C₃)
Goal: ((CategoryTheory.bifunctorComp₂₃Obj F G₂₃ X₁).map φ).app X₃ = (F.obj X₁).map ((G₂₃.map φ).app X₃)
-- CategoryTheory.bifunctorComp₂₃Obj_obj_obj
@[simps]
def bifunctorComp₂₃Obj (X₁ : C₁) : C₂ ⥤ C₃ ⥤ C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_6} C₂₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄)) (G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) (X₁ : C₁) (X₂ : C₂) (X₃ : C₃)
Goal: ((CategoryTheory.bifunctorComp₂₃Obj F G₂₃ X₁).obj X₂).obj X₃ = (F.obj X₁).obj ((G₂₃.obj X₂).obj X₃)
-- CategoryTheory.bifunctorComp₂₃_obj
@[simps]
def bifunctorComp₂₃ : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_6} C₂₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄)) (G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) (X₁ : C₁)
Goal: (CategoryTheory.bifunctorComp₂₃ F G₂₃).obj X₁ = CategoryTheory.bifunctorComp₂₃Obj F G₂₃ X₁
-- CategoryTheory.bifunctorComp₂₃_map_app_app
@[simps]
def bifunctorComp₂₃ : C₁ ⥤ C₂ ⥤ C₃ ⥤ C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6} [CategoryTheory.Category.{u_7, u_1} C₁] [CategoryTheory.Category.{u_8, u_2} C₂] [CategoryTheory.Category.{u_9, u_3} C₃] [CategoryTheory.Category.{u_10, u_4} C₄] [CategoryTheory.Category.{u_11, u_6} C₂₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄)) (G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) {X₁ Y₁ : C₁} (φ : X₁ ⟶ Y₁) (X₂ : C₂) (X₃ : C₃)
Goal: (((CategoryTheory.bifunctorComp₂₃ F G₂₃).map φ).app X₂).app X₃ = (F.map φ).app ((G₂₃.obj X₂).obj X₃)
-- CategoryTheory.GradedObject.mapTrifunctorObj_map_app
@[simps]
def mapTrifunctorObj {I₁ : Type*} (X₁ : GradedObject I₁ C₁) (I₂ I₃ : Type*) :
    GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject (I₁ × I₂ × I₃) C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_10, u_1} C₁] [CategoryTheory.Category.{u_11, u_2} C₂] [CategoryTheory.Category.{u_12, u_3} C₃] [CategoryTheory.Category.{u_13, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7} (X₁ : CategoryTheory.GradedObject I₁ C₁) (I₂ : Type u_8) (I₃ : Type u_9) {X₂ Y₂ : CategoryTheory.GradedObject I₂ C₂} (φ : X₂ ⟶ Y₂) (X₃ : CategoryTheory.GradedObject I₃ C₃) (x : I₁ × I₂ × I₃)
Goal: ((CategoryTheory.GradedObject.mapTrifunctorObj F X₁ I₂ I₃).map φ).app X₃ x =
  ((F.obj (X₁ x.1)).map (φ x.2.1)).app (X₃ x.2.2)
-- CategoryTheory.GradedObject.mapTrifunctorObj_obj_obj
@[simps]
def mapTrifunctorObj {I₁ : Type*} (X₁ : GradedObject I₁ C₁) (I₂ I₃ : Type*) :
    GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject (I₁ × I₂ × I₃) C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_10, u_1} C₁] [CategoryTheory.Category.{u_11, u_2} C₂] [CategoryTheory.Category.{u_12, u_3} C₃] [CategoryTheory.Category.{u_13, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7} (X₁ : CategoryTheory.GradedObject I₁ C₁) (I₂ : Type u_8) (I₃ : Type u_9) (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃) (x : I₁ × I₂ × I₃)
Goal: ((CategoryTheory.GradedObject.mapTrifunctorObj F X₁ I₂ I₃).obj X₂).obj X₃ x =
  ((F.obj (X₁ x.1)).obj (X₂ x.2.1)).obj (X₃ x.2.2)
-- CategoryTheory.GradedObject.mapTrifunctorObj_obj_map
@[simps]
def mapTrifunctorObj {I₁ : Type*} (X₁ : GradedObject I₁ C₁) (I₂ I₃ : Type*) :
    GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject (I₁ × I₂ × I₃) C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_10, u_1} C₁] [CategoryTheory.Category.{u_11, u_2} C₂] [CategoryTheory.Category.{u_12, u_3} C₃] [CategoryTheory.Category.{u_13, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7} (X₁ : CategoryTheory.GradedObject I₁ C₁) (I₂ : Type u_8) (I₃ : Type u_9) (X₂ : CategoryTheory.GradedObject I₂ C₂) {X₃ Y₃ : CategoryTheory.GradedObject I₃ C₃} (φ : X₃ ⟶ Y₃) (x : I₁ × I₂ × I₃)
Goal: ((CategoryTheory.GradedObject.mapTrifunctorObj F X₁ I₂ I₃).obj X₂).map φ x =
  ((F.obj (X₁ x.1)).obj (X₂ x.2.1)).map (φ x.2.2)
-- CategoryTheory.GradedObject.mapTrifunctor_map_app_app
@[simps]
def mapTrifunctor (I₁ I₂ I₃ : Type*) :
    GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤
      GradedObject (I₁ × I₂ × I₃) C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_10, u_1} C₁] [CategoryTheory.Category.{u_11, u_2} C₂] [CategoryTheory.Category.{u_12, u_3} C₃] [CategoryTheory.Category.{u_13, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) (I₁ : Type u_7) (I₂ : Type u_8) (I₃ : Type u_9) {X₁ Y₁ : CategoryTheory.GradedObject I₁ C₁} (φ : X₁ ⟶ Y₁) (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃) (x : I₁ × I₂ × I₃)
Goal: (((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).map φ).app X₂).app X₃ x =
  ((F.map (φ x.1)).app (X₂ x.2.1)).app (X₃ x.2.2)
-- CategoryTheory.GradedObject.mapTrifunctor_obj
@[simps]
def mapTrifunctor (I₁ I₂ I₃ : Type*) :
    GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤
      GradedObject (I₁ × I₂ × I₃) C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_10, u_1} C₁] [CategoryTheory.Category.{u_11, u_2} C₂] [CategoryTheory.Category.{u_12, u_3} C₃] [CategoryTheory.Category.{u_13, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) (I₁ : Type u_7) (I₂ : Type u_8) (I₃ : Type u_9) (X₁ : CategoryTheory.GradedObject I₁ C₁)
Goal: (CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁ = CategoryTheory.GradedObject.mapTrifunctorObj F X₁ I₂ I₃
-- CategoryTheory.GradedObject.mapTrifunctorMapNatTrans_app_app_app
@[simps]
def mapTrifunctorMapNatTrans (α : F ⟶ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ⟶ mapTrifunctor F' I₁ I₂ I₃ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_10, u_1} C₁] [CategoryTheory.Category.{u_11, u_2} C₂] [CategoryTheory.Category.{u_12, u_3} C₃] [CategoryTheory.Category.{u_13, u_4} C₄] {F F' : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))} (α : F ⟶ F') (I₁ : Type u_7) (I₂ : Type u_8) (I₃ : Type u_9) (X₁ : CategoryTheory.GradedObject I₁ C₁) (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃) (i : I₁ × I₂ × I₃)
Goal: (((CategoryTheory.GradedObject.mapTrifunctorMapNatTrans α I₁ I₂ I₃).app X₁).app X₂).app X₃ i =
  ((α.app (X₁ i.1)).app (X₂ i.2.1)).app (X₃ i.2.2)
-- CategoryTheory.GradedObject.mapTrifunctorMapIso_hom
@[simps]
def mapTrifunctorMapIso (e : F ≅ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_10, u_1} C₁] [CategoryTheory.Category.{u_11, u_2} C₂] [CategoryTheory.Category.{u_12, u_3} C₃] [CategoryTheory.Category.{u_13, u_4} C₄] {F F' : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))} (e : F ≅ F') (I₁ : Type u_7) (I₂ : Type u_8) (I₃ : Type u_9)
Goal: (CategoryTheory.GradedObject.mapTrifunctorMapIso e I₁ I₂ I₃).hom =
  CategoryTheory.GradedObject.mapTrifunctorMapNatTrans e.hom I₁ I₂ I₃
-- CategoryTheory.GradedObject.mapTrifunctorMapIso_inv
@[simps]
def mapTrifunctorMapIso (e : F ≅ F') (I₁ I₂ I₃ : Type*) :
    mapTrifunctor F I₁ I₂ I₃ ≅ mapTrifunctor F' I₁ I₂ I₃ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_10, u_1} C₁] [CategoryTheory.Category.{u_11, u_2} C₂] [CategoryTheory.Category.{u_12, u_3} C₃] [CategoryTheory.Category.{u_13, u_4} C₄] {F F' : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))} (e : F ≅ F') (I₁ : Type u_7) (I₂ : Type u_8) (I₃ : Type u_9)
Goal: (CategoryTheory.GradedObject.mapTrifunctorMapIso e I₁ I₂ I₃).inv =
  CategoryTheory.GradedObject.mapTrifunctorMapNatTrans e.inv I₁ I₂ I₃
-- CategoryTheory.GradedObject.ι_mapTrifunctorMapMap
@[reassoc (attr := simp)]
lemma ι_mapTrifunctorMapMap {X₁ Y₁ : GradedObject I₁ C₁} (f₁ : X₁ ⟶ Y₁)
    {X₂ Y₂ : GradedObject I₂ C₂} (f₂ : X₂ ⟶ Y₂)
    {X₃ Y₃ : GradedObject I₃ C₃} (f₃ : X₃ ⟶ Y₃)
    [HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p]
    [HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj Y₁).obj Y₂).obj Y₃) p]
    (i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (j : J) (h : p ⟨i₁, i₂, i₃⟩ = j) :
  ιMapTrifunctorMapObj F p X₁ X₂ X₃ i₁ i₂ i₃ j h ≫ mapTrifunctorMapMap F p f₁ f₂ f₃ j =
    ((F.map (f₁ i₁)).app (X₂ i₂)).app (X₃ i₃) ≫
      ((F.obj (Y₁ i₁)).map (f₂ i₂)).app (X₃ i₃) ≫
      ((F.obj (Y₁ i₁)).obj (Y₂ i₂)).map (f₃ i₃) ≫
      ιMapTrifunctorMapObj F p Y₁ Y₂ Y₃ i₁ i₂ i₃ j h 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_11, u_1} C₁] [CategoryTheory.Category.{u_12, u_2} C₂] [CategoryTheory.Category.{u_13, u_3} C₃] [CategoryTheory.Category.{u_14, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9} {J : Type u_10} (p : I₁ × I₂ × I₃ → J) {X₁ Y₁ : CategoryTheory.GradedObject I₁ C₁} (f₁ : X₁ ⟶ Y₁) {X₂ Y₂ : CategoryTheory.GradedObject I₂ C₂} (f₂ : X₂ ⟶ Y₂) {X₃ Y₃ : CategoryTheory.GradedObject I₃ C₃} (f₃ : X₃ ⟶ Y₃) [((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p] [((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj Y₁).obj Y₂).obj Y₃).HasMap p] (i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (j : J) (h : p (i₁, i₂, i₃) = j)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.ιMapTrifunctorMapObj F p X₁ X₂ X₃ i₁ i₂ i₃ j h)
    (CategoryTheory.GradedObject.mapTrifunctorMapMap F p f₁ f₂ f₃ j) =
  CategoryTheory.CategoryStruct.comp (((F.map (f₁ i₁)).app (X₂ i₂)).app (X₃ i₃))
    (CategoryTheory.CategoryStruct.comp (((F.obj (Y₁ i₁)).map (f₂ i₂)).app (X₃ i₃))
      (CategoryTheory.CategoryStruct.comp (((F.obj (Y₁ i₁)).obj (Y₂ i₂)).map (f₃ i₃))
        (CategoryTheory.GradedObject.ιMapTrifunctorMapObj F p Y₁ Y₂ Y₃ i₁ i₂ i₃ j h)))
-- CategoryTheory.GradedObject.mapTrifunctorMapObj_ext
@[ext]
lemma mapTrifunctorMapObj_ext {X₁ : GradedObject I₁ C₁} {X₂ : GradedObject I₂ C₂}
    {X₃ : GradedObject I₃ C₃} {Y : C₄} (j : J)
    [HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p]
    {φ φ' : mapTrifunctorMapObj F p X₁ X₂ X₃ j ⟶ Y}
    (h : ∀ (i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (h : p ⟨i₁, i₂, i₃⟩ = j),
      ιMapTrifunctorMapObj F p X₁ X₂ X₃ i₁ i₂ i₃ j h ≫ φ =
        ιMapTrifunctorMapObj F p X₁ X₂ X₃ i₁ i₂ i₃ j h ≫ φ') : φ = φ' 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_14, u_1} C₁] [CategoryTheory.Category.{u_13, u_2} C₂] [CategoryTheory.Category.{u_12, u_3} C₃] [CategoryTheory.Category.{u_11, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9} {J : Type u_10} (p : I₁ × I₂ × I₃ → J) {X₁ : CategoryTheory.GradedObject I₁ C₁} {X₂ : CategoryTheory.GradedObject I₂ C₂} {X₃ : CategoryTheory.GradedObject I₃ C₃} {Y : C₄} (j : J) [((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p] {φ φ' : CategoryTheory.GradedObject.mapTrifunctorMapObj F p X₁ X₂ X₃ j ⟶ Y} (h :
  ∀ (i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (h : p (i₁, i₂, i₃) = j),
    CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.ιMapTrifunctorMapObj F p X₁ X₂ X₃ i₁ i₂ i₃ j h) φ =
      CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.ιMapTrifunctorMapObj F p X₁ X₂ X₃ i₁ i₂ i₃ j h)
        φ')
Goal: φ = φ'
-- CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj_obj_obj
@[simps]
noncomputable def mapTrifunctorMapFunctorObj (X₁ : GradedObject I₁ C₁)
    [∀ X₂ X₃, HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p] :
    GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject J C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_11, u_1} C₁] [CategoryTheory.Category.{u_12, u_2} C₂] [CategoryTheory.Category.{u_13, u_3} C₃] [CategoryTheory.Category.{u_14, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9} {J : Type u_10} (p : I₁ × I₂ × I₃ → J) (X₁ : CategoryTheory.GradedObject I₁ C₁) [∀ (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃),
    ((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p] (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃)
Goal: ((CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj F p X₁).obj X₂).obj X₃ =
  CategoryTheory.GradedObject.mapTrifunctorMapObj F p X₁ X₂ X₃
-- CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj_obj_map
@[simps]
noncomputable def mapTrifunctorMapFunctorObj (X₁ : GradedObject I₁ C₁)
    [∀ X₂ X₃, HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p] :
    GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject J C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_11, u_1} C₁] [CategoryTheory.Category.{u_12, u_2} C₂] [CategoryTheory.Category.{u_13, u_3} C₃] [CategoryTheory.Category.{u_14, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9} {J : Type u_10} (p : I₁ × I₂ × I₃ → J) (X₁ : CategoryTheory.GradedObject I₁ C₁) [∀ (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃),
    ((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p] (X₂ : CategoryTheory.GradedObject I₂ C₂) {X₃ Y₃ : CategoryTheory.GradedObject I₃ C₃} (φ : X₃ ⟶ Y₃) (i : J)
Goal: ((CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj F p X₁).obj X₂).map φ i =
  CategoryTheory.GradedObject.mapTrifunctorMapMap F p (CategoryTheory.CategoryStruct.id X₁)
    (CategoryTheory.CategoryStruct.id X₂) φ i
-- CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj_map_app
@[simps]
noncomputable def mapTrifunctorMapFunctorObj (X₁ : GradedObject I₁ C₁)
    [∀ X₂ X₃, HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p] :
    GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject J C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_11, u_1} C₁] [CategoryTheory.Category.{u_12, u_2} C₂] [CategoryTheory.Category.{u_13, u_3} C₃] [CategoryTheory.Category.{u_14, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9} {J : Type u_10} (p : I₁ × I₂ × I₃ → J) (X₁ : CategoryTheory.GradedObject I₁ C₁) [∀ (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃),
    ((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p] {X₂ Y₂ : CategoryTheory.GradedObject I₂ C₂} (φ : X₂ ⟶ Y₂) (X₃ : CategoryTheory.GradedObject I₃ C₃) (i : J)
Goal: ((CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj F p X₁).map φ).app X₃ i =
  CategoryTheory.GradedObject.mapTrifunctorMapMap F p (CategoryTheory.CategoryStruct.id X₁) φ
    (CategoryTheory.CategoryStruct.id X₃) i
-- CategoryTheory.GradedObject.mapTrifunctorMap_obj
@[simps]
noncomputable def mapTrifunctorMap
    [∀ X₁ X₂ X₃, HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p] :
    GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject J C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_11, u_1} C₁] [CategoryTheory.Category.{u_12, u_2} C₂] [CategoryTheory.Category.{u_13, u_3} C₃] [CategoryTheory.Category.{u_14, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9} {J : Type u_10} (p : I₁ × I₂ × I₃ → J) [∀ (X₁ : CategoryTheory.GradedObject I₁ C₁) (X₂ : CategoryTheory.GradedObject I₂ C₂)
    (X₃ : CategoryTheory.GradedObject I₃ C₃),
    ((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p] (X₁ : CategoryTheory.GradedObject I₁ C₁)
Goal: (CategoryTheory.GradedObject.mapTrifunctorMap F p).obj X₁ =
  CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj F p X₁
-- CategoryTheory.GradedObject.mapTrifunctorMap_map_app_app
@[simps]
noncomputable def mapTrifunctorMap
    [∀ X₁ X₂ X₃, HasMap ((((mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃) p] :
    GradedObject I₁ C₁ ⥤ GradedObject I₂ C₂ ⥤ GradedObject I₃ C₃ ⥤ GradedObject J C₄ 
Arguments: {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [CategoryTheory.Category.{u_11, u_1} C₁] [CategoryTheory.Category.{u_12, u_2} C₂] [CategoryTheory.Category.{u_13, u_3} C₃] [CategoryTheory.Category.{u_14, u_4} C₄] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9} {J : Type u_10} (p : I₁ × I₂ × I₃ → J) [∀ (X₁ : CategoryTheory.GradedObject I₁ C₁) (X₂ : CategoryTheory.GradedObject I₂ C₂)
    (X₃ : CategoryTheory.GradedObject I₃ C₃),
    ((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p] {X₁ Y₁ : CategoryTheory.GradedObject I₁ C₁} (φ : X₁ ⟶ Y₁) (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃) (i : J)
Goal: (((CategoryTheory.GradedObject.mapTrifunctorMap F p).map φ).app X₂).app X₃ i =
  CategoryTheory.GradedObject.mapTrifunctorMapMap F p φ (CategoryTheory.CategoryStruct.id X₂)
    (CategoryTheory.CategoryStruct.id X₃) i
-- CategoryTheory.GradedObject.BifunctorComp₁₂IndexData.hpq
structure BifunctorComp₁₂IndexData :=
    I₁₂ : Type*
    p : I₁ × I₂ → I₁₂
    q : I₁₂ × I₃ → J
  hpq (i : I₁ × I₂ × I₃) : q ⟨p ⟨i.1, i.2.1⟩, i.2.2⟩ = r i
Arguments: {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9} {J : Type u_10} {r : I₁ × I₂ × I₃ → J} (self : CategoryTheory.GradedObject.BifunctorComp₁₂IndexData r) (i : I₁ × I₂ × I₃)
Goal: self.q (self.p (i.1, i.2.1), i.2.2) = r i