Theorem: CategoryTheory.shiftFunctorAdd'_assoc
File: Mathlib/CategoryTheory/Shift/Basic.lean

tactic: rw [← h₁₂, h₁₂₃]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A
h₁₂ : a₁ + a₂ = a₁₂
h₂₃ : a₂ + a₃ = a₂₃
h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃
⊢ a₁₂ + a₃ = a₁₂₃
state_after: no goals

tactic: rw [← h₂₃, ← add_assoc, h₁₂₃]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A
h₁₂ : a₁ + a₂ = a₁₂
h₂₃ : a₂ + a₃ = a₂₃
h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃
⊢ a₁ + a₂₃ = a₁₂₃
state_after: no goals

tactic: subst h₁₂ h₂₃ h₁₂₃
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ a₁₂ a₂₃ a₁₂₃ : A
h₁₂ : a₁ + a₂ = a₁₂
h₂₃ : a₂ + a₃ = a₂₃
h₁₂₃ : a₁ + a₂ + a₃ = a₁₂₃
⊢ shiftFunctorAdd' C a₁₂ a₃ a₁₂₃ ⋯ ≪≫
      isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂) (shiftFunctor C a₃) ≪≫
        (shiftFunctor C a₁).associator (shiftFunctor C a₂) (shiftFunctor C a₃) =
    shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ ⋯ ≪≫ isoWhiskerLeft (shiftFunctor C a₁) (shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃)
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
⊢ shiftFunctorAdd' C (a₁ + a₂) a₃ (a₁ + a₂ + a₃) ⋯ ≪≫
      isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ (a₁ + a₂) ⋯) (shiftFunctor C a₃) ≪≫
        (shiftFunctor C a₁).associator (shiftFunctor C a₂) (shiftFunctor C a₃) =
    shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯ ≪≫
      isoWhiskerLeft (shiftFunctor C a₁) (shiftFunctorAdd' C a₂ a₃ (a₂ + a₃) ⋯)

tactic: ext X
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
⊢ shiftFunctorAdd' C (a₁ + a₂) a₃ (a₁ + a₂ + a₃) ⋯ ≪≫
      isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ (a₁ + a₂) ⋯) (shiftFunctor C a₃) ≪≫
        (shiftFunctor C a₁).associator (shiftFunctor C a₂) (shiftFunctor C a₃) =
    shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯ ≪≫
      isoWhiskerLeft (shiftFunctor C a₁) (shiftFunctorAdd' C a₂ a₃ (a₂ + a₃) ⋯)
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ (shiftFunctorAdd' C (a₁ + a₂) a₃ (a₁ + a₂ + a₃) ⋯ ≪≫
            isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ (a₁ + a₂) ⋯) (shiftFunctor C a₃) ≪≫
              (shiftFunctor C a₁).associator (shiftFunctor C a₂) (shiftFunctor C a₃)).hom.app
      X =
    (shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯ ≪≫
            isoWhiskerLeft (shiftFunctor C a₁) (shiftFunctorAdd' C a₂ a₃ (a₂ + a₃) ⋯)).hom.app
      X

tactic: dsimp
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ (shiftFunctorAdd' C (a₁ + a₂) a₃ (a₁ + a₂ + a₃) ⋯ ≪≫
            isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ (a₁ + a₂) ⋯) (shiftFunctor C a₃) ≪≫
              (shiftFunctor C a₁).associator (shiftFunctor C a₂) (shiftFunctor C a₃)).hom.app
      X =
    (shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯ ≪≫
            isoWhiskerLeft (shiftFunctor C a₁) (shiftFunctorAdd' C a₂ a₃ (a₂ + a₃) ⋯)).hom.app
      X
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ (shiftFunctorAdd' C (a₁ + a₂) a₃ (a₁ + a₂ + a₃) ⋯).hom.app X ≫
      (shiftFunctor C a₃).map ((shiftFunctorAdd' C a₁ a₂ (a₁ + a₂) ⋯).hom.app X) ≫
        𝟙 ((shiftFunctor C a₃).obj ((shiftFunctor C a₂).obj ((shiftFunctor C a₁).obj X))) =
    (shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯).hom.app X ≫
      (shiftFunctorAdd' C a₂ a₃ (a₂ + a₃) ⋯).hom.app ((shiftFunctor C a₁).obj X)

tactic: simp only [shiftFunctorAdd'_eq_shiftFunctorAdd, Category.comp_id]
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ (shiftFunctorAdd' C (a₁ + a₂) a₃ (a₁ + a₂ + a₃) ⋯).hom.app X ≫
      (shiftFunctor C a₃).map ((shiftFunctorAdd' C a₁ a₂ (a₁ + a₂) ⋯).hom.app X) ≫
        𝟙 ((shiftFunctor C a₃).obj ((shiftFunctor C a₂).obj ((shiftFunctor C a₁).obj X))) =
    (shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯).hom.app X ≫
      (shiftFunctorAdd' C a₂ a₃ (a₂ + a₃) ⋯).hom.app ((shiftFunctor C a₁).obj X)
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ (shiftFunctorAdd C (a₁ + a₂) a₃).hom.app X ≫ (shiftFunctor C a₃).map ((shiftFunctorAdd C a₁ a₂).hom.app X) =
    (shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯).hom.app X ≫
      (shiftFunctorAdd C a₂ a₃).hom.app ((shiftFunctor C a₁).obj X)

tactic: dsimp [shiftFunctorAdd']
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ (shiftFunctorAdd C (a₁ + a₂) a₃).hom.app X ≫ (shiftFunctor C a₃).map ((shiftFunctorAdd C a₁ a₂).hom.app X) =
    (shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯).hom.app X ≫
      (shiftFunctorAdd C a₂ a₃).hom.app ((shiftFunctor C a₁).obj X)
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ (shiftFunctorAdd C (a₁ + a₂) a₃).hom.app X ≫ (shiftFunctor C a₃).map ((shiftFunctorAdd C a₁ a₂).hom.app X) =
    ((eqToHom ⋯).app X ≫ (shiftFunctorAdd C a₁ (a₂ + a₃)).hom.app X) ≫
      (shiftFunctorAdd C a₂ a₃).hom.app ((shiftFunctor C a₁).obj X)

tactic: simp only [eqToHom_app]
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ (shiftFunctorAdd C (a₁ + a₂) a₃).hom.app X ≫ (shiftFunctor C a₃).map ((shiftFunctorAdd C a₁ a₂).hom.app X) =
    ((eqToHom ⋯).app X ≫ (shiftFunctorAdd C a₁ (a₂ + a₃)).hom.app X) ≫
      (shiftFunctorAdd C a₂ a₃).hom.app ((shiftFunctor C a₁).obj X)
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ (shiftFunctorAdd C (a₁ + a₂) a₃).hom.app X ≫ (shiftFunctor C a₃).map ((shiftFunctorAdd C a₁ a₂).hom.app X) =
    (eqToHom ⋯ ≫ (shiftFunctorAdd C a₁ (a₂ + a₃)).hom.app X) ≫
      (shiftFunctorAdd C a₂ a₃).hom.app ((shiftFunctor C a₁).obj X)

tactic: dsimp [shiftFunctorAdd, shiftFunctor]
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ (shiftFunctorAdd C (a₁ + a₂) a₃).hom.app X ≫ (shiftFunctor C a₃).map ((shiftFunctorAdd C a₁ a₂).hom.app X) =
    (eqToHom ⋯ ≫ (shiftFunctorAdd C a₁ (a₂ + a₃)).hom.app X) ≫
      (shiftFunctorAdd C a₂ a₃).hom.app ((shiftFunctor C a₁).obj X)
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ ((shiftMonoidalFunctor C A).μIso { as := a₁ + a₂ } { as := a₃ }).inv.app X ≫
      ((shiftMonoidalFunctor C A).obj { as := a₃ }).map
        (((shiftMonoidalFunctor C A).μIso { as := a₁ } { as := a₂ }).inv.app X) =
    (eqToHom ⋯ ≫ ((shiftMonoidalFunctor C A).μIso { as := a₁ } { as := a₂ + a₃ }).inv.app X) ≫
      ((shiftMonoidalFunctor C A).μIso { as := a₂ } { as := a₃ }).inv.app
        (((shiftMonoidalFunctor C A).obj { as := a₁ }).obj X)

tactic: simp only [obj_μ_inv_app, Discrete.addMonoidal_associator, eqToIso.hom, eqToHom_map,
  eqToHom_app]
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ ((shiftMonoidalFunctor C A).μIso { as := a₁ + a₂ } { as := a₃ }).inv.app X ≫
      ((shiftMonoidalFunctor C A).obj { as := a₃ }).map
        (((shiftMonoidalFunctor C A).μIso { as := a₁ } { as := a₂ }).inv.app X) =
    (eqToHom ⋯ ≫ ((shiftMonoidalFunctor C A).μIso { as := a₁ } { as := a₂ + a₃ }).inv.app X) ≫
      ((shiftMonoidalFunctor C A).μIso { as := a₂ } { as := a₃ }).inv.app
        (((shiftMonoidalFunctor C A).obj { as := a₁ }).obj X)
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ ((shiftMonoidalFunctor C A).μIso { as := a₁ + a₂ } { as := a₃ }).inv.app X ≫
      ((shiftMonoidalFunctor C A).μ (MonoidalCategory.tensorObj { as := a₁ } { as := a₂ }) { as := a₃ }).app X ≫
        eqToHom ⋯ ≫
          ((shiftMonoidalFunctor C A).μIso { as := a₁ } (MonoidalCategory.tensorObj { as := a₂ } { as := a₃ })).inv.app
              X ≫
            ((shiftMonoidalFunctor C A).μIso { as := a₂ } { as := a₃ }).inv.app
              (((shiftMonoidalFunctor C A).obj { as := a₁ }).obj X) =
    (eqToHom ⋯ ≫ ((shiftMonoidalFunctor C A).μIso { as := a₁ } { as := a₂ + a₃ }).inv.app X) ≫
      ((shiftMonoidalFunctor C A).μIso { as := a₂ } { as := a₃ }).inv.app
        (((shiftMonoidalFunctor C A).obj { as := a₁ }).obj X)

tactic: erw [Iso.inv_hom_id_app_assoc, Category.assoc]
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ ((shiftMonoidalFunctor C A).μIso { as := a₁ + a₂ } { as := a₃ }).inv.app X ≫
      ((shiftMonoidalFunctor C A).μ (MonoidalCategory.tensorObj { as := a₁ } { as := a₂ }) { as := a₃ }).app X ≫
        eqToHom ⋯ ≫
          ((shiftMonoidalFunctor C A).μIso { as := a₁ } (MonoidalCategory.tensorObj { as := a₂ } { as := a₃ })).inv.app
              X ≫
            ((shiftMonoidalFunctor C A).μIso { as := a₂ } { as := a₃ }).inv.app
              (((shiftMonoidalFunctor C A).obj { as := a₁ }).obj X) =
    (eqToHom ⋯ ≫ ((shiftMonoidalFunctor C A).μIso { as := a₁ } { as := a₂ + a₃ }).inv.app X) ≫
      ((shiftMonoidalFunctor C A).μIso { as := a₂ } { as := a₃ }).inv.app
        (((shiftMonoidalFunctor C A).obj { as := a₁ }).obj X)
state_after: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ eqToHom ⋯ ≫
      ((shiftMonoidalFunctor C A).μIso { as := a₁ } (MonoidalCategory.tensorObj { as := a₂ } { as := a₃ })).inv.app X ≫
        ((shiftMonoidalFunctor C A).μIso { as := a₂ } { as := a₃ }).inv.app
          (((shiftMonoidalFunctor C A).obj { as := a₁ }).obj X) =
    eqToHom ⋯ ≫
      ((shiftMonoidalFunctor C A).μIso { as := a₁ } { as := a₂ + a₃ }).inv.app X ≫
        ((shiftMonoidalFunctor C A).μIso { as := a₂ } { as := a₃ }).inv.app
          (((shiftMonoidalFunctor C A).obj { as := a₁ }).obj X)

tactic: rfl
state_before: case w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a₁ a₂ a₃ : A
X : C
⊢ eqToHom ⋯ ≫
      ((shiftMonoidalFunctor C A).μIso { as := a₁ } (MonoidalCategory.tensorObj { as := a₂ } { as := a₃ })).inv.app X ≫
        ((shiftMonoidalFunctor C A).μIso { as := a₂ } { as := a₃ }).inv.app
          (((shiftMonoidalFunctor C A).obj { as := a₁ }).obj X) =
    eqToHom ⋯ ≫
      ((shiftMonoidalFunctor C A).μIso { as := a₁ } { as := a₂ + a₃ }).inv.app X ≫
        ((shiftMonoidalFunctor C A).μIso { as := a₂ } { as := a₃ }).inv.app
          (((shiftMonoidalFunctor C A).obj { as := a₁ }).obj X)
state_after: no goals