ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.IsTriangulated.octahedron_axiom
class IsTriangulated : Prop where
    octahedron_axiom :
    ∀ {X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C}
      {u₁₂ : X₁ ⟶ X₂} {u₂₃ : X₂ ⟶ X₃} {u₁₃ : X₁ ⟶ X₃} (comm : u₁₂ ≫ u₂₃ = u₁₃)
      {v₁₂ : X₂ ⟶ Z₁₂} {w₁₂ : Z₁₂ ⟶ X₁⟦(1 : ℤ)⟧} (h₁₂ : Triangle.mk u₁₂ v₁₂ w₁₂ ∈ distTriang C)
      {v₂₃ : X₃ ⟶ Z₂₃} {w₂₃ : Z₂₃ ⟶ X₂⟦(1 : ℤ)⟧} (h₂₃ : Triangle.mk u₂₃ v₂₃ w₂₃ ∈ distTriang C)
      {v₁₃ : X₃ ⟶ Z₁₃} {w₁₃ : Z₁₃ ⟶ X₁⟦(1 : ℤ)⟧} (h₁₃ : Triangle.mk u₁₃ v₁₃ w₁₃ ∈ distTriang C),
      Nonempty (Octahedron comm h₁₂ h₂₃ h₁₃)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.HasShift C ℤ] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] [self : CategoryTheory.IsTriangulated C] {X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C} {u₁₂ : X₁ ⟶ X₂} {u₂₃ : X₂ ⟶ X₃} {u₁₃ : X₁ ⟶ X₃} (comm : CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃) {v₁₂ : X₂ ⟶ Z₁₂} {w₁₂ : Z₁₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} (h₁₂ : CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles) {v₂₃ : X₃ ⟶ Z₂₃} {w₂₃ : Z₂₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₂} (h₂₃ : CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles) {v₁₃ : X₃ ⟶ Z₁₃} {w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} (h₁₃ : CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)
Goal: Nonempty (CategoryTheory.Triangulated.Octahedron comm h₁₂ h₂₃ h₁₃)
-- CategoryTheory.IsTriangulated.mk'
lemma IsTriangulated.mk' (h : ∀ ⦃X₁' X₂' X₃' : C⦄ (u₁₂' : X₁' ⟶ X₂') (u₂₃' : X₂' ⟶ X₃'),
    ∃ (X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C) (u₁₂ : X₁ ⟶ X₂) (u₂₃ : X₂ ⟶ X₃) (e₁ : X₁' ≅ X₁) (e₂ : X₂' ≅ X₂)
    (e₃ : X₃' ≅ X₃) (_ : u₁₂' ≫ e₂.hom = e₁.hom ≫ u₁₂)
    (_ : u₂₃' ≫ e₃.hom = e₂.hom ≫ u₂₃)
    (v₁₂ : X₂ ⟶ Z₁₂) (w₁₂ : Z₁₂ ⟶ X₁⟦1⟧) (h₁₂ : Triangle.mk u₁₂ v₁₂ w₁₂ ∈ distTriang C)
    (v₂₃ : X₃ ⟶ Z₂₃) (w₂₃ : Z₂₃ ⟶ X₂⟦1⟧) (h₂₃ : Triangle.mk u₂₃ v₂₃ w₂₃ ∈ distTriang C)
    (v₁₃ : X₃ ⟶ Z₁₃) (w₁₃ : Z₁₃ ⟶ X₁⟦1⟧)
      (h₁₃ : Triangle.mk (u₁₂ ≫ u₂₃) v₁₃ w₁₃ ∈ distTriang C),
        Nonempty (Octahedron rfl h₁₂ h₂₃ h₁₃)) :
    IsTriangulated C 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.HasShift C ℤ] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] (h :
  ∀ ⦃X₁' X₂' X₃' : C⦄ (u₁₂' : X₁' ⟶ X₂') (u₂₃' : X₂' ⟶ X₃'),
    ∃ X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ u₁₂ u₂₃ e₁ e₂ e₃,
      ∃ (_ : CategoryTheory.CategoryStruct.comp u₁₂' e₂.hom = CategoryTheory.CategoryStruct.comp e₁.hom u₁₂) (_ :
        CategoryTheory.CategoryStruct.comp u₂₃' e₃.hom = CategoryTheory.CategoryStruct.comp e₂.hom u₂₃),
        ∃ v₁₂ w₁₂,
          ∃ (h₁₂ :
            CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂ ∈
              CategoryTheory.Pretriangulated.distinguishedTriangles),
            ∃ v₂₃ w₂₃,
              ∃ (h₂₃ :
                CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃ ∈
                  CategoryTheory.Pretriangulated.distinguishedTriangles),
                ∃ v₁₃ w₁₃,
                  ∃ (h₁₃ :
                    CategoryTheory.Pretriangulated.Triangle.mk (CategoryTheory.CategoryStruct.comp u₁₂ u₂₃) v₁₃ w₁₃ ∈
                      CategoryTheory.Pretriangulated.distinguishedTriangles),
                    Nonempty (CategoryTheory.Triangulated.Octahedron ⋯ h₁₂ h₂₃ h₁₃))
Goal: CategoryTheory.IsTriangulated C
-- Mon_.limit_X
@[simps!]
def limit (F : J ⥤ Mon_ C) : Mon_ C 
Arguments: {J : Type w} [CategoryTheory.SmallCategory J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.MonoidalCategory C] (F : J ⥤ Mon_ C)
Goal: (Mon_.limit F).X = CategoryTheory.Limits.limit (F ⋙ Mon_.forget C)
-- Mon_.limit_one
@[simps!]
def limit (F : J ⥤ Mon_ C) : Mon_ C 
Arguments: {J : Type w} [CategoryTheory.SmallCategory J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.MonoidalCategory C] (F : J ⥤ Mon_ C)
Goal: (Mon_.limit F).one =
  CategoryTheory.Limits.limit.lift (F ⋙ Mon_.forget C)
    ((CategoryTheory.Limits.Cones.postcompose
          (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj F).one).obj
      { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } })
