File: Mathlib/CategoryTheory/Triangulated/Rotate.lean

full_name: CategoryTheory.Pretriangulated.Triangle.rotate_obj₃
code: /-- If you rotate a triangle, you get another triangle.
Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `rotate` gives a triangle of the form:
```
      g       h        -f⟦1⟧'
  Y  ───> Z  ───>  X⟦1⟧ ───> Y⟦1⟧
```
-/
@[simps!]
def Triangle.rotate (T : Triangle C) : Triangle C 
goal: T.rotate.obj₃ = (CategoryTheory.shiftFunctor C 1).obj T.obj₁

full_name: CategoryTheory.Pretriangulated.Triangle.rotate_mor₁
code: /-- If you rotate a triangle, you get another triangle.
Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `rotate` gives a triangle of the form:
```
      g       h        -f⟦1⟧'
  Y  ───> Z  ───>  X⟦1⟧ ───> Y⟦1⟧
```
-/
@[simps!]
def Triangle.rotate (T : Triangle C) : Triangle C 
goal: T.rotate.mor₁ = T.mor₂

full_name: CategoryTheory.Pretriangulated.Triangle.rotate_mor₂
code: /-- If you rotate a triangle, you get another triangle.
Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `rotate` gives a triangle of the form:
```
      g       h        -f⟦1⟧'
  Y  ───> Z  ───>  X⟦1⟧ ───> Y⟦1⟧
```
-/
@[simps!]
def Triangle.rotate (T : Triangle C) : Triangle C 
goal: T.rotate.mor₂ = T.mor₃

full_name: CategoryTheory.Pretriangulated.Triangle.rotate_mor₃
code: /-- If you rotate a triangle, you get another triangle.
Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `rotate` gives a triangle of the form:
```
      g       h        -f⟦1⟧'
  Y  ───> Z  ───>  X⟦1⟧ ───> Y⟦1⟧
```
-/
@[simps!]
def Triangle.rotate (T : Triangle C) : Triangle C 
goal: T.rotate.mor₃ = -(CategoryTheory.shiftFunctor C 1).map T.mor₁

full_name: CategoryTheory.Pretriangulated.Triangle.rotate_obj₁
code: /-- If you rotate a triangle, you get another triangle.
Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `rotate` gives a triangle of the form:
```
      g       h        -f⟦1⟧'
  Y  ───> Z  ───>  X⟦1⟧ ───> Y⟦1⟧
```
-/
@[simps!]
def Triangle.rotate (T : Triangle C) : Triangle C 
goal: T.rotate.obj₁ = T.obj₂

full_name: CategoryTheory.Pretriangulated.Triangle.rotate
code: /-- If you rotate a triangle, you get another triangle.
Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `rotate` gives a triangle of the form:
```
      g       h        -f⟦1⟧'
  Y  ───> Z  ───>  X⟦1⟧ ───> Y⟦1⟧
```
-/
@[simps!]
def Triangle.rotate (T : Triangle C) : Triangle C 
goal: CategoryTheory.Pretriangulated.Triangle C

full_name: CategoryTheory.Pretriangulated.Triangle.rotate_obj₂
code: /-- If you rotate a triangle, you get another triangle.
Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `rotate` gives a triangle of the form:
```
      g       h        -f⟦1⟧'
  Y  ───> Z  ───>  X⟦1⟧ ───> Y⟦1⟧
```
-/
@[simps!]
def Triangle.rotate (T : Triangle C) : Triangle C 
goal: T.rotate.obj₂ = T.obj₃

full_name: CategoryTheory.Pretriangulated.Triangle.invRotate_mor₂
code: /-- Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `invRotate` gives a triangle that can be thought of as:
```
        -h⟦-1⟧'     f       g
  Z⟦-1⟧  ───>  X  ───> Y  ───> Z
```
(note that this diagram doesn't technically fit the definition of triangle, as `Z⟦-1⟧⟦1⟧` is
not necessarily equal to `Z`, but it is isomorphic, by the `counitIso` of `shiftEquiv C 1`)
-/
@[simps!]
def Triangle.invRotate (T : Triangle C) : Triangle C 
goal: T.invRotate.mor₂ = T.mor₁

