ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.OplaxFunctor.bicategory_associator_hom_app
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
instance OplaxFunctor.bicategory : Bicategory (OplaxFunctor B C) 
Arguments: (B : Type u₁) [CategoryTheory.Bicategory B] (C : Type u₂) [CategoryTheory.Bicategory C] {F G H : CategoryTheory.OplaxFunctor B C} (I : CategoryTheory.OplaxFunctor B C) (η : F ⟶ G) (θ : G ⟶ H) (ι : H ⟶ I) (a : B)
Goal: (CategoryTheory.Bicategory.associator η θ ι).hom.app a =
  (CategoryTheory.Bicategory.associator (η.app a) (θ.app a) (ι.app a)).hom
-- CategoryTheory.OplaxFunctor.bicategory_associator_inv_app
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
instance OplaxFunctor.bicategory : Bicategory (OplaxFunctor B C) 
Arguments: (B : Type u₁) [CategoryTheory.Bicategory B] (C : Type u₂) [CategoryTheory.Bicategory C] {F G H : CategoryTheory.OplaxFunctor B C} (I : CategoryTheory.OplaxFunctor B C) (η : F ⟶ G) (θ : G ⟶ H) (ι : H ⟶ I) (a : B)
Goal: (CategoryTheory.Bicategory.associator η θ ι).inv.app a =
  (CategoryTheory.Bicategory.associator (η.app a) (θ.app a) (ι.app a)).inv
-- CategoryTheory.OplaxFunctor.bicategory_homCategory_comp_app
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
instance OplaxFunctor.bicategory : Bicategory (OplaxFunctor B C) 
Arguments: (B : Type u₁) [CategoryTheory.Bicategory B] (C : Type u₂) [CategoryTheory.Bicategory C] (a b : CategoryTheory.OplaxFunctor B C)
Goal: ∀ {X Y Z : a ⟶ b} (Γ : CategoryTheory.OplaxNatTrans.Modification X Y)
  (Δ : CategoryTheory.OplaxNatTrans.Modification Y Z) (a_1 : B),
  (CategoryTheory.CategoryStruct.comp Γ Δ).app a_1 = CategoryTheory.CategoryStruct.comp (Γ.app a_1) (Δ.app a_1)
-- CategoryTheory.OplaxFunctor.bicategory_rightUnitor_inv_app
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
instance OplaxFunctor.bicategory : Bicategory (OplaxFunctor B C) 
Arguments: (B : Type u₁) [CategoryTheory.Bicategory B] (C : Type u₂) [CategoryTheory.Bicategory C] {F G : CategoryTheory.OplaxFunctor B C} (η : F ⟶ G) (a : B)
Goal: (CategoryTheory.Bicategory.rightUnitor η).inv.app a = (CategoryTheory.Bicategory.rightUnitor (η.app a)).inv
-- CategoryTheory.OplaxFunctor.bicategory_leftUnitor_hom_app
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
instance OplaxFunctor.bicategory : Bicategory (OplaxFunctor B C) 
Arguments: (B : Type u₁) [CategoryTheory.Bicategory B] (C : Type u₂) [CategoryTheory.Bicategory C] {F G : CategoryTheory.OplaxFunctor B C} (η : F ⟶ G) (a : B)
Goal: (CategoryTheory.Bicategory.leftUnitor η).hom.app a = (CategoryTheory.Bicategory.leftUnitor (η.app a)).hom
-- CategoryTheory.OplaxFunctor.bicategory_comp_app
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
instance OplaxFunctor.bicategory : Bicategory (OplaxFunctor B C) 
Arguments: (B : Type u₁) [CategoryTheory.Bicategory B] (C : Type u₂) [CategoryTheory.Bicategory C]
Goal: ∀ {X Y Z : CategoryTheory.OplaxFunctor B C} (η : CategoryTheory.OplaxNatTrans X Y)
  (θ : CategoryTheory.OplaxNatTrans Y Z) (a : B),
  (CategoryTheory.CategoryStruct.comp η θ).app a = CategoryTheory.CategoryStruct.comp (η.app a) (θ.app a)