-- Mon_.limit_mul
@[simps!]
def limit (F : J ⥤ Mon_ C) : Mon_ C 
Arguments: {J : Type w} [CategoryTheory.SmallCategory J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.MonoidalCategory C] (F : J ⥤ Mon_ C)
Goal: (Mon_.limit F).mul =
  CategoryTheory.Limits.limit.lift (F ⋙ Mon_.forget C)
    ((CategoryTheory.Limits.Cones.postcompose
          (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj F).mul).obj
      {
        pt :=
          CategoryTheory.MonoidalCategory.tensorObj (CategoryTheory.Limits.limit (F ⋙ Mon_.forget C))
            (CategoryTheory.Limits.limit (F ⋙ Mon_.forget C)),
        π :=
          {
            app := fun j =>
              CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.Limits.limit.π (F ⋙ Mon_.forget C) j)
                (CategoryTheory.Limits.limit.π (F ⋙ Mon_.forget C) j),
            naturality := ⋯ } })
-- Mon_.limitCone_pt
@[simps]
def limitCone (F : J ⥤ Mon_ C) : Cone F 
Arguments: {J : Type w} [CategoryTheory.SmallCategory J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.MonoidalCategory C] (F : J ⥤ Mon_ C)
Goal: (Mon_.limitCone F).pt = Mon_.limit F
-- Mon_.limitCone_π_app_hom
@[simps]
def limitCone (F : J ⥤ Mon_ C) : Cone F 
Arguments: {J : Type w} [CategoryTheory.SmallCategory J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.MonoidalCategory C] (F : J ⥤ Mon_ C) (j : J)
Goal: ((Mon_.limitCone F).π.app j).hom = CategoryTheory.Limits.limit.π (F ⋙ Mon_.forget C) j
-- Mon_.limitConeIsLimit_lift_hom
@[simps]
def limitConeIsLimit (F : J ⥤ Mon_ C) : IsLimit (limitCone F) 
Arguments: {J : Type w} [CategoryTheory.SmallCategory J] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.MonoidalCategory C] (F : J ⥤ Mon_ C) (s : CategoryTheory.Limits.Cone F)
Goal: ((Mon_.limitConeIsLimit F).lift s).hom =
  CategoryTheory.Limits.limit.lift (F ⋙ Mon_.forget C) ((Mon_.forget C).mapCone s)
