File: Mathlib/CategoryTheory/Triangulated/Functor.lean

full_name: CategoryTheory.Functor.mapTriangle_map_hom₁
code: /-- The functor `Triangle C ⥤ Triangle D` that is induced by a functor `F : C ⥤ D`
which commutes with shift by `ℤ`. -/
@[simps]
def mapTriangle : Triangle C ⥤ Triangle D 
goal: ∀ {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y), (F.mapTriangle.map f).hom₁ = F.map f.hom₁

full_name: CategoryTheory.Functor.mapTriangle_map_hom₂
code: /-- The functor `Triangle C ⥤ Triangle D` that is induced by a functor `F : C ⥤ D`
which commutes with shift by `ℤ`. -/
@[simps]
def mapTriangle : Triangle C ⥤ Triangle D 
goal: ∀ {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y), (F.mapTriangle.map f).hom₂ = F.map f.hom₂

full_name: CategoryTheory.Functor.mapTriangle_obj
code: /-- The functor `Triangle C ⥤ Triangle D` that is induced by a functor `F : C ⥤ D`
which commutes with shift by `ℤ`. -/
@[simps]
def mapTriangle : Triangle C ⥤ Triangle D 
goal: F.mapTriangle.obj T =
  CategoryTheory.Pretriangulated.Triangle.mk (F.map T.mor₁) (F.map T.mor₂)
    (CategoryTheory.CategoryStruct.comp (F.map T.mor₃) ((F.commShiftIso 1).hom.app T.obj₁))

full_name: CategoryTheory.Functor.mapTriangle_map_hom₃
code: /-- The functor `Triangle C ⥤ Triangle D` that is induced by a functor `F : C ⥤ D`
which commutes with shift by `ℤ`. -/
@[simps]
def mapTriangle : Triangle C ⥤ Triangle D 
goal: ∀ {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y), (F.mapTriangle.map f).hom₃ = F.map f.hom₃

full_name: CategoryTheory.Functor.mapTriangle
code: /-- The functor `Triangle C ⥤ Triangle D` that is induced by a functor `F : C ⥤ D`
which commutes with shift by `ℤ`. -/
@[simps]
def mapTriangle : Triangle C ⥤ Triangle D 
goal: CategoryTheory.Functor (CategoryTheory.Pretriangulated.Triangle C) (CategoryTheory.Pretriangulated.Triangle D)

full_name: CategoryTheory.Functor.instFaithfulTriangleMapTriangle
code: instance [Faithful F] : Faithful F.mapTriangle 
goal: F.mapTriangle.Faithful

full_name: CategoryTheory.Functor.instFullTriangleMapTriangleOfFaithful
code: instance [Full F] [Faithful F] : Full F.mapTriangle 
goal: F.mapTriangle.Full

full_name: CategoryTheory.Functor.mapTriangleCommShiftIso_hom_app_hom₃
code: /-- The functor `F.mapTriangle` commutes with the shift. -/
@[simps!]
noncomputable def mapTriangleCommShiftIso (n : ℤ) :
    Triangle.shiftFunctor C n ⋙ F.mapTriangle ≅ F.mapTriangle ⋙ Triangle.shiftFunctor D n 
goal: ((F.mapTriangleCommShiftIso n).hom.app X).hom₃ = (F.commShiftIso n).hom.app X.obj₃

full_name: CategoryTheory.Functor.mapTriangleCommShiftIso
code: /-- The functor `F.mapTriangle` commutes with the shift. -/
@[simps!]
noncomputable def mapTriangleCommShiftIso (n : ℤ) :
    Triangle.shiftFunctor C n ⋙ F.mapTriangle ≅ F.mapTriangle ⋙ Triangle.shiftFunctor D n 
goal: (CategoryTheory.Pretriangulated.Triangle.shiftFunctor C n).comp F.mapTriangle ≅
  F.mapTriangle.comp (CategoryTheory.Pretriangulated.Triangle.shiftFunctor D n)