-- CategoryTheory.OplaxFunctor.bicategory_whiskerRight_app
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
instance OplaxFunctor.bicategory : Bicategory (OplaxFunctor B C) 
Arguments: (B : Type u₁) [CategoryTheory.Bicategory B] (C : Type u₂) [CategoryTheory.Bicategory C] {F G H : CategoryTheory.OplaxFunctor B C}
Goal: ∀ (x x_1 : F ⟶ G) (Γ : x ⟶ x_1) (η : G ⟶ H) (a : B),
  (CategoryTheory.Bicategory.whiskerRight Γ η).app a = CategoryTheory.Bicategory.whiskerRight (Γ.app a) (η.app a)
-- CategoryTheory.OplaxFunctor.bicategory_leftUnitor_inv_app
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
instance OplaxFunctor.bicategory : Bicategory (OplaxFunctor B C) 
Arguments: (B : Type u₁) [CategoryTheory.Bicategory B] (C : Type u₂) [CategoryTheory.Bicategory C] {F G : CategoryTheory.OplaxFunctor B C} (η : F ⟶ G) (a : B)
Goal: (CategoryTheory.Bicategory.leftUnitor η).inv.app a = (CategoryTheory.Bicategory.leftUnitor (η.app a)).inv
-- CategoryTheory.OplaxFunctor.bicategory_id_app
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
instance OplaxFunctor.bicategory : Bicategory (OplaxFunctor B C) 
Arguments: (B : Type u₁) [CategoryTheory.Bicategory B] (C : Type u₂) [CategoryTheory.Bicategory C] (F : CategoryTheory.OplaxFunctor B C) (a : B)
Goal: (CategoryTheory.CategoryStruct.id F).app a = CategoryTheory.CategoryStruct.id (F.obj a)
-- CategoryTheory.OplaxFunctor.bicategory_Hom
-- Porting note: verified that projections are correct and changed @[simps] to @[simps!]
@[simps!]
instance OplaxFunctor.bicategory : Bicategory (OplaxFunctor B C) 
Arguments: (B : Type u₁) [CategoryTheory.Bicategory B] (C : Type u₂) [CategoryTheory.Bicategory C] (F G : CategoryTheory.OplaxFunctor B C)
Goal: (F ⟶ G) = CategoryTheory.OplaxNatTrans F G
-- CategoryTheory.Pretriangulated.shiftFunctorZero_op_hom_app
lemma shiftFunctorZero_op_hom_app (X : Cᵒᵖ) :
    (shiftFunctorZero Cᵒᵖ ℤ).hom.app X = (shiftFunctorOpIso C 0 0 (zero_add 0)).hom.app X ≫
      ((shiftFunctorZero C ℤ).inv.app X.unop).op 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : Cᵒᵖ)
Goal: (CategoryTheory.shiftFunctorZero Cᵒᵖ ℤ).hom.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Pretriangulated.shiftFunctorOpIso C 0 0 ⋯).hom.app X)
    ((CategoryTheory.shiftFunctorZero C ℤ).inv.app (Opposite.unop X)).op
-- CategoryTheory.Pretriangulated.shiftFunctorZero_op_inv_app
lemma shiftFunctorZero_op_inv_app (X : Cᵒᵖ) :
    (shiftFunctorZero Cᵒᵖ ℤ).inv.app X =
      ((shiftFunctorZero C ℤ).hom.app X.unop).op ≫
      (shiftFunctorOpIso C 0 0 (zero_add 0)).inv.app X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : Cᵒᵖ)
Goal: (CategoryTheory.shiftFunctorZero Cᵒᵖ ℤ).inv.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorZero C ℤ).hom.app (Opposite.unop X)).op
    ((CategoryTheory.Pretriangulated.shiftFunctorOpIso C 0 0 ⋯).inv.app X)