-- CategoryTheory.MonoidalCategory.leftUnitor_tensor''
@[reassoc]
theorem leftUnitor_tensor'' (X Y : C) :
    (α_ (𝟙_ C) X Y).hom ≫ (λ_ (X ⊗ Y)).hom = (λ_ X).hom ⊗ 𝟙 Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] (X Y : C)
Goal: (CategoryTheory.MonoidalCategory.associator (𝟙_ C) X Y).hom ≫
    (CategoryTheory.MonoidalCategory.leftUnitor (CategoryTheory.MonoidalCategory.tensorObj X Y)).hom =
  CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.MonoidalCategory.leftUnitor X).hom (𝟙 Y)
-- CategoryTheory.MonoidalCategory.leftUnitor_tensor'
@[reassoc]
theorem leftUnitor_tensor' (X Y : C) :
    (λ_ (X ⊗ Y)).hom = (α_ (𝟙_ C) X Y).inv ≫ ((λ_ X).hom ⊗ 𝟙 Y) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] (X Y : C)
Goal: (CategoryTheory.MonoidalCategory.leftUnitor (CategoryTheory.MonoidalCategory.tensorObj X Y)).hom =
  (CategoryTheory.MonoidalCategory.associator (𝟙_ C) X Y).inv ≫
    CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.MonoidalCategory.leftUnitor X).hom (𝟙 Y)
-- CategoryTheory.MonoidalCategory.leftUnitor_tensor_inv'
@[reassoc]
theorem leftUnitor_tensor_inv' (X Y : C) :
    (λ_ (X ⊗ Y)).inv = ((λ_ X).inv ⊗ 𝟙 Y) ≫ (α_ (𝟙_ C) X Y).hom 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] (X Y : C)
Goal: (CategoryTheory.MonoidalCategory.leftUnitor (CategoryTheory.MonoidalCategory.tensorObj X Y)).inv =
  CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.MonoidalCategory.leftUnitor X).inv (𝟙 Y) ≫
    (CategoryTheory.MonoidalCategory.associator (𝟙_ C) X Y).hom
-- CategoryTheory.MonoidalCategory.id_tensor_rightUnitor_inv
@[reassoc]
theorem id_tensor_rightUnitor_inv (X Y : C) : 𝟙 X ⊗ (ρ_ Y).inv = (ρ_ _).inv ≫ (α_ _ _ _).hom 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] (X Y : C)
Goal: CategoryTheory.MonoidalCategory.tensorHom (𝟙 X) (CategoryTheory.MonoidalCategory.rightUnitor Y).inv =
  (CategoryTheory.MonoidalCategory.rightUnitor (CategoryTheory.MonoidalCategory.tensorObj X Y)).inv ≫
    (CategoryTheory.MonoidalCategory.associator X Y (𝟙_ C)).hom
-- CategoryTheory.MonoidalCategory.leftUnitor_inv_tensor_id
@[reassoc]
theorem leftUnitor_inv_tensor_id (X Y : C) : (λ_ X).inv ⊗ 𝟙 Y = (λ_ _).inv ≫ (α_ _ _ _).inv 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] (X Y : C)
Goal: CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.MonoidalCategory.leftUnitor X).inv (𝟙 Y) =
  (CategoryTheory.MonoidalCategory.leftUnitor (CategoryTheory.MonoidalCategory.tensorObj X Y)).inv ≫
    (CategoryTheory.MonoidalCategory.associator (𝟙_ C) X Y).inv
-- CategoryTheory.MonoidalCategory.pentagon_inv_inv_hom
@[reassoc]
theorem pentagon_inv_inv_hom (W X Y Z : C) :
    (α_ W (X ⊗ Y) Z).inv ≫ ((α_ W X Y).inv ⊗ 𝟙 Z) ≫ (α_ (W ⊗ X) Y Z).hom =
      (𝟙 W ⊗ (α_ X Y Z).hom) ≫ (α_ W X (Y ⊗ Z)).inv 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] (W X Y Z : C)