full_name: CategoryTheory.Functor.mapTriangleCommShiftIso_inv_app_hom₁
code: /-- The functor `F.mapTriangle` commutes with the shift. -/
@[simps!]
noncomputable def mapTriangleCommShiftIso (n : ℤ) :
    Triangle.shiftFunctor C n ⋙ F.mapTriangle ≅ F.mapTriangle ⋙ Triangle.shiftFunctor D n 
goal: ((F.mapTriangleCommShiftIso n).inv.app X).hom₁ = (F.commShiftIso n).inv.app X.obj₁

full_name: CategoryTheory.Functor.mapTriangleCommShiftIso_hom_app_hom₁
code: /-- The functor `F.mapTriangle` commutes with the shift. -/
@[simps!]
noncomputable def mapTriangleCommShiftIso (n : ℤ) :
    Triangle.shiftFunctor C n ⋙ F.mapTriangle ≅ F.mapTriangle ⋙ Triangle.shiftFunctor D n 
goal: ((F.mapTriangleCommShiftIso n).hom.app X).hom₁ = (F.commShiftIso n).hom.app X.obj₁

full_name: CategoryTheory.Functor.mapTriangleCommShiftIso_hom_app_hom₂
code: /-- The functor `F.mapTriangle` commutes with the shift. -/
@[simps!]
noncomputable def mapTriangleCommShiftIso (n : ℤ) :
    Triangle.shiftFunctor C n ⋙ F.mapTriangle ≅ F.mapTriangle ⋙ Triangle.shiftFunctor D n 
goal: ((F.mapTriangleCommShiftIso n).hom.app X).hom₂ = (F.commShiftIso n).hom.app X.obj₂

full_name: CategoryTheory.Functor.mapTriangleCommShiftIso_inv_app_hom₃
code: /-- The functor `F.mapTriangle` commutes with the shift. -/
@[simps!]
noncomputable def mapTriangleCommShiftIso (n : ℤ) :
    Triangle.shiftFunctor C n ⋙ F.mapTriangle ≅ F.mapTriangle ⋙ Triangle.shiftFunctor D n 
goal: ((F.mapTriangleCommShiftIso n).inv.app X).hom₃ = (F.commShiftIso n).inv.app X.obj₃

full_name: CategoryTheory.Functor.mapTriangleCommShiftIso_inv_app_hom₂
code: /-- The functor `F.mapTriangle` commutes with the shift. -/
@[simps!]
noncomputable def mapTriangleCommShiftIso (n : ℤ) :
    Triangle.shiftFunctor C n ⋙ F.mapTriangle ≅ F.mapTriangle ⋙ Triangle.shiftFunctor D n 
goal: ((F.mapTriangleCommShiftIso n).inv.app X).hom₂ = (F.commShiftIso n).inv.app X.obj₂

full_name: CategoryTheory.Functor.instCommShiftTriangleMapTriangleInt
code: noncomputable instance [∀ (n : ℤ), (shiftFunctor C n).Additive]
    [∀ (n : ℤ), (shiftFunctor D n).Additive] : (F.mapTriangle).CommShift ℤ 
goal: F.mapTriangle.CommShift ℤ

full_name: CategoryTheory.Functor.mapTriangleRotateIso_hom_app_hom₂
code: /-- `F.mapTriangle` commutes with the rotation of triangles. -/
@[simps!]
def mapTriangleRotateIso :
    F.mapTriangle ⋙ Pretriangulated.rotate D ≅
      Pretriangulated.rotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleRotateIso.hom.app X).hom₂ = CategoryTheory.CategoryStruct.id (F.obj X.obj₃)

full_name: CategoryTheory.Functor.mapTriangleRotateIso
code: /-- `F.mapTriangle` commutes with the rotation of triangles. -/
@[simps!]
def mapTriangleRotateIso :
    F.mapTriangle ⋙ Pretriangulated.rotate D ≅
      Pretriangulated.rotate C ⋙ F.mapTriangle 