-- CategoryTheory.Pretriangulated.shiftFunctorAdd'_op_hom_app
lemma shiftFunctorAdd'_op_hom_app (X : Cᵒᵖ) (a₁ a₂ a₃ : ℤ) (h : a₁ + a₂ = a₃)
    (b₁ b₂ b₃ : ℤ) (h₁ : a₁ + b₁ = 0) (h₂ : a₂ + b₂ = 0) (h₃ : a₃ + b₃ = 0) :
    (shiftFunctorAdd' Cᵒᵖ a₁ a₂ a₃ h).hom.app X =
      (shiftFunctorOpIso C _ _ h₃).hom.app X ≫
        ((shiftFunctorAdd' C b₁ b₂ b₃ (by omega)).inv.app X.unop).op ≫
        (shiftFunctorOpIso C _ _ h₂).inv.app _ ≫
        (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C _ _ h₁).inv.app X) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : Cᵒᵖ) (a₁ a₂ a₃ : ℤ) (h : a₁ + a₂ = a₃) (b₁ b₂ b₃ : ℤ) (h₁ : a₁ + b₁ = 0) (h₂ : a₂ + b₂ = 0) (h₃ : a₃ + b₃ = 0)
Goal: (CategoryTheory.shiftFunctorAdd' Cᵒᵖ a₁ a₂ a₃ h).hom.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Pretriangulated.shiftFunctorOpIso C a₃ b₃ h₃).hom.app X)
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd' C b₁ b₂ b₃ ⋯).inv.app (Opposite.unop X)).op
      (CategoryTheory.CategoryStruct.comp
        ((CategoryTheory.Pretriangulated.shiftFunctorOpIso C a₂ b₂ h₂).inv.app
          (Opposite.op ((CategoryTheory.shiftFunctor C b₁).toPrefunctor.1 (Opposite.unop X))))
        ((CategoryTheory.shiftFunctor Cᵒᵖ a₂).map
          ((CategoryTheory.Pretriangulated.shiftFunctorOpIso C a₁ b₁ h₁).inv.app X))))
-- CategoryTheory.Pretriangulated.shiftFunctorAdd'_op_inv_app
lemma shiftFunctorAdd'_op_inv_app (X : Cᵒᵖ) (a₁ a₂ a₃ : ℤ) (h : a₁ + a₂ = a₃)
    (b₁ b₂ b₃ : ℤ) (h₁ : a₁ + b₁ = 0) (h₂ : a₂ + b₂ = 0) (h₃ : a₃ + b₃ = 0) :
    (shiftFunctorAdd' Cᵒᵖ a₁ a₂ a₃ h).inv.app X =
      (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C _ _ h₁).hom.app X) ≫
      (shiftFunctorOpIso C _ _ h₂).hom.app _ ≫
      ((shiftFunctorAdd' C b₁ b₂ b₃ (by omega)).hom.app X.unop).op ≫
      (shiftFunctorOpIso C _ _ h₃).inv.app X 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : Cᵒᵖ) (a₁ a₂ a₃ : ℤ) (h : a₁ + a₂ = a₃) (b₁ b₂ b₃ : ℤ) (h₁ : a₁ + b₁ = 0) (h₂ : a₂ + b₂ = 0) (h₃ : a₃ + b₃ = 0)
Goal: (CategoryTheory.shiftFunctorAdd' Cᵒᵖ a₁ a₂ a₃ h).inv.app X =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor Cᵒᵖ a₂).map ((CategoryTheory.Pretriangulated.shiftFunctorOpIso C a₁ b₁ h₁).hom.app X))
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.Pretriangulated.shiftFunctorOpIso C a₂ b₂ h₂).hom.app
        ((CategoryTheory.shiftFunctor C b₁).op.obj X))
      (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd' C b₁ b₂ b₃ ⋯).hom.app (Opposite.unop X)).op
        ((CategoryTheory.Pretriangulated.shiftFunctorOpIso C a₃ b₃ h₃).inv.app X)))