Goal: (CategoryTheory.MonoidalCategory.associator W (CategoryTheory.MonoidalCategory.tensorObj X Y) Z).inv ≫
    CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.MonoidalCategory.associator W X Y).inv (𝟙 Z) ≫
      (CategoryTheory.MonoidalCategory.associator (CategoryTheory.MonoidalCategory.tensorObj W X) Y Z).hom =
  CategoryTheory.MonoidalCategory.tensorHom (𝟙 W) (CategoryTheory.MonoidalCategory.associator X Y Z).hom ≫
    (CategoryTheory.MonoidalCategory.associator W X (CategoryTheory.MonoidalCategory.tensorObj Y Z)).inv
-- CategoryTheory.MonoidalCategory.unitors_equal
theorem unitors_equal : (λ_ (𝟙_ C)).hom = (ρ_ (𝟙_ C)).hom 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C]
Goal: (CategoryTheory.MonoidalCategory.leftUnitor (𝟙_ C)).hom = (CategoryTheory.MonoidalCategory.rightUnitor (𝟙_ C)).hom
-- CategoryTheory.MonoidalCategory.unitors_inv_equal
theorem unitors_inv_equal : (λ_ (𝟙_ C)).inv = (ρ_ (𝟙_ C)).inv 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C]
Goal: (CategoryTheory.MonoidalCategory.leftUnitor (𝟙_ C)).inv = (CategoryTheory.MonoidalCategory.rightUnitor (𝟙_ C)).inv
-- CategoryTheory.MonoidalCategory.pentagon_hom_inv
@[reassoc]
theorem pentagon_hom_inv {W X Y Z : C} :
    (α_ W X (Y ⊗ Z)).hom ≫ (𝟙 W ⊗ (α_ X Y Z).inv) =
      (α_ (W ⊗ X) Y Z).inv ≫ ((α_ W X Y).hom ⊗ 𝟙 Z) ≫ (α_ W (X ⊗ Y) Z).hom 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] {W X Y Z : C}
Goal: (CategoryTheory.MonoidalCategory.associator W X (CategoryTheory.MonoidalCategory.tensorObj Y Z)).hom ≫
    CategoryTheory.MonoidalCategory.tensorHom (𝟙 W) (CategoryTheory.MonoidalCategory.associator X Y Z).inv =
  (CategoryTheory.MonoidalCategory.associator (CategoryTheory.MonoidalCategory.tensorObj W X) Y Z).inv ≫
    CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.MonoidalCategory.associator W X Y).hom (𝟙 Z) ≫
      (CategoryTheory.MonoidalCategory.associator W (CategoryTheory.MonoidalCategory.tensorObj X Y) Z).hom
-- CategoryTheory.MonoidalCategory.pentagon_inv_hom
@[reassoc]
theorem pentagon_inv_hom (W X Y Z : C) :
    (α_ (W ⊗ X) Y Z).inv ≫ ((α_ W X Y).hom ⊗ 𝟙 Z) =
      (α_ W X (Y ⊗ Z)).hom ≫ (𝟙 W ⊗ (α_ X Y Z).inv) ≫ (α_ W (X ⊗ Y) Z).inv 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.MonoidalCategory C] (W X Y Z : C)
Goal: (CategoryTheory.MonoidalCategory.associator (CategoryTheory.MonoidalCategory.tensorObj W X) Y Z).inv ≫
    CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.MonoidalCategory.associator W X Y).hom (𝟙 Z) =
  (CategoryTheory.MonoidalCategory.associator W X (CategoryTheory.MonoidalCategory.tensorObj Y Z)).hom ≫
    CategoryTheory.MonoidalCategory.tensorHom (𝟙 W) (CategoryTheory.MonoidalCategory.associator X Y Z).inv ≫
      (CategoryTheory.MonoidalCategory.associator W (CategoryTheory.MonoidalCategory.tensorObj X Y) Z).inv