goal: F.mapTriangle.comp (CategoryTheory.Pretriangulated.rotate D) ≅
  (CategoryTheory.Pretriangulated.rotate C).comp F.mapTriangle

full_name: CategoryTheory.Functor.mapTriangleRotateIso_inv_app_hom₃
code: /-- `F.mapTriangle` commutes with the rotation of triangles. -/
@[simps!]
def mapTriangleRotateIso :
    F.mapTriangle ⋙ Pretriangulated.rotate D ≅
      Pretriangulated.rotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleRotateIso.inv.app X).hom₃ = (F.commShiftIso 1).hom.app X.obj₁

full_name: CategoryTheory.Functor.mapTriangleRotateIso_hom_app_hom₃
code: /-- `F.mapTriangle` commutes with the rotation of triangles. -/
@[simps!]
def mapTriangleRotateIso :
    F.mapTriangle ⋙ Pretriangulated.rotate D ≅
      Pretriangulated.rotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleRotateIso.hom.app X).hom₃ = (F.commShiftIso 1).inv.app X.obj₁

full_name: CategoryTheory.Functor.mapTriangleRotateIso_inv_app_hom₁
code: /-- `F.mapTriangle` commutes with the rotation of triangles. -/
@[simps!]
def mapTriangleRotateIso :
    F.mapTriangle ⋙ Pretriangulated.rotate D ≅
      Pretriangulated.rotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleRotateIso.inv.app X).hom₁ = CategoryTheory.CategoryStruct.id (F.obj X.obj₂)

full_name: CategoryTheory.Functor.mapTriangleRotateIso_inv_app_hom₂
code: /-- `F.mapTriangle` commutes with the rotation of triangles. -/
@[simps!]
def mapTriangleRotateIso :
    F.mapTriangle ⋙ Pretriangulated.rotate D ≅
      Pretriangulated.rotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleRotateIso.inv.app X).hom₂ = CategoryTheory.CategoryStruct.id (F.obj X.obj₃)

full_name: CategoryTheory.Functor.mapTriangleRotateIso_hom_app_hom₁
code: /-- `F.mapTriangle` commutes with the rotation of triangles. -/
@[simps!]
def mapTriangleRotateIso :
    F.mapTriangle ⋙ Pretriangulated.rotate D ≅
      Pretriangulated.rotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleRotateIso.hom.app X).hom₁ = CategoryTheory.CategoryStruct.id (F.obj X.obj₂)

full_name: CategoryTheory.Functor.mapTriangleInvRotateIso_hom_app_hom₁
code: /-- `F.mapTriangle` commutes with the inverse of the rotation of triangles. -/
@[simps!]
noncomputable def mapTriangleInvRotateIso [F.Additive] :
    F.mapTriangle ⋙ Pretriangulated.invRotate D ≅
      Pretriangulated.invRotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleInvRotateIso.hom.app X).hom₁ = (F.commShiftIso (-1)).inv.app X.obj₃

full_name: CategoryTheory.Functor.mapTriangleInvRotateIso_inv_app_hom₃
code: /-- `F.mapTriangle` commutes with the inverse of the rotation of triangles. -/
@[simps!]
noncomputable def mapTriangleInvRotateIso [F.Additive] :
    F.mapTriangle ⋙ Pretriangulated.invRotate D ≅
      Pretriangulated.invRotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleInvRotateIso.inv.app X).hom₃ = CategoryTheory.CategoryStruct.id (F.obj X.obj₂)

full_name: CategoryTheory.Functor.mapTriangleInvRotateIso_hom_app_hom₂
code: /-- `F.mapTriangle` commutes with the inverse of the rotation of triangles. -/
@[simps!]
noncomputable def mapTriangleInvRotateIso [F.Additive] :
    F.mapTriangle ⋙ Pretriangulated.invRotate D ≅
      Pretriangulated.invRotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleInvRotateIso.hom.app X).hom₂ = CategoryTheory.CategoryStruct.id (F.obj X.obj₁)