full_name: CategoryTheory.Pretriangulated.Triangle.invRotate_mor₃
code: /-- Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `invRotate` gives a triangle that can be thought of as:
```
        -h⟦-1⟧'     f       g
  Z⟦-1⟧  ───>  X  ───> Y  ───> Z
```
(note that this diagram doesn't technically fit the definition of triangle, as `Z⟦-1⟧⟦1⟧` is
not necessarily equal to `Z`, but it is isomorphic, by the `counitIso` of `shiftEquiv C 1`)
-/
@[simps!]
def Triangle.invRotate (T : Triangle C) : Triangle C 
goal: T.invRotate.mor₃ = T.mor₂ ≫ (CategoryTheory.shiftFunctorCompIsoId C (-1) 1 ⋯).inv.app T.3

full_name: CategoryTheory.Pretriangulated.Triangle.invRotate_obj₁
code: /-- Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `invRotate` gives a triangle that can be thought of as:
```
        -h⟦-1⟧'     f       g
  Z⟦-1⟧  ───>  X  ───> Y  ───> Z
```
(note that this diagram doesn't technically fit the definition of triangle, as `Z⟦-1⟧⟦1⟧` is
not necessarily equal to `Z`, but it is isomorphic, by the `counitIso` of `shiftEquiv C 1`)
-/
@[simps!]
def Triangle.invRotate (T : Triangle C) : Triangle C 
goal: T.invRotate.obj₁ = (CategoryTheory.shiftFunctor C (-1)).obj T.obj₃

full_name: CategoryTheory.Pretriangulated.Triangle.invRotate_obj₂
code: /-- Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `invRotate` gives a triangle that can be thought of as:
```
        -h⟦-1⟧'     f       g
  Z⟦-1⟧  ───>  X  ───> Y  ───> Z
```
(note that this diagram doesn't technically fit the definition of triangle, as `Z⟦-1⟧⟦1⟧` is
not necessarily equal to `Z`, but it is isomorphic, by the `counitIso` of `shiftEquiv C 1`)
-/
@[simps!]
def Triangle.invRotate (T : Triangle C) : Triangle C 
goal: T.invRotate.obj₂ = T.obj₁

full_name: CategoryTheory.Pretriangulated.Triangle.invRotate_obj₃
code: /-- Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `invRotate` gives a triangle that can be thought of as:
```
        -h⟦-1⟧'     f       g
  Z⟦-1⟧  ───>  X  ───> Y  ───> Z
```
(note that this diagram doesn't technically fit the definition of triangle, as `Z⟦-1⟧⟦1⟧` is
not necessarily equal to `Z`, but it is isomorphic, by the `counitIso` of `shiftEquiv C 1`)
-/
@[simps!]
def Triangle.invRotate (T : Triangle C) : Triangle C 
goal: T.invRotate.obj₃ = T.obj₂

full_name: CategoryTheory.Pretriangulated.Triangle.invRotate
code: /-- Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `invRotate` gives a triangle that can be thought of as:
```
        -h⟦-1⟧'     f       g
  Z⟦-1⟧  ───>  X  ───> Y  ───> Z
```
(note that this diagram doesn't technically fit the definition of triangle, as `Z⟦-1⟧⟦1⟧` is
not necessarily equal to `Z`, but it is isomorphic, by the `counitIso` of `shiftEquiv C 1`)
-/
@[simps!]
def Triangle.invRotate (T : Triangle C) : Triangle C 
goal: CategoryTheory.Pretriangulated.Triangle C

full_name: CategoryTheory.Pretriangulated.Triangle.invRotate_mor₁
code: /-- Given a triangle of the form:
```
      f       g       h
  X  ───> Y  ───> Z  ───> X⟦1⟧
```
applying `invRotate` gives a triangle that can be thought of as:
```
        -h⟦-1⟧'     f       g
  Z⟦-1⟧  ───>  X  ───> Y  ───> Z
```
(note that this diagram doesn't technically fit the definition of triangle, as `Z⟦-1⟧⟦1⟧` is
not necessarily equal to `Z`, but it is isomorphic, by the `counitIso` of `shiftEquiv C 1`)
-/
@[simps!]
def Triangle.invRotate (T : Triangle C) : Triangle C 
goal: T.invRotate.mor₁ =
  -(CategoryTheory.shiftFunctor C (-1)).map T.mor₃ ≫ (CategoryTheory.shiftFunctorCompIsoId C 1 (-1) ⋯).hom.app T.obj₁

