File: Mathlib/CategoryTheory/Triangulated/Opposite.lean

full_name: _private.Mathlib.CategoryTheory.Triangulated.Opposite.0.CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux
code: /-- As it is unclear whether the opposite category `Cᵒᵖ` should always be equipped
with the shift by `ℤ` such that shifting by `n` on `Cᵒᵖ` corresponds to shifting
by `-n` on `C`, the user shall have to do `open CategoryTheory.Pretriangulated.Opposite`
in order to get this shift and the (pre)triangulated structure on `Cᵒᵖ`. -/

private abbrev OppositeShiftAux 
goal: Type u_1

full_name: CategoryTheory.Pretriangulated.Opposite.instHasShiftOppositeInt
code: /-- The category `Cᵒᵖ` is equipped with the shift such that the shift by `n` on `Cᵒᵖ`
corresponds to the shift by `-n` on `C`. -/
noncomputable scoped instance : HasShift Cᵒᵖ ℤ 
goal: CategoryTheory.HasShift Cᵒᵖ ℤ

full_name: CategoryTheory.Pretriangulated.Opposite.instAdditiveOppositeShiftFunctorInt
code: instance [Preadditive C] [∀ (n : ℤ), (shiftFunctor C n).Additive] (n : ℤ) :
    (shiftFunctor Cᵒᵖ n).Additive 
goal: (CategoryTheory.shiftFunctor Cᵒᵖ n).Additive

full_name: CategoryTheory.Pretriangulated.shiftFunctorOpIso
code: /-- The shift functor on the opposite category identifies to the opposite functor
of a shift functor on the original category. -/
noncomputable def shiftFunctorOpIso (n m : ℤ) (hnm : n + m = 0) :
    shiftFunctor Cᵒᵖ n ≅ (shiftFunctor C m).op 
goal: CategoryTheory.shiftFunctor Cᵒᵖ n ≅ (CategoryTheory.shiftFunctor C m).op

full_name: CategoryTheory.Pretriangulated.shiftFunctorZero_op_hom_app
code: 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 
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

full_name: CategoryTheory.Pretriangulated.shiftFunctorZero_op_inv_app
code: 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 
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)

full_name: CategoryTheory.Pretriangulated.shiftFunctorAdd'_op_hom_app
code: 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) 
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))))

full_name: CategoryTheory.Pretriangulated.shiftFunctorAdd'_op_inv_app
code: 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 
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)))

full_name: CategoryTheory.Pretriangulated.shiftFunctor_op_map
code: 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 
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))

full_name: CategoryTheory.Pretriangulated.opShiftFunctorEquivalence
code: /-- The autoequivalence `Cᵒᵖ ≌ Cᵒᵖ` whose functor is `shiftFunctor Cᵒᵖ n` and whose inverse
functor is `(shiftFunctor C n).op`. Do not unfold the definitions of the unit and counit
isomorphisms: the compatibilities they satisfy are stated as separate lemmas. -/
@[simps functor inverse]
noncomputable def opShiftFunctorEquivalence (n : ℤ) : Cᵒᵖ ≌ Cᵒᵖ 
goal: Cᵒᵖ ≌ Cᵒᵖ

full_name: CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_functor
code: /-- The autoequivalence `Cᵒᵖ ≌ Cᵒᵖ` whose functor is `shiftFunctor Cᵒᵖ n` and whose inverse
functor is `(shiftFunctor C n).op`. Do not unfold the definitions of the unit and counit
isomorphisms: the compatibilities they satisfy are stated as separate lemmas. -/
@[simps functor inverse]
noncomputable def opShiftFunctorEquivalence (n : ℤ) : Cᵒᵖ ≌ Cᵒᵖ 
goal: (CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).functor = CategoryTheory.shiftFunctor Cᵒᵖ n