-- CategoryTheory.Pretriangulated.shiftFunctor_op_map
lemma shiftFunctor_op_map (n m : ℤ) (hnm : n + m = 0) {K L : Cᵒᵖ} (φ : K ⟶ L) :
    (shiftFunctor Cᵒᵖ n).map φ =
      (shiftFunctorOpIso C n m hnm).hom.app K ≫ ((shiftFunctor C m).map φ.unop).op ≫
        (shiftFunctorOpIso C n m hnm).inv.app L 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (n m : ℤ) (hnm : n + m = 0) {K L : Cᵒᵖ} (φ : K ⟶ L)
Goal: (CategoryTheory.shiftFunctor Cᵒᵖ n).map φ =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Pretriangulated.shiftFunctorOpIso C n m hnm).hom.app K)
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C m).map φ.unop).op
      ((CategoryTheory.Pretriangulated.shiftFunctorOpIso C n m hnm).inv.app L))
-- CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_functor
@[simps functor inverse]
noncomputable def opShiftFunctorEquivalence (n : ℤ) : Cᵒᵖ ≌ Cᵒᵖ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (n : ℤ)
Goal: (CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).functor = CategoryTheory.shiftFunctor Cᵒᵖ n
-- CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_inverse
@[simps functor inverse]
noncomputable def opShiftFunctorEquivalence (n : ℤ) : Cᵒᵖ ≌ Cᵒᵖ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (n : ℤ)
Goal: (CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).inverse = (CategoryTheory.shiftFunctor C n).op
-- CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_unitIso_hom_naturality
@[reassoc (attr := simp)]
lemma opShiftFunctorEquivalence_unitIso_hom_naturality (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y) :
    f ≫ (opShiftFunctorEquivalence C n).unitIso.hom.app Y =
      (opShiftFunctorEquivalence C n).unitIso.hom.app X ≫ (f⟦n⟧').unop⟦n⟧'.op 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp f
    ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.hom.app Y) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.hom.app X)
    ((CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctor Cᵒᵖ n).map f).unop).op
-- CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_unitIso_inv_naturality
@[reassoc (attr := simp)]
lemma opShiftFunctorEquivalence_unitIso_inv_naturality (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y) :
    (f⟦n⟧').unop⟦n⟧'.op ≫ (opShiftFunctorEquivalence C n).unitIso.inv.app Y =
      (opShiftFunctorEquivalence C n).unitIso.inv.app X ≫ f 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctor Cᵒᵖ n).map f).unop).op
    ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.inv.app Y) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.inv.app X)
    f
-- CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_counitIso_hom_naturality
@[reassoc (attr := simp)]
lemma opShiftFunctorEquivalence_counitIso_hom_naturality (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y) :
    f.unop⟦n⟧'.op⟦n⟧' ≫ (opShiftFunctorEquivalence C n).counitIso.hom.app Y =
      (opShiftFunctorEquivalence C n).counitIso.hom.app X ≫ f 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor Cᵒᵖ n).map ((CategoryTheory.shiftFunctor C n).map f.unop).op)
    ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).counitIso.hom.app Y) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).counitIso.hom.app X) f
-- CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_counitIso_inv_naturality
@[reassoc (attr := simp)]
lemma opShiftFunctorEquivalence_counitIso_inv_naturality (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y) :
    f ≫ (opShiftFunctorEquivalence C n).counitIso.inv.app Y =
      (opShiftFunctorEquivalence C n).counitIso.inv.app X ≫ f.unop⟦n⟧'.op⟦n⟧' 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp f
    ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).counitIso.inv.app Y) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).counitIso.inv.app X)
    ((CategoryTheory.shiftFunctor Cᵒᵖ n).map ((CategoryTheory.shiftFunctor C n).map f.unop).op)
-- CategoryTheory.Pretriangulated.shift_unop_opShiftFunctorEquivalence_counitIso_inv_app
lemma shift_unop_opShiftFunctorEquivalence_counitIso_inv_app (X : Cᵒᵖ) (n : ℤ) :
    ((opShiftFunctorEquivalence C n).counitIso.inv.app X).unop⟦n⟧' =
      ((opShiftFunctorEquivalence C n).unitIso.hom.app ((Opposite.op ((X.unop)⟦n⟧)))).unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : Cᵒᵖ) (n : ℤ)