full_name: CategoryTheory.Pretriangulated.rotate
code: /-- Rotating triangles gives an endofunctor on the category of triangles in `C`.
-/
@[simps]
def rotate : Triangle C ⥤ Triangle C 
goal: CategoryTheory.Pretriangulated.Triangle C ⥤ CategoryTheory.Pretriangulated.Triangle C

full_name: CategoryTheory.Pretriangulated.rotate_map_hom₁
code: /-- Rotating triangles gives an endofunctor on the category of triangles in `C`.
-/
@[simps]
def rotate : Triangle C ⥤ Triangle C 
goal: ∀ {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y),
  ((CategoryTheory.Pretriangulated.rotate C).map f).hom₁ = f.hom₂

full_name: CategoryTheory.Pretriangulated.rotate_obj
code: /-- Rotating triangles gives an endofunctor on the category of triangles in `C`.
-/
@[simps]
def rotate : Triangle C ⥤ Triangle C 
goal: (CategoryTheory.Pretriangulated.rotate C).obj T = T.rotate

full_name: CategoryTheory.Pretriangulated.rotate_map_hom₂
code: /-- Rotating triangles gives an endofunctor on the category of triangles in `C`.
-/
@[simps]
def rotate : Triangle C ⥤ Triangle C 
goal: ∀ {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y),
  ((CategoryTheory.Pretriangulated.rotate C).map f).hom₂ = f.hom₃

full_name: CategoryTheory.Pretriangulated.rotate_map_hom₃
code: /-- Rotating triangles gives an endofunctor on the category of triangles in `C`.
-/
@[simps]
def rotate : Triangle C ⥤ Triangle C 
goal: ∀ {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y),
  ((CategoryTheory.Pretriangulated.rotate C).map f).hom₃ = (CategoryTheory.shiftFunctor C 1).map f.hom₁

full_name: CategoryTheory.Pretriangulated.invRotate
code: /-- The inverse rotation of triangles gives an endofunctor on the category of triangles in `C`.
-/
@[simps]
def invRotate : Triangle C ⥤ Triangle C 
goal: CategoryTheory.Pretriangulated.Triangle C ⥤ CategoryTheory.Pretriangulated.Triangle C

full_name: CategoryTheory.Pretriangulated.invRotate_obj
code: /-- The inverse rotation of triangles gives an endofunctor on the category of triangles in `C`.
-/
@[simps]
def invRotate : Triangle C ⥤ Triangle C 
goal: (CategoryTheory.Pretriangulated.invRotate C).obj T = T.invRotate

full_name: CategoryTheory.Pretriangulated.invRotate_map_hom₁
code: /-- The inverse rotation of triangles gives an endofunctor on the category of triangles in `C`.
-/
@[simps]
def invRotate : Triangle C ⥤ Triangle C 
goal: ∀ {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y),
  ((CategoryTheory.Pretriangulated.invRotate C).map f).hom₁ = (CategoryTheory.shiftFunctor C (-1)).map f.hom₃

full_name: CategoryTheory.Pretriangulated.invRotate_map_hom₃
code: /-- The inverse rotation of triangles gives an endofunctor on the category of triangles in `C`.
-/
@[simps]
def invRotate : Triangle C ⥤ Triangle C 
goal: ∀ {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y),
  ((CategoryTheory.Pretriangulated.invRotate C).map f).hom₃ = f.hom₂

full_name: CategoryTheory.Pretriangulated.invRotate_map_hom₂
code: /-- The inverse rotation of triangles gives an endofunctor on the category of triangles in `C`.
-/
@[simps]
def invRotate : Triangle C ⥤ Triangle C 
goal: ∀ {X Y : CategoryTheory.Pretriangulated.Triangle C} (f : X ⟶ Y),
  ((CategoryTheory.Pretriangulated.invRotate C).map f).hom₂ = f.hom₁