full_name: CategoryTheory.Functor.mapTriangleInvRotateIso
code: /-- `F.mapTriangle` commutes with the inverse of the rotation of triangles. -/
@[simps!]
noncomputable def mapTriangleInvRotateIso [F.Additive] :
    F.mapTriangle ⋙ Pretriangulated.invRotate D ≅
      Pretriangulated.invRotate C ⋙ F.mapTriangle 
goal: F.mapTriangle.comp (CategoryTheory.Pretriangulated.invRotate D) ≅
  (CategoryTheory.Pretriangulated.invRotate C).comp F.mapTriangle

full_name: CategoryTheory.Functor.mapTriangleInvRotateIso_inv_app_hom₂
code: /-- `F.mapTriangle` commutes with the inverse of the rotation of triangles. -/
@[simps!]
noncomputable def mapTriangleInvRotateIso [F.Additive] :
    F.mapTriangle ⋙ Pretriangulated.invRotate D ≅
      Pretriangulated.invRotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleInvRotateIso.inv.app X).hom₂ = CategoryTheory.CategoryStruct.id (F.obj X.obj₁)

full_name: CategoryTheory.Functor.mapTriangleInvRotateIso_hom_app_hom₃
code: /-- `F.mapTriangle` commutes with the inverse of the rotation of triangles. -/
@[simps!]
noncomputable def mapTriangleInvRotateIso [F.Additive] :
    F.mapTriangle ⋙ Pretriangulated.invRotate D ≅
      Pretriangulated.invRotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleInvRotateIso.hom.app X).hom₃ = CategoryTheory.CategoryStruct.id (F.obj X.obj₂)

full_name: CategoryTheory.Functor.mapTriangleInvRotateIso_inv_app_hom₁
code: /-- `F.mapTriangle` commutes with the inverse of the rotation of triangles. -/
@[simps!]
noncomputable def mapTriangleInvRotateIso [F.Additive] :
    F.mapTriangle ⋙ Pretriangulated.invRotate D ≅
      Pretriangulated.invRotate C ⋙ F.mapTriangle 
goal: (F.mapTriangleInvRotateIso.inv.app X).hom₁ = (F.commShiftIso (-1)).hom.app X.obj₃

full_name: CategoryTheory.Functor.mapTriangleIdIso
code: /-- The canonical isomorphism `(𝟭 C).mapTriangle ≅ 𝟭 (Triangle C)`. -/
@[simps!]
def mapTriangleIdIso : (𝟭 C).mapTriangle ≅ 𝟭 _ 
goal: (CategoryTheory.Functor.id C).mapTriangle ≅ CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C)

full_name: CategoryTheory.Functor.mapTriangleIdIso_hom_app_hom₂
code: /-- The canonical isomorphism `(𝟭 C).mapTriangle ≅ 𝟭 (Triangle C)`. -/
@[simps!]
def mapTriangleIdIso : (𝟭 C).mapTriangle ≅ 𝟭 _ 
goal: ((CategoryTheory.Functor.mapTriangleIdIso C).hom.app X).hom₂ = CategoryTheory.CategoryStruct.id X.obj₂

full_name: CategoryTheory.Functor.mapTriangleIdIso_inv_app_hom₁
code: /-- The canonical isomorphism `(𝟭 C).mapTriangle ≅ 𝟭 (Triangle C)`. -/
@[simps!]
def mapTriangleIdIso : (𝟭 C).mapTriangle ≅ 𝟭 _ 
goal: ((CategoryTheory.Functor.mapTriangleIdIso C).inv.app X).hom₁ = CategoryTheory.CategoryStruct.id X.obj₁