Goal: (CategoryTheory.shiftFunctor C n).map
    ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).counitIso.inv.app X).unop =
  ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.hom.app
      (Opposite.op ((CategoryTheory.shiftFunctor C n).obj (Opposite.unop X)))).unop
-- CategoryTheory.Pretriangulated.shift_unop_opShiftFunctorEquivalence_counitIso_hom_app
lemma shift_unop_opShiftFunctorEquivalence_counitIso_hom_app (X : Cᵒᵖ) (n : ℤ) :
    ((opShiftFunctorEquivalence C n).counitIso.hom.app X).unop⟦n⟧' =
      ((opShiftFunctorEquivalence C n).unitIso.inv.app ((Opposite.op (X.unop⟦n⟧)))).unop 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : Cᵒᵖ) (n : ℤ)
Goal: (CategoryTheory.shiftFunctor C n).map
    ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).counitIso.hom.app X).unop =
  ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.inv.app
      (Opposite.op ((CategoryTheory.shiftFunctor C n).obj (Opposite.unop X)))).unop
-- CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_counitIso_inv_app_shift
lemma opShiftFunctorEquivalence_counitIso_inv_app_shift (X : Cᵒᵖ) (n : ℤ) :
    (opShiftFunctorEquivalence C n).counitIso.inv.app (X⟦n⟧) =
      ((opShiftFunctorEquivalence C n).unitIso.hom.app X)⟦n⟧' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : Cᵒᵖ) (n : ℤ)
Goal: (CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).counitIso.inv.app
    ((CategoryTheory.shiftFunctor Cᵒᵖ n).obj X) =
  (CategoryTheory.shiftFunctor Cᵒᵖ n).map
    ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.hom.app X)
-- CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_counitIso_hom_app_shift
lemma opShiftFunctorEquivalence_counitIso_hom_app_shift (X : Cᵒᵖ) (n : ℤ) :
    (opShiftFunctorEquivalence C n).counitIso.hom.app (X⟦n⟧) =
      ((opShiftFunctorEquivalence C n).unitIso.inv.app X)⟦n⟧' 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : Cᵒᵖ) (n : ℤ)