full_name: CategoryTheory.Pretriangulated.rotCompInvRot_hom_app_hom₃
code: /-- The unit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def rotCompInvRot : 𝟭 (Triangle C) ≅ rotate C ⋙ invRotate C 
goal: (CategoryTheory.Pretriangulated.rotCompInvRot.hom.app X).hom₃ = 𝟙 X.obj₃

full_name: CategoryTheory.Pretriangulated.rotCompInvRot_hom_app_hom₂
code: /-- The unit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def rotCompInvRot : 𝟭 (Triangle C) ≅ rotate C ⋙ invRotate C 
goal: (CategoryTheory.Pretriangulated.rotCompInvRot.hom.app X).hom₂ = 𝟙 X.obj₂

full_name: CategoryTheory.Pretriangulated.rotCompInvRot_inv_app_hom₃
code: /-- The unit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def rotCompInvRot : 𝟭 (Triangle C) ≅ rotate C ⋙ invRotate C 
goal: (CategoryTheory.Pretriangulated.rotCompInvRot.inv.app X).hom₃ = 𝟙 X.obj₃

full_name: CategoryTheory.Pretriangulated.rotCompInvRot_hom_app_hom₁
code: /-- The unit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def rotCompInvRot : 𝟭 (Triangle C) ≅ rotate C ⋙ invRotate C 
goal: (CategoryTheory.Pretriangulated.rotCompInvRot.hom.app X).hom₁ =
  (CategoryTheory.shiftFunctorCompIsoId C 1 (-1) ⋯).inv.app X.obj₁

full_name: CategoryTheory.Pretriangulated.rotCompInvRot
code: /-- The unit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def rotCompInvRot : 𝟭 (Triangle C) ≅ rotate C ⋙ invRotate C 
goal: 𝟭 (CategoryTheory.Pretriangulated.Triangle C) ≅
  CategoryTheory.Pretriangulated.rotate C ⋙ CategoryTheory.Pretriangulated.invRotate C

full_name: CategoryTheory.Pretriangulated.rotCompInvRot_inv_app_hom₂
code: /-- The unit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def rotCompInvRot : 𝟭 (Triangle C) ≅ rotate C ⋙ invRotate C 
goal: (CategoryTheory.Pretriangulated.rotCompInvRot.inv.app X).hom₂ = 𝟙 X.obj₂

full_name: CategoryTheory.Pretriangulated.rotCompInvRot_inv_app_hom₁
code: /-- The unit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def rotCompInvRot : 𝟭 (Triangle C) ≅ rotate C ⋙ invRotate C 
goal: (CategoryTheory.Pretriangulated.rotCompInvRot.inv.app X).hom₁ =
  (CategoryTheory.shiftFunctorCompIsoId C 1 (-1) ⋯).hom.app X.obj₁

full_name: CategoryTheory.Pretriangulated.invRotCompRot_hom_app_hom₂
code: /-- The counit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def invRotCompRot : invRotate C ⋙ rotate C ≅ 𝟭 (Triangle C) 
goal: (CategoryTheory.Pretriangulated.invRotCompRot.hom.app X).hom₂ = 𝟙 X.obj₂

full_name: CategoryTheory.Pretriangulated.invRotCompRot
code: /-- The counit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def invRotCompRot : invRotate C ⋙ rotate C ≅ 𝟭 (Triangle C) 
goal: CategoryTheory.Pretriangulated.invRotate C ⋙ CategoryTheory.Pretriangulated.rotate C ≅
  𝟭 (CategoryTheory.Pretriangulated.Triangle C)

full_name: CategoryTheory.Pretriangulated.invRotCompRot_inv_app_hom₂
code: /-- The counit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def invRotCompRot : invRotate C ⋙ rotate C ≅ 𝟭 (Triangle C) 
goal: (CategoryTheory.Pretriangulated.invRotCompRot.inv.app X).hom₂ = 𝟙 X.obj₂