full_name: CategoryTheory.Functor.mapTriangleIdIso_inv_app_hom₂
code: /-- The canonical isomorphism `(𝟭 C).mapTriangle ≅ 𝟭 (Triangle C)`. -/
@[simps!]
def mapTriangleIdIso : (𝟭 C).mapTriangle ≅ 𝟭 _ 
goal: ((CategoryTheory.Functor.mapTriangleIdIso C).inv.app X).hom₂ = CategoryTheory.CategoryStruct.id X.obj₂

full_name: CategoryTheory.Functor.mapTriangleIdIso_inv_app_hom₃
code: /-- The canonical isomorphism `(𝟭 C).mapTriangle ≅ 𝟭 (Triangle C)`. -/
@[simps!]
def mapTriangleIdIso : (𝟭 C).mapTriangle ≅ 𝟭 _ 
goal: ((CategoryTheory.Functor.mapTriangleIdIso C).inv.app X).hom₃ = CategoryTheory.CategoryStruct.id X.obj₃

full_name: CategoryTheory.Functor.mapTriangleIdIso_hom_app_hom₃
code: /-- The canonical isomorphism `(𝟭 C).mapTriangle ≅ 𝟭 (Triangle C)`. -/
@[simps!]
def mapTriangleIdIso : (𝟭 C).mapTriangle ≅ 𝟭 _ 
goal: ((CategoryTheory.Functor.mapTriangleIdIso C).hom.app X).hom₃ = CategoryTheory.CategoryStruct.id X.obj₃

full_name: CategoryTheory.Functor.mapTriangleIdIso_hom_app_hom₁
code: /-- The canonical isomorphism `(𝟭 C).mapTriangle ≅ 𝟭 (Triangle C)`. -/
@[simps!]
def mapTriangleIdIso : (𝟭 C).mapTriangle ≅ 𝟭 _ 
goal: ((CategoryTheory.Functor.mapTriangleIdIso C).hom.app X).hom₁ = CategoryTheory.CategoryStruct.id X.obj₁