-- CategoryTheory.Monoidal.FunctorCategory.tensorObj_obj
@[simps]
def tensorObj : C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F G : C ⥤ D) (X : C)
Goal: (CategoryTheory.Monoidal.FunctorCategory.tensorObj F G).obj X = F.obj X ⊗ G.obj X
-- CategoryTheory.Monoidal.FunctorCategory.tensorObj_map
@[simps]
def tensorObj : C ⥤ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] (F G : C ⥤ D)
Goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.Monoidal.FunctorCategory.tensorObj F G).map f = F.map f ⊗ G.map f
-- CategoryTheory.Monoidal.FunctorCategory.tensorHom_app
@[simps]
def tensorHom : tensorObj F F' ⟶ tensorObj G G' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F G F' G' : C ⥤ D} (α : F ⟶ G) (β : F' ⟶ G') (X : C)
Goal: (CategoryTheory.Monoidal.FunctorCategory.tensorHom α β).app X = α.app X ⊗ β.app X
-- CategoryTheory.Monoidal.FunctorCategory.whiskerLeft_app
@[simps]
def whiskerLeft (F) (β : F' ⟶ G') : tensorObj F F' ⟶ tensorObj F G' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F' G' : C ⥤ D} (F : C ⥤ D) (β : F' ⟶ G') (X : C)
Goal: (CategoryTheory.Monoidal.FunctorCategory.whiskerLeft F β).app X = F.obj X ◁ β.app X
-- CategoryTheory.Monoidal.FunctorCategory.whiskerRight_app
@[simps]
def whiskerRight (F') : tensorObj F F' ⟶ tensorObj G F' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F G : C ⥤ D} (α : F ⟶ G) (F' : C ⥤ D) (X : C)
Goal: (CategoryTheory.Monoidal.FunctorCategory.whiskerRight α F').app X = α.app X ▷ F'.obj X
-- CategoryTheory.Monoidal.tensorUnit_obj
@[simp]
theorem tensorUnit_obj {X} : (𝟙_ (C ⥤ D)).obj X = 𝟙_ D 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {X : C}
Goal: (𝟙_ (C ⥤ D)).obj X = 𝟙_ D
-- CategoryTheory.Monoidal.tensorUnit_map
@[simp]
theorem tensorUnit_map {X Y} {f : X ⟶ Y} : (𝟙_ (C ⥤ D)).map f = 𝟙 (𝟙_ D) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {X Y : C} {f : X ⟶ Y}
Goal: (𝟙_ (C ⥤ D)).map f = 𝟙 (𝟙_ D)
-- CategoryTheory.Monoidal.tensorObj_obj
@[simp]
theorem tensorObj_obj {F G : C ⥤ D} {X} : (F ⊗ G).obj X = F.obj X ⊗ G.obj X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F G : C ⥤ D} {X : C}
Goal: (F ⊗ G).obj X = F.obj X ⊗ G.obj X
-- CategoryTheory.Monoidal.tensorObj_map
@[simp]
theorem tensorObj_map {F G : C ⥤ D} {X Y} {f : X ⟶ Y} : (F ⊗ G).map f = F.map f ⊗ G.map f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F G : C ⥤ D} {X Y : C} {f : X ⟶ Y}
Goal: (F ⊗ G).map f = F.map f ⊗ G.map f
-- CategoryTheory.Monoidal.tensorHom_app
@[simp]
theorem tensorHom_app {F G F' G' : C ⥤ D} {α : F ⟶ G} {β : F' ⟶ G'} {X} :
    (α ⊗ β).app X = α.app X ⊗ β.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F G F' G' : C ⥤ D} {α : F ⟶ G} {β : F' ⟶ G'} {X : C}
Goal: (α ⊗ β).app X = α.app X ⊗ β.app X
-- CategoryTheory.Monoidal.whiskerLeft_app
@[simp]
theorem whiskerLeft_app {F F' G' : C ⥤ D} {β : F' ⟶ G'} {X} :
    (F ◁ β).app X = F.obj X ◁ β.app X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F F' G' : C ⥤ D} {β : F' ⟶ G'} {X : C}
Goal: (F ◁ β).app X = F.obj X ◁ β.app X
-- CategoryTheory.Monoidal.whiskerRight_app
@[simp]
theorem whiskerRight_app {F G F' : C ⥤ D} {α : F ⟶ G} {X} :
    (α ▷ F').app X = α.app X ▷ F'.obj X 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F G F' : C ⥤ D} {α : F ⟶ G} {X : C}
Goal: (α ▷ F').app X = α.app X ▷ F'.obj X
-- CategoryTheory.Monoidal.leftUnitor_hom_app
@[simp]
theorem leftUnitor_hom_app {F : C ⥤ D} {X} :
    ((λ_ F).hom : 𝟙_ _ ⊗ F ⟶ F).app X = (λ_ (F.obj X)).hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F : C ⥤ D} {X : C}
Goal: (λ_ F).hom.app X = (λ_ (F.obj X)).hom
-- CategoryTheory.Monoidal.leftUnitor_inv_app
@[simp]
theorem leftUnitor_inv_app {F : C ⥤ D} {X} :
    ((λ_ F).inv : F ⟶ 𝟙_ _ ⊗ F).app X = (λ_ (F.obj X)).inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F : C ⥤ D} {X : C}
Goal: (λ_ F).inv.app X = (λ_ (F.obj X)).inv
-- CategoryTheory.Monoidal.rightUnitor_hom_app
@[simp]
theorem rightUnitor_hom_app {F : C ⥤ D} {X} :
    ((ρ_ F).hom : F ⊗ 𝟙_ _ ⟶ F).app X = (ρ_ (F.obj X)).hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F : C ⥤ D} {X : C}