full_name: CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_inverse
code: /-- The autoequivalence `Cᵒᵖ ≌ Cᵒᵖ` whose functor is `shiftFunctor Cᵒᵖ n` and whose inverse
functor is `(shiftFunctor C n).op`. Do not unfold the definitions of the unit and counit
isomorphisms: the compatibilities they satisfy are stated as separate lemmas. -/
@[simps functor inverse]
noncomputable def opShiftFunctorEquivalence (n : ℤ) : Cᵒᵖ ≌ Cᵒᵖ 
goal: (CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).inverse = (CategoryTheory.shiftFunctor C n).op

full_name: CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_unitIso_hom_naturality
code: @[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 
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

full_name: CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_unitIso_inv_naturality
code: @[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 
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

full_name: CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_counitIso_hom_naturality
code: @[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 
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

full_name: CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_counitIso_inv_naturality
code: @[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⟧' 
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)

full_name: CategoryTheory.Pretriangulated.shift_unop_opShiftFunctorEquivalence_counitIso_inv_app
code: 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 
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

full_name: CategoryTheory.Pretriangulated.shift_unop_opShiftFunctorEquivalence_counitIso_hom_app
code: 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 
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

full_name: CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_counitIso_inv_app_shift
code: 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⟧' 
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)

full_name: CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_counitIso_hom_app_shift
code: 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⟧' 
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)

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor_map_hom₁
code: /-- The functor which sends a triangle `X ⟶ Y ⟶ Z ⟶ X⟦1⟧` in `C` to the triangle
`op Z ⟶ op Y ⟶ op X ⟶ (op Z)⟦1⟧` in `Cᵒᵖ` (without introducing signs). -/
@[simps]
noncomputable def functor : (Triangle C)ᵒᵖ ⥤ Triangle Cᵒᵖ 
goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).map φ).hom₁ = φ.unop.hom₃.op

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor_obj
code: /-- The functor which sends a triangle `X ⟶ Y ⟶ Z ⟶ X⟦1⟧` in `C` to the triangle
`op Z ⟶ op Y ⟶ op X ⟶ (op Z)⟦1⟧` in `Cᵒᵖ` (without introducing signs). -/
@[simps]
noncomputable def functor : (Triangle C)ᵒᵖ ⥤ 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))

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor_map_hom₂
code: /-- The functor which sends a triangle `X ⟶ Y ⟶ Z ⟶ X⟦1⟧` in `C` to the triangle
`op Z ⟶ op Y ⟶ op X ⟶ (op Z)⟦1⟧` in `Cᵒᵖ` (without introducing signs). -/
@[simps]
noncomputable def functor : (Triangle C)ᵒᵖ ⥤ Triangle Cᵒᵖ 
goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).map φ).hom₂ = φ.unop.hom₂.op

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor_map_hom₃
code: /-- The functor which sends a triangle `X ⟶ Y ⟶ Z ⟶ X⟦1⟧` in `C` to the triangle
`op Z ⟶ op Y ⟶ op X ⟶ (op Z)⟦1⟧` in `Cᵒᵖ` (without introducing signs). -/
@[simps]
noncomputable def functor : (Triangle C)ᵒᵖ ⥤ Triangle Cᵒᵖ 
goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).map φ).hom₃ = φ.unop.hom₁.op

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor
code: /-- The functor which sends a triangle `X ⟶ Y ⟶ Z ⟶ X⟦1⟧` in `C` to the triangle
`op Z ⟶ op Y ⟶ op X ⟶ (op Z)⟦1⟧` in `Cᵒᵖ` (without introducing signs). -/
@[simps]
noncomputable def functor : (Triangle C)ᵒᵖ ⥤ Triangle Cᵒᵖ 
goal: CategoryTheory.Functor (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ (CategoryTheory.Pretriangulated.Triangle Cᵒᵖ)

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse
code: /-- The functor which sends a triangle `X ⟶ Y ⟶ Z ⟶ X⟦1⟧` in `Cᵒᵖ` to the triangle
`Z.unop ⟶ Y.unop ⟶ X.unop ⟶ Z.unop⟦1⟧` in `C` (without introducing signs). -/
@[simps]
noncomputable def inverse : Triangle Cᵒᵖ ⥤ (Triangle C)ᵒᵖ 
goal: CategoryTheory.Functor (CategoryTheory.Pretriangulated.Triangle Cᵒᵖ) (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse_map
code: /-- The functor which sends a triangle `X ⟶ Y ⟶ Z ⟶ X⟦1⟧` in `Cᵒᵖ` to the triangle
`Z.unop ⟶ Y.unop ⟶ X.unop ⟶ Z.unop⟦1⟧` in `C` (without introducing signs). -/
@[simps]
noncomputable def inverse : Triangle Cᵒᵖ ⥤ (Triangle C)ᵒᵖ 
goal: (CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse C).map φ =
  Quiver.Hom.op { hom₁ := φ.hom₃.unop, hom₂ := φ.hom₂.unop, hom₃ := φ.hom₁.unop, comm₁ := ⋯, comm₂ := ⋯, comm₃ := ⋯ }

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse_obj
code: /-- The functor which sends a triangle `X ⟶ Y ⟶ Z ⟶ X⟦1⟧` in `Cᵒᵖ` to the triangle
`Z.unop ⟶ Y.unop ⟶ X.unop ⟶ Z.unop⟦1⟧` in `C` (without introducing signs). -/
@[simps]
noncomputable def inverse : Triangle Cᵒᵖ ⥤ (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)))

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso
code: /-- The unit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . -/
@[simps!]
noncomputable def unitIso : 𝟭 _ ≅ functor C ⋙ inverse C 
goal: CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ ≅
  (CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).comp
    (CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse C)

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso_hom_app
code: /-- The unit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . -/
@[simps!]
noncomputable def unitIso : 𝟭 _ ≅ functor C ⋙ inverse 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

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso_inv_app
code: /-- The unit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . -/
@[simps!]
noncomputable def unitIso : 𝟭 _ ≅ functor C ⋙ inverse 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

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₂
code: /-- The counit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . -/
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).inv.app X).hom₂ =
  CategoryTheory.CategoryStruct.id X.obj₂

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso
code: /-- The counit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . -/
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
goal: (CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse C).comp
    (CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C) ≅
  CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle Cᵒᵖ)

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₃
code: /-- The counit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . -/
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).inv.app X).hom₃ =
  CategoryTheory.CategoryStruct.id X.obj₃

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₁
code: /-- The counit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . -/
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).inv.app X).hom₁ =
  CategoryTheory.CategoryStruct.id X.obj₁

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_hom_app_hom₂
code: /-- The counit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . -/
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).hom.app X).hom₂ =
  CategoryTheory.CategoryStruct.id X.obj₂

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_hom_app_hom₃
code: /-- The counit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . -/
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).hom.app X).hom₃ =
  CategoryTheory.CategoryStruct.id X.obj₃