full_name: CategoryTheory.Functor.mapTriangleCompIso_hom_app_hom₁
code: /-- The canonical isomorphism `(F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle`. -/
@[simps!]
def mapTriangleCompIso : (F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle 
goal: ((F.mapTriangleCompIso G).hom.app X).hom₁ = CategoryTheory.CategoryStruct.id (G.obj (F.obj X.obj₁))

full_name: CategoryTheory.Functor.mapTriangleCompIso_hom_app_hom₂
code: /-- The canonical isomorphism `(F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle`. -/
@[simps!]
def mapTriangleCompIso : (F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle 
goal: ((F.mapTriangleCompIso G).hom.app X).hom₂ = CategoryTheory.CategoryStruct.id (G.obj (F.obj X.obj₂))

full_name: CategoryTheory.Functor.mapTriangleCompIso_hom_app_hom₃
code: /-- The canonical isomorphism `(F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle`. -/
@[simps!]
def mapTriangleCompIso : (F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle 
goal: ((F.mapTriangleCompIso G).hom.app X).hom₃ = CategoryTheory.CategoryStruct.id (G.obj (F.obj X.obj₃))

full_name: CategoryTheory.Functor.mapTriangleCompIso_inv_app_hom₃
code: /-- The canonical isomorphism `(F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle`. -/
@[simps!]
def mapTriangleCompIso : (F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle 
goal: ((F.mapTriangleCompIso G).inv.app X).hom₃ = CategoryTheory.CategoryStruct.id (G.obj (F.obj X.obj₃))

full_name: CategoryTheory.Functor.mapTriangleCompIso_inv_app_hom₂
code: /-- The canonical isomorphism `(F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle`. -/
@[simps!]
def mapTriangleCompIso : (F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle 
goal: ((F.mapTriangleCompIso G).inv.app X).hom₂ = CategoryTheory.CategoryStruct.id (G.obj (F.obj X.obj₂))

full_name: CategoryTheory.Functor.mapTriangleCompIso_inv_app_hom₁
code: /-- The canonical isomorphism `(F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle`. -/
@[simps!]
def mapTriangleCompIso : (F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle 
goal: ((F.mapTriangleCompIso G).inv.app X).hom₁ = CategoryTheory.CategoryStruct.id (G.obj (F.obj X.obj₁))

full_name: CategoryTheory.Functor.mapTriangleCompIso
code: /-- The canonical isomorphism `(F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle`. -/
@[simps!]
def mapTriangleCompIso : (F ⋙ G).mapTriangle ≅ F.mapTriangle ⋙ G.mapTriangle 
goal: (F.comp G).mapTriangle ≅ F.mapTriangle.comp G.mapTriangle

full_name: CategoryTheory.Functor.mapTriangleIso_hom_app_hom₂
code: /-- Two isomorphic functors `F₁` and `F₂` induce isomorphic functors
`F₁.mapTriangle` and `F₂.mapTriangle` if the isomorphism `F₁ ≅ F₂` is compatible
with the shifts. -/
@[simps!]
def mapTriangleIso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) [F₁.CommShift ℤ] [F₂.CommShift ℤ]
    [NatTrans.CommShift e.hom ℤ] : F₁.mapTriangle ≅ F₂.mapTriangle 
goal: ((CategoryTheory.Functor.mapTriangleIso e).hom.app X).hom₂ = e.hom.app X.obj₂

full_name: CategoryTheory.Functor.mapTriangleIso_inv_app_hom₁
code: /-- Two isomorphic functors `F₁` and `F₂` induce isomorphic functors
`F₁.mapTriangle` and `F₂.mapTriangle` if the isomorphism `F₁ ≅ F₂` is compatible
with the shifts. -/
@[simps!]
def mapTriangleIso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) [F₁.CommShift ℤ] [F₂.CommShift ℤ]
    [NatTrans.CommShift e.hom ℤ] : F₁.mapTriangle ≅ F₂.mapTriangle 
goal: ((CategoryTheory.Functor.mapTriangleIso e).inv.app X).hom₁ = e.inv.app X.obj₁

full_name: CategoryTheory.Functor.mapTriangleIso_inv_app_hom₂
code: /-- Two isomorphic functors `F₁` and `F₂` induce isomorphic functors
`F₁.mapTriangle` and `F₂.mapTriangle` if the isomorphism `F₁ ≅ F₂` is compatible
with the shifts. -/
@[simps!]
def mapTriangleIso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) [F₁.CommShift ℤ] [F₂.CommShift ℤ]
    [NatTrans.CommShift e.hom ℤ] : F₁.mapTriangle ≅ F₂.mapTriangle 
goal: ((CategoryTheory.Functor.mapTriangleIso e).inv.app X).hom₂ = e.inv.app X.obj₂

full_name: CategoryTheory.Functor.mapTriangleIso_inv_app_hom₃
code: /-- Two isomorphic functors `F₁` and `F₂` induce isomorphic functors
`F₁.mapTriangle` and `F₂.mapTriangle` if the isomorphism `F₁ ≅ F₂` is compatible
with the shifts. -/
@[simps!]
def mapTriangleIso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) [F₁.CommShift ℤ] [F₂.CommShift ℤ]
    [NatTrans.CommShift e.hom ℤ] : F₁.mapTriangle ≅ F₂.mapTriangle 
goal: ((CategoryTheory.Functor.mapTriangleIso e).inv.app X).hom₃ = e.inv.app X.obj₃

full_name: CategoryTheory.Functor.mapTriangleIso_hom_app_hom₃
code: /-- Two isomorphic functors `F₁` and `F₂` induce isomorphic functors
`F₁.mapTriangle` and `F₂.mapTriangle` if the isomorphism `F₁ ≅ F₂` is compatible
with the shifts. -/
@[simps!]
def mapTriangleIso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) [F₁.CommShift ℤ] [F₂.CommShift ℤ]
    [NatTrans.CommShift e.hom ℤ] : F₁.mapTriangle ≅ F₂.mapTriangle 
goal: ((CategoryTheory.Functor.mapTriangleIso e).hom.app X).hom₃ = e.hom.app X.obj₃

full_name: CategoryTheory.Functor.mapTriangleIso_hom_app_hom₁
code: /-- Two isomorphic functors `F₁` and `F₂` induce isomorphic functors
`F₁.mapTriangle` and `F₂.mapTriangle` if the isomorphism `F₁ ≅ F₂` is compatible
with the shifts. -/
@[simps!]
def mapTriangleIso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) [F₁.CommShift ℤ] [F₂.CommShift ℤ]
    [NatTrans.CommShift e.hom ℤ] : F₁.mapTriangle ≅ F₂.mapTriangle 