Goal: (CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).counitIso.hom.app
    ((CategoryTheory.shiftFunctor Cᵒᵖ n).obj X) =
  (CategoryTheory.shiftFunctor Cᵒᵖ n).map
    ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.inv.app X)
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor_map_hom₁
@[simps]
noncomputable def functor : (Triangle C)ᵒᵖ ⥤ Triangle Cᵒᵖ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] {T₁ T₂ : (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ} (φ : T₁ ⟶ T₂)
Goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).map φ).hom₁ = φ.unop.hom₃.op
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor_obj
@[simps]
noncomputable def functor : (Triangle C)ᵒᵖ ⥤ Triangle Cᵒᵖ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (T : (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ)
Goal: (CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).obj T =
  CategoryTheory.Pretriangulated.Triangle.mk (Opposite.unop T).mor₂.op (Opposite.unop T).mor₁.op
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 1).counitIso.inv.app
        (Opposite.op (Opposite.unop T).obj₁))
      ((CategoryTheory.shiftFunctor Cᵒᵖ 1).map (Opposite.unop T).mor₃.op))
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor_map_hom₂
@[simps]
noncomputable def functor : (Triangle C)ᵒᵖ ⥤ Triangle Cᵒᵖ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] {T₁ T₂ : (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ} (φ : T₁ ⟶ T₂)
Goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).map φ).hom₂ = φ.unop.hom₂.op
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor_map_hom₃
@[simps]
noncomputable def functor : (Triangle C)ᵒᵖ ⥤ Triangle Cᵒᵖ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] {T₁ T₂ : (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ} (φ : T₁ ⟶ T₂)
Goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).map φ).hom₃ = φ.unop.hom₁.op
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse_map
@[simps]
noncomputable def inverse : Triangle Cᵒᵖ ⥤ (Triangle C)ᵒᵖ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] {T₁ T₂ : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ} (φ : T₁ ⟶ T₂)
Goal: (CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse C).map φ =
  Quiver.Hom.op { hom₁ := φ.hom₃.unop, hom₂ := φ.hom₂.unop, hom₃ := φ.hom₁.unop, comm₁ := ⋯, comm₂ := ⋯, comm₃ := ⋯ }
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse_obj
@[simps]
noncomputable def inverse : Triangle Cᵒᵖ ⥤ (Triangle C)ᵒᵖ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ)
Goal: (CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse C).obj T =
  Opposite.op
    (CategoryTheory.Pretriangulated.Triangle.mk T.mor₂.unop T.mor₁.unop
      (CategoryTheory.CategoryStruct.comp
        ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 1).unitIso.inv.app T.obj₁).unop
        ((CategoryTheory.shiftFunctor C 1).map T.mor₃.unop)))
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso_hom_app
@[simps!]
noncomputable def unitIso : 𝟭 _ ≅ functor C ⋙ inverse C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ)
Goal: (CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso C).hom.app X =
  ((CategoryTheory.Pretriangulated.Triangle.mk (Opposite.unop X).mor₁ (Opposite.unop X).mor₂
          (CategoryTheory.CategoryStruct.comp
            ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 1).unitIso.inv.app
                (Opposite.op (Opposite.unop X).obj₃)).unop
            ((CategoryTheory.shiftFunctor C 1).map
              (CategoryTheory.CategoryStruct.comp
                ((CategoryTheory.shiftFunctor Cᵒᵖ 1).map (Opposite.unop X).mor₃.op).unop
                ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 1).counitIso.inv.app
                    (Opposite.op (Opposite.unop X).obj₁)).unop)))).homMk
      (Opposite.unop X) (CategoryTheory.CategoryStruct.id (Opposite.unop X).obj₁)
      (CategoryTheory.CategoryStruct.id (Opposite.unop X).obj₂)
      (CategoryTheory.CategoryStruct.id (Opposite.unop X).obj₃) ⋯ ⋯ ⋯).op
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso_inv_app
@[simps!]
noncomputable def unitIso : 𝟭 _ ≅ functor C ⋙ inverse C 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ)
Goal: (CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso C).inv.app X =
  ((Opposite.unop X).homMk
      (CategoryTheory.Pretriangulated.Triangle.mk (Opposite.unop X).mor₁ (Opposite.unop X).mor₂
        (CategoryTheory.CategoryStruct.comp
          ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 1).unitIso.inv.app
              (Opposite.op (Opposite.unop X).obj₃)).unop
          ((CategoryTheory.shiftFunctor C 1).map
            (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor Cᵒᵖ 1).map (Opposite.unop X).mor₃.op).unop
              ((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C 1).counitIso.inv.app
                  (Opposite.op (Opposite.unop X).obj₁)).unop))))
      (CategoryTheory.CategoryStruct.id (Opposite.unop X).obj₁)
      (CategoryTheory.CategoryStruct.id (Opposite.unop X).obj₂)
      (CategoryTheory.CategoryStruct.id (Opposite.unop X).obj₃) ⋯ ⋯ ⋯).op
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₂
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ)
Goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).inv.app X).hom₂ =
  CategoryTheory.CategoryStruct.id X.obj₂
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₃
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ)
Goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).inv.app X).hom₃ =
  CategoryTheory.CategoryStruct.id X.obj₃
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₁
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ)
Goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).inv.app X).hom₁ =
  CategoryTheory.CategoryStruct.id X.obj₁
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_hom_app_hom₂
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ)
Goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).hom.app X).hom₂ =
  CategoryTheory.CategoryStruct.id X.obj₂
-- CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_hom_app_hom₃
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.HasShift C ℤ] (X : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ)
Goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).hom.app X).hom₃ =
  CategoryTheory.CategoryStruct.id X.obj₃