full_name: CategoryTheory.Pretriangulated.invRotCompRot_hom_app_hom₁
code: /-- The counit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def invRotCompRot : invRotate C ⋙ rotate C ≅ 𝟭 (Triangle C) 
goal: (CategoryTheory.Pretriangulated.invRotCompRot.hom.app X).hom₁ = 𝟙 X.obj₁

full_name: CategoryTheory.Pretriangulated.invRotCompRot_inv_app_hom₃
code: /-- The counit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def invRotCompRot : invRotate C ⋙ rotate C ≅ 𝟭 (Triangle C) 
goal: (CategoryTheory.Pretriangulated.invRotCompRot.inv.app X).hom₃ =
  (CategoryTheory.shiftFunctorCompIsoId C (-1) 1 ⋯).inv.app X.obj₃

full_name: CategoryTheory.Pretriangulated.invRotCompRot_hom_app_hom₃
code: /-- The counit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def invRotCompRot : invRotate C ⋙ rotate C ≅ 𝟭 (Triangle C) 
goal: (CategoryTheory.Pretriangulated.invRotCompRot.hom.app X).hom₃ =
  (CategoryTheory.shiftFunctorCompIsoId C (-1) 1 ⋯).hom.app X.obj₃

full_name: CategoryTheory.Pretriangulated.invRotCompRot_inv_app_hom₁
code: /-- The counit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. -/
@[simps!]
def invRotCompRot : invRotate C ⋙ rotate C ≅ 𝟭 (Triangle C) 
goal: (CategoryTheory.Pretriangulated.invRotCompRot.inv.app X).hom₁ = 𝟙 X.obj₁

full_name: CategoryTheory.Pretriangulated.triangleRotation
code: /-- Rotating triangles gives an auto-equivalence on the category of triangles in `C`.
-/
@[simps]
def triangleRotation : Equivalence (Triangle C) (Triangle C) 
goal: CategoryTheory.Pretriangulated.Triangle C ≌ CategoryTheory.Pretriangulated.Triangle C

full_name: CategoryTheory.Pretriangulated.triangleRotation_functor
code: /-- Rotating triangles gives an auto-equivalence on the category of triangles in `C`.
-/
@[simps]
def triangleRotation : Equivalence (Triangle C) (Triangle C) 
goal: (CategoryTheory.Pretriangulated.triangleRotation C).functor = CategoryTheory.Pretriangulated.rotate C

full_name: CategoryTheory.Pretriangulated.triangleRotation_unitIso
code: /-- Rotating triangles gives an auto-equivalence on the category of triangles in `C`.
-/
@[simps]
def triangleRotation : Equivalence (Triangle C) (Triangle C) 
goal: (CategoryTheory.Pretriangulated.triangleRotation C).unitIso = CategoryTheory.Pretriangulated.rotCompInvRot

full_name: CategoryTheory.Pretriangulated.triangleRotation_counitIso
code: /-- Rotating triangles gives an auto-equivalence on the category of triangles in `C`.
-/
@[simps]
def triangleRotation : Equivalence (Triangle C) (Triangle C) 
goal: (CategoryTheory.Pretriangulated.triangleRotation C).counitIso = CategoryTheory.Pretriangulated.invRotCompRot

full_name: CategoryTheory.Pretriangulated.triangleRotation_inverse
code: /-- Rotating triangles gives an auto-equivalence on the category of triangles in `C`.
-/
@[simps]
def triangleRotation : Equivalence (Triangle C) (Triangle C) 
goal: (CategoryTheory.Pretriangulated.triangleRotation C).inverse = CategoryTheory.Pretriangulated.invRotate C

full_name: CategoryTheory.Pretriangulated.instIsEquivalenceTriangleRotate
code: instance : (rotate C).IsEquivalence 
goal: (CategoryTheory.Pretriangulated.rotate C).IsEquivalence

full_name: CategoryTheory.Pretriangulated.instIsEquivalenceTriangleInvRotate
code: instance : (invRotate C).IsEquivalence 
goal: (CategoryTheory.Pretriangulated.invRotate C).IsEquivalence