goal: ((CategoryTheory.Functor.mapTriangleIso e).hom.app X).hom₁ = e.hom.app X.obj₁

full_name: CategoryTheory.Functor.mapTriangleIso
code: /-- Two isomorphic functors `F₁` and `F₂` induce isomorphic functors
`F₁.mapTriangle` and `F₂.mapTriangle` if the isomorphism `F₁ ≅ F₂` is compatible
with the shifts. -/
@[simps!]
def mapTriangleIso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) [F₁.CommShift ℤ] [F₂.CommShift ℤ]
    [NatTrans.CommShift e.hom ℤ] : F₁.mapTriangle ≅ F₂.mapTriangle 
goal: F₁.mapTriangle ≅ F₂.mapTriangle

full_name: CategoryTheory.Functor.IsTriangulated.map_distinguished
code: /-- A functor which commutes with the shift by `ℤ` is triangulated if
it sends distinguished triangles to distinguished triangles. -/
class IsTriangulated : Prop where
  map_distinguished (T : Triangle C) : (T ∈ distTriang C) → F.mapTriangle.obj T ∈ distTriang D
goal: T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles →
  F.mapTriangle.obj T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles

full_name: CategoryTheory.Functor.IsTriangulated
code: /-- A functor which commutes with the shift by `ℤ` is triangulated if
it sends distinguished triangles to distinguished triangles. -/
class IsTriangulated : Prop where
  map_distinguished (T : Triangle C) : (T ∈ distTriang C) → F.mapTriangle.obj T ∈ distTriang D
goal: Prop

full_name: CategoryTheory.Functor.map_distinguished
code: lemma map_distinguished [F.IsTriangulated] (T : Triangle C) (hT : T ∈ distTriang C) :
    F.mapTriangle.obj T ∈ distTriang D 
goal: F.mapTriangle.obj T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles

full_name: CategoryTheory.Functor.IsTriangulated.instPreservesZeroMorphisms
code: instance (priority := 100) [F.IsTriangulated] : PreservesZeroMorphisms F 
goal: F.PreservesZeroMorphisms

full_name: CategoryTheory.Functor.IsTriangulated.instPreservesLimitsOfShapeDiscreteWalkingPair
code: noncomputable instance [F.IsTriangulated] :
    PreservesLimitsOfShape (Discrete WalkingPair) F 
goal: CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F

full_name: CategoryTheory.Functor.IsTriangulated.instAdditive
code: instance (priority := 100) [F.IsTriangulated] : F.Additive 
goal: F.Additive

full_name: CategoryTheory.Functor.IsTriangulated.instId
code: instance : (𝟭 C).IsTriangulated 
goal: (CategoryTheory.Functor.id C).IsTriangulated

full_name: CategoryTheory.Functor.IsTriangulated.instComp
code: instance [F.IsTriangulated] [G.IsTriangulated] : (F ⋙ G).IsTriangulated 
goal: (F.comp G).IsTriangulated

