Theorem: CategoryTheory.hasShiftMk_shift_toLaxMonoidalFunctor_toFunctor
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
⊢ ∀ {X Y : Discrete A} (f : X ⟶ Y) (X' : Discrete A),
    MonoidalCategory.whiskerRight (__src✝.map f) (__src✝.obj X') ≫ (fun m n => (h.add m.as n.as).inv) Y X' =
      (fun m n => (h.add m.as n.as).inv) X X' ≫ __src✝.map (MonoidalCategory.whiskerRight f X')
state_after: case mk.mk.up.up.refl.mk
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
⊢ MonoidalCategory.whiskerRight (__src✝.map { down := { down := ⋯ } }) (__src✝.obj { as := X' }) ≫
      (fun m n => (h.add m.as n.as).inv) { as := X } { as := X' } =
    (fun m n => (h.add m.as n.as).inv) { as := X } { as := X' } ≫
      __src✝.map (MonoidalCategory.whiskerRight { down := { down := ⋯ } } { as := X' })
tactic: rintro ⟨X⟩ ⟨Y⟩ ⟨⟨⟨rfl⟩⟩⟩ ⟨X'⟩
state_before: case mk.mk.up.up.refl.mk
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
⊢ MonoidalCategory.whiskerRight (__src✝.map { down := { down := ⋯ } }) (__src✝.obj { as := X' }) ≫
      (fun m n => (h.add m.as n.as).inv) { as := X } { as := X' } =
    (fun m n => (h.add m.as n.as).inv) { as := X } { as := X' } ≫
      __src✝.map (MonoidalCategory.whiskerRight { down := { down := ⋯ } } { as := X' })
state_after: case mk.mk.up.up.refl.mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
x✝ : C
⊢ (MonoidalCategory.whiskerRight (__src✝.map { down := { down := ⋯ } }) (__src✝.obj { as := X' }) ≫
          (fun m n => (h.add m.as n.as).inv) { as := X } { as := X' }).app
      x✝ =
    ((fun m n => (h.add m.as n.as).inv) { as := X } { as := X' } ≫
          __src✝.map (MonoidalCategory.whiskerRight { down := { down := ⋯ } } { as := X' })).app
      x✝
tactic: ext
state_before: case mk.mk.up.up.refl.mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
x✝ : C
⊢ (MonoidalCategory.whiskerRight (__src✝.map { down := { down := ⋯ } }) (__src✝.obj { as := X' }) ≫
          (fun m n => (h.add m.as n.as).inv) { as := X } { as := X' }).app
      x✝ =
    ((fun m n => (h.add m.as n.as).inv) { as := X } { as := X' } ≫
          __src✝.map (MonoidalCategory.whiskerRight { down := { down := ⋯ } } { as := X' })).app
      x✝
state_after: case mk.mk.up.up.refl.mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
x✝ : C
⊢ (h.F X').map (𝟙 ((h.F X).obj x✝)) ≫ (h.add X X').inv.app x✝ = (h.add X X').inv.app x✝ ≫ 𝟙 ((h.F (X + X')).obj x✝)
tactic: dsimp
state_before: case mk.mk.up.up.refl.mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
x✝ : C
⊢ (h.F X').map (𝟙 ((h.F X).obj x✝)) ≫ (h.add X X').inv.app x✝ = (h.add X X').inv.app x✝ ≫ 𝟙 ((h.F (X + X')).obj x✝)
state_after: no goals
tactic: simp
state_before: C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
⊢ ∀ {X Y : Discrete A} (X' : Discrete A) (f : X ⟶ Y),
    MonoidalCategory.whiskerLeft (__src✝.obj X') (__src✝.map f) ≫ (fun m n => (h.add m.as n.as).inv) X' Y =
      (fun m n => (h.add m.as n.as).inv) X' X ≫ __src✝.map (MonoidalCategory.whiskerLeft X' f)
state_after: case mk.mk.mk.up.up.refl
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
⊢ MonoidalCategory.whiskerLeft (__src✝.obj { as := X' }) (__src✝.map { down := { down := ⋯ } }) ≫
      (fun m n => (h.add m.as n.as).inv) { as := X' } { as := X } =
    (fun m n => (h.add m.as n.as).inv) { as := X' } { as := X } ≫
      __src✝.map (MonoidalCategory.whiskerLeft { as := X' } { down := { down := ⋯ } })
tactic: rintro ⟨X⟩ ⟨Y⟩ ⟨X'⟩ ⟨⟨⟨rfl⟩⟩⟩
state_before: case mk.mk.mk.up.up.refl
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
⊢ MonoidalCategory.whiskerLeft (__src✝.obj { as := X' }) (__src✝.map { down := { down := ⋯ } }) ≫
      (fun m n => (h.add m.as n.as).inv) { as := X' } { as := X } =
    (fun m n => (h.add m.as n.as).inv) { as := X' } { as := X } ≫
      __src✝.map (MonoidalCategory.whiskerLeft { as := X' } { down := { down := ⋯ } })
state_after: case mk.mk.mk.up.up.refl.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
x✝ : C
⊢ (MonoidalCategory.whiskerLeft (__src✝.obj { as := X' }) (__src✝.map { down := { down := ⋯ } }) ≫
          (fun m n => (h.add m.as n.as).inv) { as := X' } { as := X }).app
      x✝ =
    ((fun m n => (h.add m.as n.as).inv) { as := X' } { as := X } ≫
          __src✝.map (MonoidalCategory.whiskerLeft { as := X' } { down := { down := ⋯ } })).app
      x✝
tactic: ext
state_before: case mk.mk.mk.up.up.refl.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
x✝ : C
⊢ (MonoidalCategory.whiskerLeft (__src✝.obj { as := X' }) (__src✝.map { down := { down := ⋯ } }) ≫
          (fun m n => (h.add m.as n.as).inv) { as := X' } { as := X }).app
      x✝ =
    ((fun m n => (h.add m.as n.as).inv) { as := X' } { as := X } ≫
          __src✝.map (MonoidalCategory.whiskerLeft { as := X' } { down := { down := ⋯ } })).app
      x✝
state_after: case mk.mk.mk.up.up.refl.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
x✝ : C
⊢ 𝟙 ((h.F X).obj ((h.F X').obj x✝)) ≫ (h.add X' X).inv.app x✝ = (h.add X' X).inv.app x✝ ≫ 𝟙 ((h.F (X' + X)).obj x✝)
tactic: dsimp
state_before: case mk.mk.mk.up.up.refl.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
X X' : A
x✝ : C
⊢ 𝟙 ((h.F X).obj ((h.F X').obj x✝)) ≫ (h.add X' X).inv.app x✝ = (h.add X' X).inv.app x✝ ≫ 𝟙 ((h.F (X' + X)).obj x✝)
state_after: no goals
tactic: simp
state_before: C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
⊢ ∀ (X Y Z : Discrete A),
    MonoidalCategory.whiskerRight ((fun m n => (h.add m.as n.as).inv) X Y) (__src✝.obj Z) ≫
        (fun m n => (h.add m.as n.as).inv) (MonoidalCategory.tensorObj X Y) Z ≫
          __src✝.map (MonoidalCategory.associator X Y Z).hom =
      (MonoidalCategory.associator (__src✝.obj X) (__src✝.obj Y) (__src✝.obj Z)).hom ≫
        MonoidalCategory.whiskerLeft (__src✝.obj X) ((fun m n => (h.add m.as n.as).inv) Y Z) ≫
          (fun m n => (h.add m.as n.as).inv) X (MonoidalCategory.tensorObj Y Z)
state_after: case mk.mk.mk
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
m₁ m₂ m₃ : A
⊢ MonoidalCategory.whiskerRight ((fun m n => (h.add m.as n.as).inv) { as := m₁ } { as := m₂ })
        (__src✝.obj { as := m₃ }) ≫
      (fun m n => (h.add m.as n.as).inv) (MonoidalCategory.tensorObj { as := m₁ } { as := m₂ }) { as := m₃ } ≫
        __src✝.map (MonoidalCategory.associator { as := m₁ } { as := m₂ } { as := m₃ }).hom =
    (MonoidalCategory.associator (__src✝.obj { as := m₁ }) (__src✝.obj { as := m₂ }) (__src✝.obj { as := m₃ })).hom ≫
      MonoidalCategory.whiskerLeft (__src✝.obj { as := m₁ })
          ((fun m n => (h.add m.as n.as).inv) { as := m₂ } { as := m₃ }) ≫
        (fun m n => (h.add m.as n.as).inv) { as := m₁ } (MonoidalCategory.tensorObj { as := m₂ } { as := m₃ })
tactic: rintro ⟨m₁⟩ ⟨m₂⟩ ⟨m₃⟩
state_before: case mk.mk.mk
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
m₁ m₂ m₃ : A
⊢ MonoidalCategory.whiskerRight ((fun m n => (h.add m.as n.as).inv) { as := m₁ } { as := m₂ })
        (__src✝.obj { as := m₃ }) ≫
      (fun m n => (h.add m.as n.as).inv) (MonoidalCategory.tensorObj { as := m₁ } { as := m₂ }) { as := m₃ } ≫
        __src✝.map (MonoidalCategory.associator { as := m₁ } { as := m₂ } { as := m₃ }).hom =
    (MonoidalCategory.associator (__src✝.obj { as := m₁ }) (__src✝.obj { as := m₂ }) (__src✝.obj { as := m₃ })).hom ≫
      MonoidalCategory.whiskerLeft (__src✝.obj { as := m₁ })
          ((fun m n => (h.add m.as n.as).inv) { as := m₂ } { as := m₃ }) ≫
        (fun m n => (h.add m.as n.as).inv) { as := m₁ } (MonoidalCategory.tensorObj { as := m₂ } { as := m₃ })
state_after: case mk.mk.mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
m₁ m₂ m₃ : A
X : C
⊢ (MonoidalCategory.whiskerRight ((fun m n => (h.add m.as n.as).inv) { as := m₁ } { as := m₂ })
            (__src✝.obj { as := m₃ }) ≫
          (fun m n => (h.add m.as n.as).inv) (MonoidalCategory.tensorObj { as := m₁ } { as := m₂ }) { as := m₃ } ≫
            __src✝.map (MonoidalCategory.associator { as := m₁ } { as := m₂ } { as := m₃ }).hom).app
      X =
    ((MonoidalCategory.associator (__src✝.obj { as := m₁ }) (__src✝.obj { as := m₂ }) (__src✝.obj { as := m₃ })).hom ≫
          MonoidalCategory.whiskerLeft (__src✝.obj { as := m₁ })
              ((fun m n => (h.add m.as n.as).inv) { as := m₂ } { as := m₃ }) ≫
            (fun m n => (h.add m.as n.as).inv) { as := m₁ } (MonoidalCategory.tensorObj { as := m₂ } { as := m₃ })).app
      X
tactic: ext X
state_before: case mk.mk.mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
m₁ m₂ m₃ : A
X : C
⊢ (MonoidalCategory.whiskerRight ((fun m n => (h.add m.as n.as).inv) { as := m₁ } { as := m₂ })
            (__src✝.obj { as := m₃ }) ≫
          (fun m n => (h.add m.as n.as).inv) (MonoidalCategory.tensorObj { as := m₁ } { as := m₂ }) { as := m₃ } ≫
            __src✝.map (MonoidalCategory.associator { as := m₁ } { as := m₂ } { as := m₃ }).hom).app
      X =
    ((MonoidalCategory.associator (__src✝.obj { as := m₁ }) (__src✝.obj { as := m₂ }) (__src✝.obj { as := m₃ })).hom ≫
          MonoidalCategory.whiskerLeft (__src✝.obj { as := m₁ })
              ((fun m n => (h.add m.as n.as).inv) { as := m₂ } { as := m₃ }) ≫
            (fun m n => (h.add m.as n.as).inv) { as := m₁ } (MonoidalCategory.tensorObj { as := m₂ } { as := m₃ })).app
      X
state_after: no goals
tactic: simp [endofunctorMonoidalCategory, h.assoc_inv_app_assoc]
state_before: C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
⊢ ∀ (X : Discrete A),
    (MonoidalCategory.leftUnitor (__src✝.obj X)).hom =
      MonoidalCategory.whiskerRight h.zero.inv (__src✝.obj X) ≫
        (fun m n => (h.add m.as n.as).inv) (𝟙_ (Discrete A)) X ≫ __src✝.map (MonoidalCategory.leftUnitor X).hom
state_after: case mk
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
n : A
⊢ (MonoidalCategory.leftUnitor (__src✝.obj { as := n })).hom =
    MonoidalCategory.whiskerRight h.zero.inv (__src✝.obj { as := n }) ≫
      (fun m n => (h.add m.as n.as).inv) (𝟙_ (Discrete A)) { as := n } ≫
        __src✝.map (MonoidalCategory.leftUnitor { as := n }).hom
tactic: rintro ⟨n⟩
state_before: case mk
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
n : A
⊢ (MonoidalCategory.leftUnitor (__src✝.obj { as := n })).hom =
    MonoidalCategory.whiskerRight h.zero.inv (__src✝.obj { as := n }) ≫
      (fun m n => (h.add m.as n.as).inv) (𝟙_ (Discrete A)) { as := n } ≫
        __src✝.map (MonoidalCategory.leftUnitor { as := n }).hom
state_after: case mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
n : A
X : C
⊢ (MonoidalCategory.leftUnitor (__src✝.obj { as := n })).hom.app X =
    (MonoidalCategory.whiskerRight h.zero.inv (__src✝.obj { as := n }) ≫
          (fun m n => (h.add m.as n.as).inv) (𝟙_ (Discrete A)) { as := n } ≫
            __src✝.map (MonoidalCategory.leftUnitor { as := n }).hom).app
      X
tactic: ext X
state_before: case mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
n : A
X : C
⊢ (MonoidalCategory.leftUnitor (__src✝.obj { as := n })).hom.app X =
    (MonoidalCategory.whiskerRight h.zero.inv (__src✝.obj { as := n }) ≫
          (fun m n => (h.add m.as n.as).inv) (𝟙_ (Discrete A)) { as := n } ≫
            __src✝.map (MonoidalCategory.leftUnitor { as := n }).hom).app
      X
state_after: no goals
tactic: simp [endofunctorMonoidalCategory, h.zero_add_inv_app, ← Functor.map_comp]
state_before: C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
⊢ ∀ (X : Discrete A),
    (MonoidalCategory.rightUnitor (__src✝.obj X)).hom =
      MonoidalCategory.whiskerLeft (__src✝.obj X) h.zero.inv ≫
        (fun m n => (h.add m.as n.as).inv) X (𝟙_ (Discrete A)) ≫ __src✝.map (MonoidalCategory.rightUnitor X).hom
state_after: case mk
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
n : A
⊢ (MonoidalCategory.rightUnitor (__src✝.obj { as := n })).hom =
    MonoidalCategory.whiskerLeft (__src✝.obj { as := n }) h.zero.inv ≫
      (fun m n => (h.add m.as n.as).inv) { as := n } (𝟙_ (Discrete A)) ≫
        __src✝.map (MonoidalCategory.rightUnitor { as := n }).hom
tactic: rintro ⟨n⟩
state_before: case mk
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
n : A
⊢ (MonoidalCategory.rightUnitor (__src✝.obj { as := n })).hom =
    MonoidalCategory.whiskerLeft (__src✝.obj { as := n }) h.zero.inv ≫
      (fun m n => (h.add m.as n.as).inv) { as := n } (𝟙_ (Discrete A)) ≫
        __src✝.map (MonoidalCategory.rightUnitor { as := n }).hom
state_after: case mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
n : A
X : C
⊢ (MonoidalCategory.rightUnitor (__src✝.obj { as := n })).hom.app X =
    (MonoidalCategory.whiskerLeft (__src✝.obj { as := n }) h.zero.inv ≫
          (fun m n => (h.add m.as n.as).inv) { as := n } (𝟙_ (Discrete A)) ≫
            __src✝.map (MonoidalCategory.rightUnitor { as := n }).hom).app
      X
tactic: ext X
state_before: case mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
n : A
X : C
⊢ (MonoidalCategory.rightUnitor (__src✝.obj { as := n })).hom.app X =
    (MonoidalCategory.whiskerLeft (__src✝.obj { as := n }) h.zero.inv ≫
          (fun m n => (h.add m.as n.as).inv) { as := n } (𝟙_ (Discrete A)) ≫
            __src✝.map (MonoidalCategory.rightUnitor { as := n }).hom).app
      X
state_after: no goals
tactic: simp [endofunctorMonoidalCategory, h.add_zero_inv_app]