full_name: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_hom_app_hom₁
code: /-- The counit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . -/
@[simps!]
noncomputable def counitIso : inverse C ⋙ functor C ≅ 𝟭 _ 
goal: ((CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C).hom.app X).hom₁ =
  CategoryTheory.CategoryStruct.id X.obj₁

full_name: CategoryTheory.Pretriangulated.triangleOpEquivalence_counitIso
code: /-- An anti-equivalence between the categories of triangles in `C` and in `Cᵒᵖ`.
A triangle in `Cᵒᵖ` shall be distinguished iff it correspond to a distinguished
triangle in `C` via this equivalence. -/
@[simps]
noncomputable def triangleOpEquivalence :
    (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ 
goal: (CategoryTheory.Pretriangulated.triangleOpEquivalence C).counitIso =
  CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso C

full_name: CategoryTheory.Pretriangulated.triangleOpEquivalence_inverse
code: /-- An anti-equivalence between the categories of triangles in `C` and in `Cᵒᵖ`.
A triangle in `Cᵒᵖ` shall be distinguished iff it correspond to a distinguished
triangle in `C` via this equivalence. -/
@[simps]
noncomputable def triangleOpEquivalence :
    (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ 
goal: (CategoryTheory.Pretriangulated.triangleOpEquivalence C).inverse =
  CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse C

full_name: CategoryTheory.Pretriangulated.triangleOpEquivalence_unitIso
code: /-- An anti-equivalence between the categories of triangles in `C` and in `Cᵒᵖ`.
A triangle in `Cᵒᵖ` shall be distinguished iff it correspond to a distinguished
triangle in `C` via this equivalence. -/
@[simps]
noncomputable def triangleOpEquivalence :
    (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ 
goal: (CategoryTheory.Pretriangulated.triangleOpEquivalence C).unitIso =
  CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso C

full_name: CategoryTheory.Pretriangulated.triangleOpEquivalence
code: /-- An anti-equivalence between the categories of triangles in `C` and in `Cᵒᵖ`.
A triangle in `Cᵒᵖ` shall be distinguished iff it correspond to a distinguished
triangle in `C` via this equivalence. -/
@[simps]
noncomputable def triangleOpEquivalence :
    (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ 
goal: (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ ≌ CategoryTheory.Pretriangulated.Triangle Cᵒᵖ

full_name: CategoryTheory.Pretriangulated.triangleOpEquivalence_functor
code: /-- An anti-equivalence between the categories of triangles in `C` and in `Cᵒᵖ`.
A triangle in `Cᵒᵖ` shall be distinguished iff it correspond to a distinguished
triangle in `C` via this equivalence. -/
@[simps]
noncomputable def triangleOpEquivalence :
    (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ 
goal: (CategoryTheory.Pretriangulated.triangleOpEquivalence C).functor =
  CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C

full_name: CategoryTheory.Pretriangulated.Opposite.distinguishedTriangles
code: /-- A triangle in `Cᵒᵖ` shall be distinguished iff it corresponds to a distinguished
triangle in `C` via the equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ`. -/
def distinguishedTriangles : Set (Triangle Cᵒᵖ) 
goal: Set (CategoryTheory.Pretriangulated.Triangle Cᵒᵖ)

full_name: CategoryTheory.Pretriangulated.Opposite.mem_distinguishedTriangles_iff
code: lemma mem_distinguishedTriangles_iff (T : Triangle Cᵒᵖ) :
    T ∈ distinguishedTriangles C ↔
      ((triangleOpEquivalence C).inverse.obj T).unop ∈ distTriang C 
goal: T ∈ CategoryTheory.Pretriangulated.Opposite.distinguishedTriangles C ↔
  Opposite.unop ((CategoryTheory.Pretriangulated.triangleOpEquivalence C).inverse.obj T) ∈
    CategoryTheory.Pretriangulated.distinguishedTriangles

full_name: CategoryTheory.Pretriangulated.Opposite.mem_distinguishedTriangles_iff'
code: lemma mem_distinguishedTriangles_iff' (T : Triangle Cᵒᵖ) :
    T ∈ distinguishedTriangles C ↔
      ∃ (T' : Triangle C) (_ : T' ∈ distTriang C),
        Nonempty (T ≅ (triangleOpEquivalence C).functor.obj (Opposite.op T')) 
goal: T ∈ CategoryTheory.Pretriangulated.Opposite.distinguishedTriangles C ↔
  ∃ T',
    ∃ (_ : T' ∈ CategoryTheory.Pretriangulated.distinguishedTriangles),
      Nonempty (T ≅ (CategoryTheory.Pretriangulated.triangleOpEquivalence C).functor.obj (Opposite.op T'))

full_name: CategoryTheory.Pretriangulated.Opposite.isomorphic_distinguished
code: lemma isomorphic_distinguished (T₁ : Triangle Cᵒᵖ)
    (hT₁ : T₁ ∈ distinguishedTriangles C) (T₂ : Triangle Cᵒᵖ) (e : T₂ ≅ T₁) :
    T₂ ∈ distinguishedTriangles C 
goal: T₂ ∈ CategoryTheory.Pretriangulated.Opposite.distinguishedTriangles C

full_name: CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso_inv_hom₃
code: /-- Up to rotation, the contractible triangle `X ⟶ X ⟶ 0 ⟶ X⟦1⟧` for `X : Cᵒᵖ` corresponds
to the contractible triangle for `X.unop` in `C`. -/
@[simps!]
noncomputable def contractibleTriangleIso (X : Cᵒᵖ) :
    contractibleTriangle X ≅ (triangleOpEquivalence C).functor.obj
      (Opposite.op (contractibleTriangle X.unop).invRotate) 
goal: (CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso X).inv.hom₃ = (⋯.iso ⋯).inv

full_name: CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso_hom_hom₁
code: /-- Up to rotation, the contractible triangle `X ⟶ X ⟶ 0 ⟶ X⟦1⟧` for `X : Cᵒᵖ` corresponds
to the contractible triangle for `X.unop` in `C`. -/
@[simps!]
noncomputable def contractibleTriangleIso (X : Cᵒᵖ) :
    contractibleTriangle X ≅ (triangleOpEquivalence C).functor.obj
      (Opposite.op (contractibleTriangle X.unop).invRotate) 
goal: (CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso X).hom.hom₁ = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso_inv_hom₁
code: /-- Up to rotation, the contractible triangle `X ⟶ X ⟶ 0 ⟶ X⟦1⟧` for `X : Cᵒᵖ` corresponds
to the contractible triangle for `X.unop` in `C`. -/
@[simps!]
noncomputable def contractibleTriangleIso (X : Cᵒᵖ) :
    contractibleTriangle X ≅ (triangleOpEquivalence C).functor.obj
      (Opposite.op (contractibleTriangle X.unop).invRotate) 
goal: (CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso X).inv.hom₁ = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso
code: /-- Up to rotation, the contractible triangle `X ⟶ X ⟶ 0 ⟶ X⟦1⟧` for `X : Cᵒᵖ` corresponds
to the contractible triangle for `X.unop` in `C`. -/
@[simps!]
noncomputable def contractibleTriangleIso (X : Cᵒᵖ) :
    contractibleTriangle X ≅ (triangleOpEquivalence C).functor.obj
      (Opposite.op (contractibleTriangle X.unop).invRotate) 
goal: CategoryTheory.Pretriangulated.contractibleTriangle X ≅
  (CategoryTheory.Pretriangulated.triangleOpEquivalence C).functor.obj
    (Opposite.op (CategoryTheory.Pretriangulated.contractibleTriangle (Opposite.unop X)).invRotate)

full_name: CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso_hom_hom₃
code: /-- Up to rotation, the contractible triangle `X ⟶ X ⟶ 0 ⟶ X⟦1⟧` for `X : Cᵒᵖ` corresponds
to the contractible triangle for `X.unop` in `C`. -/
@[simps!]
noncomputable def contractibleTriangleIso (X : Cᵒᵖ) :
    contractibleTriangle X ≅ (triangleOpEquivalence C).functor.obj
      (Opposite.op (contractibleTriangle X.unop).invRotate) 
goal: (CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso X).hom.hom₃ = (⋯.iso ⋯).hom

full_name: CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso_inv_hom₂
code: /-- Up to rotation, the contractible triangle `X ⟶ X ⟶ 0 ⟶ X⟦1⟧` for `X : Cᵒᵖ` corresponds
to the contractible triangle for `X.unop` in `C`. -/
@[simps!]
noncomputable def contractibleTriangleIso (X : Cᵒᵖ) :
    contractibleTriangle X ≅ (triangleOpEquivalence C).functor.obj
      (Opposite.op (contractibleTriangle X.unop).invRotate) 
goal: (CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso X).inv.hom₂ = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso_hom_hom₂
code: /-- Up to rotation, the contractible triangle `X ⟶ X ⟶ 0 ⟶ X⟦1⟧` for `X : Cᵒᵖ` corresponds
to the contractible triangle for `X.unop` in `C`. -/
@[simps!]
noncomputable def contractibleTriangleIso (X : Cᵒᵖ) :
    contractibleTriangle X ≅ (triangleOpEquivalence C).functor.obj
      (Opposite.op (contractibleTriangle X.unop).invRotate) 
goal: (CategoryTheory.Pretriangulated.Opposite.contractibleTriangleIso X).hom.hom₂ = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Pretriangulated.Opposite.contractible_distinguished
code: lemma contractible_distinguished (X : Cᵒᵖ) :
    contractibleTriangle X ∈ distinguishedTriangles C 
goal: CategoryTheory.Pretriangulated.contractibleTriangle X ∈ CategoryTheory.Pretriangulated.Opposite.distinguishedTriangles C

full_name: CategoryTheory.Pretriangulated.Opposite.rotateTriangleOpEquivalenceInverseObjRotateUnopIso
code: /-- Isomorphism expressing a compatibility of the equivalence `triangleOpEquivalence C`
with the rotation of triangles. -/
noncomputable def rotateTriangleOpEquivalenceInverseObjRotateUnopIso (T : Triangle Cᵒᵖ) :
    ((triangleOpEquivalence C).inverse.obj T.rotate).unop.rotate ≅
      ((triangleOpEquivalence C).inverse.obj T).unop 
goal: (Opposite.unop ((CategoryTheory.Pretriangulated.triangleOpEquivalence C).inverse.obj T.rotate)).rotate ≅
  Opposite.unop ((CategoryTheory.Pretriangulated.triangleOpEquivalence C).inverse.obj T)

full_name: CategoryTheory.Pretriangulated.Opposite.rotate_distinguished_triangle
code: lemma rotate_distinguished_triangle (T : Triangle Cᵒᵖ) :
    T ∈ distinguishedTriangles C ↔ T.rotate ∈ distinguishedTriangles C 
goal: T ∈ CategoryTheory.Pretriangulated.Opposite.distinguishedTriangles C ↔
  T.rotate ∈ CategoryTheory.Pretriangulated.Opposite.distinguishedTriangles C

full_name: CategoryTheory.Pretriangulated.Opposite.distinguished_cocone_triangle
code: lemma distinguished_cocone_triangle {X Y : Cᵒᵖ} (f : X ⟶ Y) :
    ∃ (Z : Cᵒᵖ) (g : Y ⟶ Z) (h : Z ⟶ X⟦(1 : ℤ)⟧),
      Triangle.mk f g h ∈ distinguishedTriangles C 
goal: ∃ Z g h,
  CategoryTheory.Pretriangulated.Triangle.mk f g h ∈ CategoryTheory.Pretriangulated.Opposite.distinguishedTriangles C

full_name: CategoryTheory.Pretriangulated.Opposite.complete_distinguished_triangle_morphism
code: lemma complete_distinguished_triangle_morphism (T₁ T₂ : Triangle Cᵒᵖ)
    (hT₁ : T₁ ∈ distinguishedTriangles C) (hT₂ : T₂ ∈ distinguishedTriangles C)
    (a : T₁.obj₁ ⟶ T₂.obj₁) (b : T₁.obj₂ ⟶ T₂.obj₂) (comm : T₁.mor₁ ≫ b = a ≫ T₂.mor₁) :
    ∃ (c : T₁.obj₃ ⟶ T₂.obj₃), T₁.mor₂ ≫ c = b ≫ T₂.mor₂ ∧
      T₁.mor₃ ≫ a⟦1⟧' = c ≫ T₂.mor₃ 
goal: ∃ c,
  CategoryTheory.CategoryStruct.comp T₁.mor₂ c = CategoryTheory.CategoryStruct.comp b T₂.mor₂ ∧
    CategoryTheory.CategoryStruct.comp T₁.mor₃ ((CategoryTheory.shiftFunctor Cᵒᵖ 1).map a) =
      CategoryTheory.CategoryStruct.comp c T₂.mor₃

full_name: CategoryTheory.Pretriangulated.Opposite.instOpposite
code: /-- The pretriangulated structure on the opposite category of
a pretriangulated category. It is a scoped instance, so that we need to
`open CategoryTheory.Pretriangulated.Opposite` in order to be able
to use it: the reason is that it relies on the definition of the shift
on the opposite category `Cᵒᵖ`, for which it is unclear whether it should
be a global instance or not. -/
scoped instance : Pretriangulated Cᵒᵖ 
goal: CategoryTheory.Pretriangulated Cᵒᵖ

full_name: CategoryTheory.Pretriangulated.mem_distTriang_op_iff
code: lemma mem_distTriang_op_iff (T : Triangle Cᵒᵖ) :
    (T ∈ distTriang Cᵒᵖ) ↔ ((triangleOpEquivalence C).inverse.obj T).unop ∈ distTriang C 
goal: T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles ↔
  Opposite.unop ((CategoryTheory.Pretriangulated.triangleOpEquivalence C).inverse.obj T) ∈
    CategoryTheory.Pretriangulated.distinguishedTriangles

full_name: CategoryTheory.Pretriangulated.mem_distTriang_op_iff'
code: lemma mem_distTriang_op_iff' (T : Triangle Cᵒᵖ) :
    (T ∈ distTriang Cᵒᵖ) ↔ ∃ (T' : Triangle C) (_ : T' ∈ distTriang C),
      Nonempty (T ≅ (triangleOpEquivalence C).functor.obj (Opposite.op T')) 
goal: T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles ↔
  ∃ T',
    ∃ (_ : T' ∈ CategoryTheory.Pretriangulated.distinguishedTriangles),
      Nonempty (T ≅ (CategoryTheory.Pretriangulated.triangleOpEquivalence C).functor.obj (Opposite.op T'))

full_name: CategoryTheory.Pretriangulated.op_distinguished
code: lemma op_distinguished (T : Triangle C) (hT : T ∈ distTriang C) :
    ((triangleOpEquivalence C).functor.obj (Opposite.op T)) ∈ distTriang Cᵒᵖ 
goal: (CategoryTheory.Pretriangulated.triangleOpEquivalence C).functor.obj (Opposite.op T) ∈
  CategoryTheory.Pretriangulated.distinguishedTriangles

full_name: CategoryTheory.Pretriangulated.unop_distinguished
code: lemma unop_distinguished (T : Triangle Cᵒᵖ) (hT : T ∈ distTriang Cᵒᵖ) :
    ((triangleOpEquivalence C).inverse.obj T).unop ∈ distTriang C 
goal: Opposite.unop ((CategoryTheory.Pretriangulated.triangleOpEquivalence C).inverse.obj T) ∈
  CategoryTheory.Pretriangulated.distinguishedTriangles

full_name: CategoryTheory.Functor.map_distinguished_op_exact
code: lemma map_distinguished_op_exact [HasShift C ℤ] [HasZeroObject C] [Preadditive C]
    [∀ (n : ℤ), (shiftFunctor C n).Additive]
    [Pretriangulated C]{A : Type*} [Category A] [Abelian A] (F : Cᵒᵖ ⥤ A)
    [F.IsHomological] (T : Triangle C) (hT : T ∈ distTriang C) :
    ((shortComplexOfDistTriangle T hT).op.map F).Exact 
goal: ((CategoryTheory.Pretriangulated.shortComplexOfDistTriangle T hT).op.map F).Exact