full_name: CategoryTheory.Functor.isTriangulated_of_iso
code: lemma isTriangulated_of_iso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) [F₁.CommShift ℤ] [F₂.CommShift ℤ]
    [NatTrans.CommShift e.hom ℤ] [F₁.IsTriangulated] : F₂.IsTriangulated 
goal: F₂.IsTriangulated

full_name: CategoryTheory.Functor.isTriangulated_iff_of_iso
code: lemma isTriangulated_iff_of_iso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂) [F₁.CommShift ℤ] [F₂.CommShift ℤ]
    [NatTrans.CommShift e.hom ℤ] : F₁.IsTriangulated ↔ F₂.IsTriangulated 
goal: F₁.IsTriangulated ↔ F₂.IsTriangulated

full_name: CategoryTheory.Functor.mem_mapTriangle_essImage_of_distinguished
code: lemma mem_mapTriangle_essImage_of_distinguished
    [F.IsTriangulated] [F.mapArrow.EssSurj] (T : Triangle D) (hT : T ∈ distTriang D) :
    ∃ (T' : Triangle C) (_ : T' ∈ distTriang C), Nonempty (F.mapTriangle.obj T' ≅ T) 
goal: ∃ T', ∃ (_ : T' ∈ CategoryTheory.Pretriangulated.distinguishedTriangles), Nonempty (F.mapTriangle.obj T' ≅ T)

full_name: CategoryTheory.Functor.isTriangulated_of_precomp
code: lemma isTriangulated_of_precomp
    [(F ⋙ G).IsTriangulated] [F.IsTriangulated] [F.mapArrow.EssSurj] :
    G.IsTriangulated 
goal: G.IsTriangulated

full_name: CategoryTheory.Functor.isTriangulated_of_precomp_iso
code: lemma isTriangulated_of_precomp_iso {H : C ⥤ E} (e : F ⋙ G ≅ H) [H.CommShift ℤ]
    [H.IsTriangulated] [F.IsTriangulated] [F.mapArrow.EssSurj] [NatTrans.CommShift e.hom ℤ] :
    G.IsTriangulated 
goal: G.IsTriangulated

full_name: CategoryTheory.Triangulated.Octahedron.map_m₃
code: /-- The image of an octahedron by a triangulated functor. -/
@[simps]
def map : Octahedron (by dsimp; rw [← F.map_comp, comm])
    (F.map_distinguished _ h₁₂) (F.map_distinguished _ h₂₃) (F.map_distinguished _ h₁₃) 
goal: (h.map F).m₃ = F.map h.m₃

full_name: CategoryTheory.Triangulated.Octahedron.map_m₁
code: /-- The image of an octahedron by a triangulated functor. -/
@[simps]
def map : Octahedron (by dsimp; rw [← F.map_comp, comm])
    (F.map_distinguished _ h₁₂) (F.map_distinguished _ h₂₃) (F.map_distinguished _ h₁₃) 
goal: (h.map F).m₁ = F.map h.m₁

full_name: CategoryTheory.Triangulated.Octahedron.map
code: /-- The image of an octahedron by a triangulated functor. -/
@[simps]
def map : Octahedron (by dsimp; rw [← F.map_comp, comm])
    (F.map_distinguished _ h₁₂) (F.map_distinguished _ h₂₃) (F.map_distinguished _ h₁₃) 
goal: CategoryTheory.Triangulated.Octahedron ⋯ ⋯ ⋯ ⋯

full_name: CategoryTheory.isTriangulated_of_essSurj_mapComposableArrows_two
code: /-- If `F : C ⥤ D` is a triangulated functor from a triangulated category, then `D`
is also triangulated if tuples of composables arrows in `D` can be lifted to `C`. -/
lemma isTriangulated_of_essSurj_mapComposableArrows_two
    (F : C ⥤ D) [F.CommShift ℤ] [F.IsTriangulated]
    [(F.mapComposableArrows 2).EssSurj] [IsTriangulated C] :
    IsTriangulated D 
goal: CategoryTheory.IsTriangulated D