Goal: (ρ_ F).hom.app X = (ρ_ (F.obj X)).hom
-- CategoryTheory.Monoidal.rightUnitor_inv_app
@[simp]
theorem rightUnitor_inv_app {F : C ⥤ D} {X} :
    ((ρ_ F).inv : F ⟶ F ⊗ 𝟙_ _).app X = (ρ_ (F.obj X)).inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F : C ⥤ D} {X : C}
Goal: (ρ_ F).inv.app X = (ρ_ (F.obj X)).inv
-- CategoryTheory.Monoidal.associator_hom_app
@[simp]
theorem associator_hom_app {F G H : C ⥤ D} {X} :
    ((α_ F G H).hom : (F ⊗ G) ⊗ H ⟶ F ⊗ G ⊗ H).app X = (α_ (F.obj X) (G.obj X) (H.obj X)).hom 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F G H : C ⥤ D} {X : C}
Goal: (α_ F G H).hom.app X = (α_ (F.obj X) (G.obj X) (H.obj X)).hom
-- CategoryTheory.Monoidal.associator_inv_app
@[simp]
theorem associator_inv_app {F G H : C ⥤ D} {X} :
    ((α_ F G H).inv : F ⊗ G ⊗ H ⟶ (F ⊗ G) ⊗ H).app X = (α_ (F.obj X) (G.obj X) (H.obj X)).inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.MonoidalCategory D] {F G H : C ⥤ D} {X : C}
Goal: (α_ F G H).inv.app X = (α_ (F.obj X) (G.obj X) (H.obj X)).inv
-- CategoryTheory.Limits.BinaryFan.swap_fst
@[simp]
theorem BinaryFan.swap_fst {P Q : C} (t : BinaryFan P Q) : t.swap.fst = t.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} (t : CategoryTheory.Limits.BinaryFan P Q)
Goal: t.swap.fst = t.snd
-- CategoryTheory.Limits.BinaryFan.swap_snd
@[simp]
theorem BinaryFan.swap_snd {P Q : C} (t : BinaryFan P Q) : t.swap.snd = t.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} (t : CategoryTheory.Limits.BinaryFan P Q)
Goal: t.swap.snd = t.fst
-- CategoryTheory.Limits.IsLimit.swapBinaryFan_lift
@[simps]
def IsLimit.swapBinaryFan {P Q : C} {t : BinaryFan P Q} (I : IsLimit t) : IsLimit t.swap 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} {t : CategoryTheory.Limits.BinaryFan P Q} (I : CategoryTheory.Limits.IsLimit t) (s : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair Q P))
Goal: I.swapBinaryFan.lift s = I.lift (CategoryTheory.Limits.BinaryFan.swap s)
-- CategoryTheory.Limits.HasBinaryProduct.swap
theorem HasBinaryProduct.swap (P Q : C) [HasBinaryProduct P Q] : HasBinaryProduct Q P 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (P Q : C) [CategoryTheory.Limits.HasBinaryProduct P Q]
Goal: CategoryTheory.Limits.HasBinaryProduct Q P
-- CategoryTheory.Limits.BinaryFan.assoc_fst
@[simp]
theorem BinaryFan.assoc_fst {X Y Z : C} {sXY : BinaryFan X Y} {sYZ : BinaryFan Y Z}
    (Q : IsLimit sYZ) (s : BinaryFan sXY.pt Z) : (BinaryFan.assoc Q s).fst = s.fst ≫ sXY.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {sXY : CategoryTheory.Limits.BinaryFan X Y} {sYZ : CategoryTheory.Limits.BinaryFan Y Z} (Q : CategoryTheory.Limits.IsLimit sYZ) (s : CategoryTheory.Limits.BinaryFan sXY.pt Z)
