Theorem: CategoryTheory.Pretriangulated.shiftFunctorAdd'_op_hom_app
File: Mathlib/CategoryTheory/Triangulated/Opposite.lean

tactic: omega
state_before: C : Type u_1
inst✝¹ : Category.{?u.8849, u_1} C
inst✝ : 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
⊢ b₁ + b₂ = b₃
state_after: no goals

tactic: erw [@pullbackShiftFunctorAdd'_hom_app (OppositeShift C ℤ) _ _ _ _ _ _ _ X
  a₁ a₂ a₃ h b₁ b₂ b₃ (by dsimp; omega) (by dsimp; omega) (by dsimp; omega)]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ (shiftFunctorAdd' Cᵒᵖ a₁ a₂ a₃ h).hom.app X =
    (shiftFunctorOpIso C a₃ b₃ h₃).hom.app X ≫
      ((shiftFunctorAdd' C b₁ b₂ b₃ ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ b₂ h₂).inv.app { unop := (shiftFunctor C b₁).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ b₁ h₁).inv.app X)
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃ b₃
              ⋯).hom.app
        X ≫
      (shiftFunctorAdd' (OppositeShift C ℤ) b₁ b₂ b₃ ⋯).hom.app X ≫
        (pullbackShiftIso (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
                  b₂ ⋯).inv.app
            ((shiftFunctor (OppositeShift C ℤ) b₁).obj X) ≫
          (shiftFunctor
                (PullbackShift (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1))
                a₂).map
            ((pullbackShiftIso (OppositeShift C ℤ)
                    (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
                    b₁ ⋯).inv.app
              X) =
    (shiftFunctorOpIso C a₃ b₃ h₃).hom.app X ≫
      ((shiftFunctorAdd' C b₁ b₂ b₃ ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ b₂ h₂).inv.app { unop := (shiftFunctor C b₁).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ b₁ h₁).inv.app X)

tactic: erw [oppositeShiftFunctorAdd'_hom_app]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃ b₃
              ⋯).hom.app
        X ≫
      (shiftFunctorAdd' (OppositeShift C ℤ) b₁ b₂ b₃ ⋯).hom.app X ≫
        (pullbackShiftIso (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
                  b₂ ⋯).inv.app
            ((shiftFunctor (OppositeShift C ℤ) b₁).obj X) ≫
          (shiftFunctor
                (PullbackShift (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1))
                a₂).map
            ((pullbackShiftIso (OppositeShift C ℤ)
                    (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
                    b₁ ⋯).inv.app
              X) =
    (shiftFunctorOpIso C a₃ b₃ h₃).hom.app X ≫
      ((shiftFunctorAdd' C b₁ b₂ b₃ ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ b₂ h₂).inv.app { unop := (shiftFunctor C b₁).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ b₁ h₁).inv.app X)
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃ b₃
              ⋯).hom.app
        X ≫
      ((shiftFunctorAdd' C b₁ b₂ b₃ ⋯).inv.app X.unop).op ≫
        (pullbackShiftIso (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
                  b₂ ⋯).inv.app
            ((shiftFunctor (OppositeShift C ℤ) b₁).obj X) ≫
          (shiftFunctor
                (PullbackShift (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1))
                a₂).map
            ((pullbackShiftIso (OppositeShift C ℤ)
                    (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
                    b₁ ⋯).inv.app
              X) =
    (shiftFunctorOpIso C a₃ b₃ h₃).hom.app X ≫
      ((shiftFunctorAdd' C b₁ b₂ b₃ ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ b₂ h₂).inv.app { unop := (shiftFunctor C b₁).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ b₁ h₁).inv.app X)

tactic: obtain rfl : b₁ = -a₁ := by omega
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃ b₃
              ⋯).hom.app
        X ≫
      ((shiftFunctorAdd' C b₁ b₂ b₃ ⋯).inv.app X.unop).op ≫
        (pullbackShiftIso (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
                  b₂ ⋯).inv.app
            ((shiftFunctor (OppositeShift C ℤ) b₁).obj X) ≫
          (shiftFunctor
                (PullbackShift (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1))
                a₂).map
            ((pullbackShiftIso (OppositeShift C ℤ)
                    (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
                    b₁ ⋯).inv.app
              X) =
    (shiftFunctorOpIso C a₃ b₃ h₃).hom.app X ≫
      ((shiftFunctorAdd' C b₁ b₂ b₃ ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ b₂ h₂).inv.app { unop := (shiftFunctor C b₁).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ b₁ h₁).inv.app X)
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
a₁ a₂ a₃ : ℤ
h : a₁ + a₂ = a₃
b₂ b₃ : ℤ
h₂ : a₂ + b₂ = 0
h₃ : a₃ + b₃ = 0
h₁ : a₁ + -a₁ = 0
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃ b₃
              ⋯).hom.app
        X ≫
      ((shiftFunctorAdd' C (-a₁) b₂ b₃ ⋯).inv.app X.unop).op ≫
        (pullbackShiftIso (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
                  b₂ ⋯).inv.app
            ((shiftFunctor (OppositeShift C ℤ) (-a₁)).obj X) ≫
          (shiftFunctor
                (PullbackShift (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1))
                a₂).map
            ((pullbackShiftIso (OppositeShift C ℤ)
                    (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
                    (-a₁) ⋯).inv.app
              X) =
    (shiftFunctorOpIso C a₃ b₃ h₃).hom.app X ≫
      ((shiftFunctorAdd' C (-a₁) b₂ b₃ ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ b₂ h₂).inv.app { unop := (shiftFunctor C (-a₁)).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ (-a₁) h₁).inv.app X)

tactic: obtain rfl : b₂ = -a₂ := by omega
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
a₁ a₂ a₃ : ℤ
h : a₁ + a₂ = a₃
b₂ b₃ : ℤ
h₂ : a₂ + b₂ = 0
h₃ : a₃ + b₃ = 0
h₁ : a₁ + -a₁ = 0
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃ b₃
              ⋯).hom.app
        X ≫
      ((shiftFunctorAdd' C (-a₁) b₂ b₃ ⋯).inv.app X.unop).op ≫
        (pullbackShiftIso (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
                  b₂ ⋯).inv.app
            ((shiftFunctor (OppositeShift C ℤ) (-a₁)).obj X) ≫
          (shiftFunctor
                (PullbackShift (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1))
                a₂).map
            ((pullbackShiftIso (OppositeShift C ℤ)
                    (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
                    (-a₁) ⋯).inv.app
              X) =
    (shiftFunctorOpIso C a₃ b₃ h₃).hom.app X ≫
      ((shiftFunctorAdd' C (-a₁) b₂ b₃ ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ b₂ h₂).inv.app { unop := (shiftFunctor C (-a₁)).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ (-a₁) h₁).inv.app X)
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
a₁ a₂ a₃ : ℤ
h : a₁ + a₂ = a₃
b₃ : ℤ
h₃ : a₃ + b₃ = 0
h₁ : a₁ + -a₁ = 0
h₂ : a₂ + -a₂ = 0
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃ b₃
              ⋯).hom.app
        X ≫
      ((shiftFunctorAdd' C (-a₁) (-a₂) b₃ ⋯).inv.app X.unop).op ≫
        (pullbackShiftIso (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
                  (-a₂) ⋯).inv.app
            ((shiftFunctor (OppositeShift C ℤ) (-a₁)).obj X) ≫
          (shiftFunctor
                (PullbackShift (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1))
                a₂).map
            ((pullbackShiftIso (OppositeShift C ℤ)
                    (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
                    (-a₁) ⋯).inv.app
              X) =
    (shiftFunctorOpIso C a₃ b₃ h₃).hom.app X ≫
      ((shiftFunctorAdd' C (-a₁) (-a₂) b₃ ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ (-a₂) h₂).inv.app { unop := (shiftFunctor C (-a₁)).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ (-a₁) h₁).inv.app X)

tactic: obtain rfl : b₃ = -a₃ := by omega
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
a₁ a₂ a₃ : ℤ
h : a₁ + a₂ = a₃
b₃ : ℤ
h₃ : a₃ + b₃ = 0
h₁ : a₁ + -a₁ = 0
h₂ : a₂ + -a₂ = 0
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃ b₃
              ⋯).hom.app
        X ≫
      ((shiftFunctorAdd' C (-a₁) (-a₂) b₃ ⋯).inv.app X.unop).op ≫
        (pullbackShiftIso (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
                  (-a₂) ⋯).inv.app
            ((shiftFunctor (OppositeShift C ℤ) (-a₁)).obj X) ≫
          (shiftFunctor
                (PullbackShift (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1))
                a₂).map
            ((pullbackShiftIso (OppositeShift C ℤ)
                    (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
                    (-a₁) ⋯).inv.app
              X) =
    (shiftFunctorOpIso C a₃ b₃ h₃).hom.app X ≫
      ((shiftFunctorAdd' C (-a₁) (-a₂) b₃ ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ (-a₂) h₂).inv.app { unop := (shiftFunctor C (-a₁)).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ (-a₁) h₁).inv.app X)
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
a₁ a₂ a₃ : ℤ
h : a₁ + a₂ = a₃
h₁ : a₁ + -a₁ = 0
h₂ : a₂ + -a₂ = 0
h₃ : a₃ + -a₃ = 0
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃ (-a₃)
              ⋯).hom.app
        X ≫
      ((shiftFunctorAdd' C (-a₁) (-a₂) (-a₃) ⋯).inv.app X.unop).op ≫
        (pullbackShiftIso (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
                  (-a₂) ⋯).inv.app
            ((shiftFunctor (OppositeShift C ℤ) (-a₁)).obj X) ≫
          (shiftFunctor
                (PullbackShift (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1))
                a₂).map
            ((pullbackShiftIso (OppositeShift C ℤ)
                    (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
                    (-a₁) ⋯).inv.app
              X) =
    (shiftFunctorOpIso C a₃ (-a₃) h₃).hom.app X ≫
      ((shiftFunctorAdd' C (-a₁) (-a₂) (-a₃) ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ (-a₂) h₂).inv.app { unop := (shiftFunctor C (-a₁)).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ (-a₁) h₁).inv.app X)

tactic: rfl
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
a₁ a₂ a₃ : ℤ
h : a₁ + a₂ = a₃
h₁ : a₁ + -a₁ = 0
h₂ : a₂ + -a₂ = 0
h₃ : a₃ + -a₃ = 0
⊢ (pullbackShiftIso (OppositeShift C ℤ)
              (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃ (-a₃)
              ⋯).hom.app
        X ≫
      ((shiftFunctorAdd' C (-a₁) (-a₂) (-a₃) ⋯).inv.app X.unop).op ≫
        (pullbackShiftIso (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
                  (-a₂) ⋯).inv.app
            ((shiftFunctor (OppositeShift C ℤ) (-a₁)).obj X) ≫
          (shiftFunctor
                (PullbackShift (OppositeShift C ℤ)
                  (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1))
                a₂).map
            ((pullbackShiftIso (OppositeShift C ℤ)
                    (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
                    (-a₁) ⋯).inv.app
              X) =
    (shiftFunctorOpIso C a₃ (-a₃) h₃).hom.app X ≫
      ((shiftFunctorAdd' C (-a₁) (-a₂) (-a₃) ⋯).inv.app X.unop).op ≫
        (shiftFunctorOpIso C a₂ (-a₂) h₂).inv.app { unop := (shiftFunctor C (-a₁)).toPrefunctor.1 X.unop } ≫
          (shiftFunctor Cᵒᵖ a₂).map ((shiftFunctorOpIso C a₁ (-a₁) h₁).inv.app X)
state_after: no goals

tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ b₁ = (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₁
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ b₁ = -a₁

tactic: omega
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ b₁ = -a₁
state_after: no goals

tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ b₂ = (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₂
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ b₂ = -a₂

tactic: omega
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ b₂ = -a₂
state_after: no goals

tactic: dsimp
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ b₃ = (AddMonoidHom.mk' (fun n => -n) CategoryTheory.Pretriangulated.Opposite.OppositeShiftAux.proof_1) a₃
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ b₃ = -a₃

tactic: omega
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : 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
⊢ b₃ = -a₃
state_after: no goals

tactic: omega
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
a₁ a₂ a₃ : ℤ
h : a₁ + a₂ = a₃
b₂ b₃ : ℤ
h₂ : a₂ + b₂ = 0
h₃ : a₃ + b₃ = 0
h₁ : a₁ + -a₁ = 0
⊢ b₂ = -a₂
state_after: no goals

tactic: omega
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasShift C ℤ
X : Cᵒᵖ
a₁ a₂ a₃ : ℤ
h : a₁ + a₂ = a₃
b₃ : ℤ
h₃ : a₃ + b₃ = 0
h₁ : a₁ + -a₁ = 0
h₂ : a₂ + -a₂ = 0
⊢ b₃ = -a₃
state_after: no goals