Goal: (CategoryTheory.Limits.BinaryFan.assoc Q s).fst = CategoryTheory.CategoryStruct.comp s.fst sXY.fst
-- CategoryTheory.Limits.BinaryFan.assoc_snd
@[simp]
theorem BinaryFan.assoc_snd {X Y Z : C} {sXY : BinaryFan X Y} {sYZ : BinaryFan Y Z}
    (Q : IsLimit sYZ) (s : BinaryFan sXY.pt Z) :
    (BinaryFan.assoc Q s).snd = Q.lift (BinaryFan.mk (s.fst ≫ sXY.snd) s.snd) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {sXY : CategoryTheory.Limits.BinaryFan X Y} {sYZ : CategoryTheory.Limits.BinaryFan Y Z} (Q : CategoryTheory.Limits.IsLimit sYZ) (s : CategoryTheory.Limits.BinaryFan sXY.pt Z)
Goal: (CategoryTheory.Limits.BinaryFan.assoc Q s).snd =
  Q.lift (CategoryTheory.Limits.BinaryFan.mk (CategoryTheory.CategoryStruct.comp s.fst sXY.snd) s.snd)
-- CategoryTheory.Limits.BinaryFan.assocInv_fst
@[simp]
theorem BinaryFan.assocInv_fst {X Y Z : C} {sXY : BinaryFan X Y} (P : IsLimit sXY)
    {sYZ : BinaryFan Y Z} (s : BinaryFan X sYZ.pt) :
    (BinaryFan.assocInv P s).fst = P.lift (BinaryFan.mk s.fst (s.snd ≫ sYZ.fst)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {sXY : CategoryTheory.Limits.BinaryFan X Y} (P : CategoryTheory.Limits.IsLimit sXY) {sYZ : CategoryTheory.Limits.BinaryFan Y Z} (s : CategoryTheory.Limits.BinaryFan X sYZ.pt)
Goal: (CategoryTheory.Limits.BinaryFan.assocInv P s).fst =
  P.lift (CategoryTheory.Limits.BinaryFan.mk s.fst (CategoryTheory.CategoryStruct.comp s.snd sYZ.fst))
-- CategoryTheory.Limits.BinaryFan.assocInv_snd
@[simp]
theorem BinaryFan.assocInv_snd {X Y Z : C} {sXY : BinaryFan X Y} (P : IsLimit sXY)
    {sYZ : BinaryFan Y Z} (s : BinaryFan X sYZ.pt) :
    (BinaryFan.assocInv P s).snd = s.snd ≫ sYZ.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {sXY : CategoryTheory.Limits.BinaryFan X Y} (P : CategoryTheory.Limits.IsLimit sXY) {sYZ : CategoryTheory.Limits.BinaryFan Y Z} (s : CategoryTheory.Limits.BinaryFan X sYZ.pt)
Goal: (CategoryTheory.Limits.BinaryFan.assocInv P s).snd = CategoryTheory.CategoryStruct.comp s.snd sYZ.snd
-- CategoryTheory.Limits.IsLimit.assoc_lift
@[simps]
def IsLimit.assoc {X Y Z : C} {sXY : BinaryFan X Y} (P : IsLimit sXY) {sYZ : BinaryFan Y Z}
    (Q : IsLimit sYZ) {s : BinaryFan sXY.pt Z} (R : IsLimit s) : IsLimit (BinaryFan.assoc Q s) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {sXY : CategoryTheory.Limits.BinaryFan X Y} (P : CategoryTheory.Limits.IsLimit sXY) {sYZ : CategoryTheory.Limits.BinaryFan Y Z} (Q : CategoryTheory.Limits.IsLimit sYZ) {s : CategoryTheory.Limits.BinaryFan sXY.pt Z} (R : CategoryTheory.Limits.IsLimit s) (t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X sYZ.pt))
Goal: (P.assoc Q R).lift t = R.lift (CategoryTheory.Limits.BinaryFan.assocInv P t)