l3lab/ntp-mathlib huggingface dataset:
/-- Constructs a `HasShift C A` instance from `ShiftMkCore`. -/
@[simps]
def hasShiftMk (h : ShiftMkCore C A) : HasShift C A :=
  ⟨{ Discrete.functor h.F with
      ε := h.zero.inv
      μ := fun m n => (h.add m.as n.as).inv
      μ_natural := by
        rintro ⟨X⟩ ⟨Y⟩ ⟨X'⟩ ⟨Y'⟩ ⟨⟨⟨rfl⟩⟩⟩ ⟨⟨⟨rfl⟩⟩⟩
        ext
        dsimp
        simp
      associativity := by
        rintro ⟨m₁⟩ ⟨m₂⟩ ⟨m₃⟩
        ext X
        simp [endofunctorMonoidalCategory, h.assoc_inv_app_assoc]
      left_unitality := by
        

Proof state:
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
src✝ : Discrete A ⥤ C ⥤ C := Discrete.functor h.F
⊢ ∀ (X : Discrete A),
    (MonoidalCategory.leftUnitor ((Functor.mk src✝.toPrefunctor).obj X)).hom =
      MonoidalCategory.tensorHom h.zero.inv (𝟙 ((Functor.mk src✝.toPrefunctor).obj X)) ≫
        (fun m n => (ShiftMkCore.add h m.as n.as).inv) (𝟙_ (Discrete A)) X ≫
          (Functor.mk src✝.toPrefunctor).map (MonoidalCategory.leftUnitor X).hom

Next tactic:
rintro ⟨n⟩
/-- Constructs a `HasShift C A` instance from `ShiftMkCore`. -/
@[simps]
def hasShiftMk (h : ShiftMkCore C A) : HasShift C A :=
  ⟨{ Discrete.functor h.F with
      ε := h.zero.inv
      μ := fun m n => (h.add m.as n.as).inv
      μ_natural := by
        rintro ⟨X⟩ ⟨Y⟩ ⟨X'⟩ ⟨Y'⟩ ⟨⟨⟨rfl⟩⟩⟩ ⟨⟨⟨rfl⟩⟩⟩
        ext
        dsimp
        simp
      associativity := by
        rintro ⟨m₁⟩ ⟨m₂⟩ ⟨m₃⟩
        ext X
        simp [endofunctorMonoidalCategory, h.assoc_inv_app_assoc]
      left_unitality := by
        rintro ⟨n⟩
        

Proof state:
case mk
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
src✝ : Discrete A ⥤ C ⥤ C := Discrete.functor h.F
n : A
⊢ (MonoidalCategory.leftUnitor ((Functor.mk src✝.toPrefunctor).obj { as := n })).hom =
    MonoidalCategory.tensorHom h.zero.inv (𝟙 ((Functor.mk src✝.toPrefunctor).obj { as := n })) ≫
      (fun m n => (ShiftMkCore.add h m.as n.as).inv) (𝟙_ (Discrete A)) { as := n } ≫
        (Functor.mk src✝.toPrefunctor).map (MonoidalCategory.leftUnitor { as := n }).hom

Next tactic:
ext X
/-- Constructs a `HasShift C A` instance from `ShiftMkCore`. -/
@[simps]
def hasShiftMk (h : ShiftMkCore C A) : HasShift C A :=
  ⟨{ Discrete.functor h.F with
      ε := h.zero.inv
      μ := fun m n => (h.add m.as n.as).inv
      μ_natural := by
        rintro ⟨X⟩ ⟨Y⟩ ⟨X'⟩ ⟨Y'⟩ ⟨⟨⟨rfl⟩⟩⟩ ⟨⟨⟨rfl⟩⟩⟩
        ext
        dsimp
        simp
      associativity := by
        rintro ⟨m₁⟩ ⟨m₂⟩ ⟨m₃⟩
        ext X
        simp [endofunctorMonoidalCategory, h.assoc_inv_app_assoc]
      left_unitality := by
        rintro ⟨n⟩
        ext X
        

Proof state:
case mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
src✝ : Discrete A ⥤ C ⥤ C := Discrete.functor h.F
n : A
X : C
⊢ (MonoidalCategory.leftUnitor ((Functor.mk src✝.toPrefunctor).obj { as := n })).hom.app X =
    (MonoidalCategory.tensorHom h.zero.inv (𝟙 ((Functor.mk src✝.toPrefunctor).obj { as := n })) ≫
          (fun m n => (ShiftMkCore.add h m.as n.as).inv) (𝟙_ (Discrete A)) { as := n } ≫
            (Functor.mk src✝.toPrefunctor).map (MonoidalCategory.leftUnitor { as := n }).hom).app
      X

Next tactic:
simp [endofunctorMonoidalCategory, h.zero_add_inv_app, ← Functor.map_comp]
/-- Constructs a `HasShift C A` instance from `ShiftMkCore`. -/
@[simps]
def hasShiftMk (h : ShiftMkCore C A) : HasShift C A :=
  ⟨{ Discrete.functor h.F with
      ε := h.zero.inv
      μ := fun m n => (h.add m.as n.as).inv
      μ_natural := by
        rintro ⟨X⟩ ⟨Y⟩ ⟨X'⟩ ⟨Y'⟩ ⟨⟨⟨rfl⟩⟩⟩ ⟨⟨⟨rfl⟩⟩⟩
        ext
        dsimp
        simp
      associativity := by
        rintro ⟨m₁⟩ ⟨m₂⟩ ⟨m₃⟩
        ext X
        simp [endofunctorMonoidalCategory, h.assoc_inv_app_assoc]
      left_unitality := by
        rintro ⟨n⟩
        ext X
        simp [endofunctorMonoidalCategory, h.zero_add_inv_app, ← Functor.map_comp]
      right_unitality := by
        

Proof state:
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
src✝ : Discrete A ⥤ C ⥤ C := Discrete.functor h.F
⊢ ∀ (X : Discrete A),
    (MonoidalCategory.rightUnitor ((Functor.mk src✝.toPrefunctor).obj X)).hom =
      MonoidalCategory.tensorHom (𝟙 ((Functor.mk src✝.toPrefunctor).obj X)) h.zero.inv ≫
        (fun m n => (ShiftMkCore.add h m.as n.as).inv) X (𝟙_ (Discrete A)) ≫
          (Functor.mk src✝.toPrefunctor).map (MonoidalCategory.rightUnitor X).hom

Next tactic:
rintro ⟨n⟩
/-- Constructs a `HasShift C A` instance from `ShiftMkCore`. -/
@[simps]
def hasShiftMk (h : ShiftMkCore C A) : HasShift C A :=
  ⟨{ Discrete.functor h.F with
      ε := h.zero.inv
      μ := fun m n => (h.add m.as n.as).inv
      μ_natural := by
        rintro ⟨X⟩ ⟨Y⟩ ⟨X'⟩ ⟨Y'⟩ ⟨⟨⟨rfl⟩⟩⟩ ⟨⟨⟨rfl⟩⟩⟩
        ext
        dsimp
        simp
      associativity := by
        rintro ⟨m₁⟩ ⟨m₂⟩ ⟨m₃⟩
        ext X
        simp [endofunctorMonoidalCategory, h.assoc_inv_app_assoc]
      left_unitality := by
        rintro ⟨n⟩
        ext X
        simp [endofunctorMonoidalCategory, h.zero_add_inv_app, ← Functor.map_comp]
      right_unitality := by
        rintro ⟨n⟩
        

Proof state:
case mk
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
src✝ : Discrete A ⥤ C ⥤ C := Discrete.functor h.F
n : A
⊢ (MonoidalCategory.rightUnitor ((Functor.mk src✝.toPrefunctor).obj { as := n })).hom =
    MonoidalCategory.tensorHom (𝟙 ((Functor.mk src✝.toPrefunctor).obj { as := n })) h.zero.inv ≫
      (fun m n => (ShiftMkCore.add h m.as n.as).inv) { as := n } (𝟙_ (Discrete A)) ≫
        (Functor.mk src✝.toPrefunctor).map (MonoidalCategory.rightUnitor { as := n }).hom

Next tactic:
ext X
/-- Constructs a `HasShift C A` instance from `ShiftMkCore`. -/
@[simps]
def hasShiftMk (h : ShiftMkCore C A) : HasShift C A :=
  ⟨{ Discrete.functor h.F with
      ε := h.zero.inv
      μ := fun m n => (h.add m.as n.as).inv
      μ_natural := by
        rintro ⟨X⟩ ⟨Y⟩ ⟨X'⟩ ⟨Y'⟩ ⟨⟨⟨rfl⟩⟩⟩ ⟨⟨⟨rfl⟩⟩⟩
        ext
        dsimp
        simp
      associativity := by
        rintro ⟨m₁⟩ ⟨m₂⟩ ⟨m₃⟩
        ext X
        simp [endofunctorMonoidalCategory, h.assoc_inv_app_assoc]
      left_unitality := by
        rintro ⟨n⟩
        ext X
        simp [endofunctorMonoidalCategory, h.zero_add_inv_app, ← Functor.map_comp]
      right_unitality := by
        rintro ⟨n⟩
        ext X
        

Proof state:
case mk.w.h
C : Type u
A : Type u_1
inst✝¹ : Category.{v, u} C
inst✝ : AddMonoid A
h : ShiftMkCore C A
src✝ : Discrete A ⥤ C ⥤ C := Discrete.functor h.F
n : A
X : C
⊢ (MonoidalCategory.rightUnitor ((Functor.mk src✝.toPrefunctor).obj { as := n })).hom.app X =
    (MonoidalCategory.tensorHom (𝟙 ((Functor.mk src✝.toPrefunctor).obj { as := n })) h.zero.inv ≫
          (fun m n => (ShiftMkCore.add h m.as n.as).inv) { as := n } (𝟙_ (Discrete A)) ≫
            (Functor.mk src✝.toPrefunctor).map (MonoidalCategory.rightUnitor { as := n }).hom).app
      X

Next tactic:
simp [endofunctorMonoidalCategory, h.add_zero_inv_app]
/-- When `k = i + j`, shifting by `k` is the same as shifting by `i` and then shifting by `j`. -/
def shiftFunctorAdd' (i j k : A) (h : i + j = k) :
    shiftFunctor C k ≅ shiftFunctor C i ⋙ shiftFunctor C j :=
  eqToIso (by 

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
i j k : A
h : i + j = k
⊢ shiftFunctor C k = shiftFunctor C (i + j)

Next tactic:
rw [h]
lemma shiftFunctorAdd'_eq_shiftFunctorAdd (i j : A) :
    shiftFunctorAdd' C i j (i+j) rfl = shiftFunctorAdd C i j := by
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
i j : A
⊢ shiftFunctorAdd' C i j (i + j) (_ : i + j = i + j) = shiftFunctorAdd C i j

Next tactic:
ext1
lemma shiftFunctorAdd'_eq_shiftFunctorAdd (i j : A) :
    shiftFunctorAdd' C i j (i+j) rfl = shiftFunctorAdd C i j := by
  ext1
  

Proof state:
case w
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
i j : A
⊢ (shiftFunctorAdd' C i j (i + j) (_ : i + j = i + j)).hom = (shiftFunctorAdd C i j).hom

Next tactic:
apply Category.id_comp
lemma ShiftMkCore.shiftFunctor_eq (h : ShiftMkCore C A) (a : A) :
    letI := hasShiftMk C A h;
    shiftFunctor C a = h.F a := by
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
a : A
⊢ shiftFunctor C a = F h a

Next tactic:
rfl
lemma ShiftMkCore.shiftFunctorZero_eq (h : ShiftMkCore C A) :
    letI := hasShiftMk C A h;
    shiftFunctorZero C A = h.zero := by
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
⊢ shiftFunctorZero C A = h.zero

Next tactic:
letI := hasShiftMk C A h
lemma ShiftMkCore.shiftFunctorZero_eq (h : ShiftMkCore C A) :
    letI := hasShiftMk C A h;
    shiftFunctorZero C A = h.zero := by
  letI := hasShiftMk C A h
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ shiftFunctorZero C A = h.zero

Next tactic:
dsimp [shiftFunctorZero]
lemma ShiftMkCore.shiftFunctorZero_eq (h : ShiftMkCore C A) :
    letI := hasShiftMk C A h;
    shiftFunctorZero C A = h.zero := by
  letI := hasShiftMk C A h
  dsimp [shiftFunctorZero]
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (MonoidalFunctor.εIso (shiftMonoidalFunctor C A)).symm = h.zero

Next tactic:
change (shiftFunctorZero C A).symm.symm = h.zero.symm.symm
lemma ShiftMkCore.shiftFunctorZero_eq (h : ShiftMkCore C A) :
    letI := hasShiftMk C A h;
    shiftFunctorZero C A = h.zero := by
  letI := hasShiftMk C A h
  dsimp [shiftFunctorZero]
  change (shiftFunctorZero C A).symm.symm = h.zero.symm.symm
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorZero C A).symm.symm = h.zero.symm.symm

Next tactic:
congr 1
lemma ShiftMkCore.shiftFunctorZero_eq (h : ShiftMkCore C A) :
    letI := hasShiftMk C A h;
    shiftFunctorZero C A = h.zero := by
  letI := hasShiftMk C A h
  dsimp [shiftFunctorZero]
  change (shiftFunctorZero C A).symm.symm = h.zero.symm.symm
  congr 1
  

Proof state:
case e_I
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorZero C A).symm = h.zero.symm

Next tactic:
ext
lemma ShiftMkCore.shiftFunctorZero_eq (h : ShiftMkCore C A) :
    letI := hasShiftMk C A h;
    shiftFunctorZero C A = h.zero := by
  letI := hasShiftMk C A h
  dsimp [shiftFunctorZero]
  change (shiftFunctorZero C A).symm.symm = h.zero.symm.symm
  congr 1
  ext
  

Proof state:
case e_I.w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
this : HasShift C A := hasShiftMk C A h
x✝ : C
⊢ (shiftFunctorZero C A).symm.hom.app x✝ = h.zero.symm.hom.app x✝

Next tactic:
rfl
lemma ShiftMkCore.shiftFunctorAdd_eq (h : ShiftMkCore C A) (a b : A) :
    letI := hasShiftMk C A h;
    shiftFunctorAdd C a b = h.add a b := by
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
a b : A
⊢ shiftFunctorAdd C a b = add h a b

Next tactic:
letI := hasShiftMk C A h
lemma ShiftMkCore.shiftFunctorAdd_eq (h : ShiftMkCore C A) (a b : A) :
    letI := hasShiftMk C A h;
    shiftFunctorAdd C a b = h.add a b := by
  letI := hasShiftMk C A h
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
a b : A
this : HasShift C A := hasShiftMk C A h
⊢ shiftFunctorAdd C a b = add h a b

Next tactic:
change (shiftFunctorAdd C a b).symm.symm = (h.add a b).symm.symm
lemma ShiftMkCore.shiftFunctorAdd_eq (h : ShiftMkCore C A) (a b : A) :
    letI := hasShiftMk C A h;
    shiftFunctorAdd C a b = h.add a b := by
  letI := hasShiftMk C A h
  change (shiftFunctorAdd C a b).symm.symm = (h.add a b).symm.symm
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
a b : A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorAdd C a b).symm.symm = (add h a b).symm.symm

Next tactic:
congr 1
lemma ShiftMkCore.shiftFunctorAdd_eq (h : ShiftMkCore C A) (a b : A) :
    letI := hasShiftMk C A h;
    shiftFunctorAdd C a b = h.add a b := by
  letI := hasShiftMk C A h
  change (shiftFunctorAdd C a b).symm.symm = (h.add a b).symm.symm
  congr 1
  

Proof state:
case e_I
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
a b : A
this : HasShift C A := hasShiftMk C A h
⊢ (shiftFunctorAdd C a b).symm = (add h a b).symm

Next tactic:
ext
lemma ShiftMkCore.shiftFunctorAdd_eq (h : ShiftMkCore C A) (a b : A) :
    letI := hasShiftMk C A h;
    shiftFunctorAdd C a b = h.add a b := by
  letI := hasShiftMk C A h
  change (shiftFunctorAdd C a b).symm.symm = (h.add a b).symm.symm
  congr 1
  ext
  

Proof state:
case e_I.w.w.h
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
h : ShiftMkCore C A
a b : A
this : HasShift C A := hasShiftMk C A h
x✝ : C
⊢ (shiftFunctorAdd C a b).symm.hom.app x✝ = (add h a b).symm.hom.app x✝

Next tactic:
rfl
lemma shiftFunctorAdd'_zero_add (a : A) :
    shiftFunctorAdd' C 0 a a (zero_add a) = (Functor.leftUnitor _).symm ≪≫
    isoWhiskerRight (shiftFunctorZero C A).symm (shiftFunctor C a) := by
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
⊢ shiftFunctorAdd' C 0 a a (_ : 0 + a = a) =
    (Functor.leftUnitor (shiftFunctor C a)).symm ≪≫ isoWhiskerRight (shiftFunctorZero C A).symm (shiftFunctor C a)

Next tactic:
ext X
lemma shiftFunctorAdd'_zero_add (a : A) :
    shiftFunctorAdd' C 0 a a (zero_add a) = (Functor.leftUnitor _).symm ≪≫
    isoWhiskerRight (shiftFunctorZero C A).symm (shiftFunctor C a) := by
  ext X
  

Proof state:
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
X : C
⊢ (shiftFunctorAdd' C 0 a a (_ : 0 + a = a)).hom.app X =
    ((Functor.leftUnitor (shiftFunctor C a)).symm ≪≫
            isoWhiskerRight (shiftFunctorZero C A).symm (shiftFunctor C a)).hom.app
      X

Next tactic:
dsimp [shiftFunctorAdd', shiftFunctorZero, shiftFunctor]
lemma shiftFunctorAdd'_zero_add (a : A) :
    shiftFunctorAdd' C 0 a a (zero_add a) = (Functor.leftUnitor _).symm ≪≫
    isoWhiskerRight (shiftFunctorZero C A).symm (shiftFunctor C a) := by
  ext X
  dsimp [shiftFunctorAdd', shiftFunctorZero, shiftFunctor]
  

Proof state:
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
X : C
⊢ (eqToHom (_ : shiftFunctor C a = shiftFunctor C (0 + a))).app X ≫ (shiftFunctorAdd C 0 a).hom.app X =
    𝟙 (((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj { as := a }).obj X) ≫
      ((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj { as := a }).map
        ((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.ε.app X)

Next tactic:
simp only [eqToHom_app, obj_ε_app, Discrete.addMonoidal_leftUnitor, eqToIso.inv,
    eqToHom_map, Category.id_comp]
lemma shiftFunctorAdd'_zero_add (a : A) :
    shiftFunctorAdd' C 0 a a (zero_add a) = (Functor.leftUnitor _).symm ≪≫
    isoWhiskerRight (shiftFunctorZero C A).symm (shiftFunctor C a) := by
  ext X
  dsimp [shiftFunctorAdd', shiftFunctorZero, shiftFunctor]
  simp only [eqToHom_app, obj_ε_app, Discrete.addMonoidal_leftUnitor, eqToIso.inv,
    eqToHom_map, Category.id_comp]
  

Proof state:
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
X : C
⊢ eqToHom
        (_ :
          ((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj { as := a }).obj X =
            ((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj { as := 0 + a }).obj X) ≫
      (shiftFunctorAdd C 0 a).hom.app X =
    eqToHom
        (_ :
          ((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj { as := a }).obj X =
            ((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj
                  (MonoidalCategory.tensorObj (𝟙_ (Discrete A)) { as := a })).obj
              X) ≫
      (MonoidalFunctor.μIso (shiftMonoidalFunctor C A) (𝟙_ (Discrete A)) { as := a }).inv.app X

Next tactic:
rfl
lemma shiftFunctorAdd'_add_zero (a : A) :
    shiftFunctorAdd' C a 0 a (add_zero a) = (Functor.rightUnitor _).symm ≪≫
    isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm := by
  

Proof state:
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
⊢ shiftFunctorAdd' C a 0 a (_ : a + 0 = a) =
    (Functor.rightUnitor (shiftFunctor C a)).symm ≪≫ isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm

Next tactic:
ext
lemma shiftFunctorAdd'_add_zero (a : A) :
    shiftFunctorAdd' C a 0 a (add_zero a) = (Functor.rightUnitor _).symm ≪≫
    isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm := by
  ext
  

Proof state:
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
x✝ : C
⊢ (shiftFunctorAdd' C a 0 a (_ : a + 0 = a)).hom.app x✝ =
    ((Functor.rightUnitor (shiftFunctor C a)).symm ≪≫
            isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm).hom.app
      x✝

Next tactic:
dsimp [shiftFunctorAdd', shiftFunctorZero, shiftFunctor]
lemma shiftFunctorAdd'_add_zero (a : A) :
    shiftFunctorAdd' C a 0 a (add_zero a) = (Functor.rightUnitor _).symm ≪≫
    isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm := by
  ext
  dsimp [shiftFunctorAdd', shiftFunctorZero, shiftFunctor]
  

Proof state:
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
x✝ : C
⊢ (eqToHom (_ : shiftFunctor C a = shiftFunctor C (a + 0))).app x✝ ≫ (shiftFunctorAdd C a 0).hom.app x✝ =
    𝟙 (((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj { as := a }).obj x✝) ≫
      (shiftMonoidalFunctor C A).toLaxMonoidalFunctor.ε.app
        (((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj { as := a }).obj x✝)

Next tactic:
simp only [eqToHom_app, ε_app_obj, Discrete.addMonoidal_rightUnitor, eqToIso.inv,
    eqToHom_map, Category.id_comp]
lemma shiftFunctorAdd'_add_zero (a : A) :
    shiftFunctorAdd' C a 0 a (add_zero a) = (Functor.rightUnitor _).symm ≪≫
    isoWhiskerLeft (shiftFunctor C a) (shiftFunctorZero C A).symm := by
  ext
  dsimp [shiftFunctorAdd', shiftFunctorZero, shiftFunctor]
  simp only [eqToHom_app, ε_app_obj, Discrete.addMonoidal_rightUnitor, eqToIso.inv,
    eqToHom_map, Category.id_comp]
  

Proof state:
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
x✝ : C
⊢ eqToHom
        (_ :
          ((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj { as := a }).obj x✝ =
            ((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj { as := a + 0 }).obj x✝) ≫
      (shiftFunctorAdd C a 0).hom.app x✝ =
    eqToHom
        (_ :
          ((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj { as := a }).obj x✝ =
            ((shiftMonoidalFunctor C A).toLaxMonoidalFunctor.toFunctor.obj
                  (MonoidalCategory.tensorObj { as := a } (𝟙_ (Discrete A)))).obj
              x✝) ≫
      (MonoidalFunctor.μIso (shiftMonoidalFunctor C A) { as := a } (𝟙_ (Discrete A))).inv.app x✝

Next tactic:
rfl
lemma shiftFunctorAdd'_assoc (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₁₂₃ (by 

Proof state:
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₁₂₃

Next tactic:
rw [← h₁₂, h₁₂₃]
lemma shiftFunctorAdd'_assoc (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₁₂₃ (by rw [← h₁₂, h₁₂₃]) ≪≫
      isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂) _ ≪≫ Functor.associator _ _ _ =
    shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ (by 

Proof state:
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₁₂₃

Next tactic:
rw [← h₂₃, ← add_assoc, h₁₂₃]
lemma shiftFunctorAdd'_assoc (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₁₂₃ (by rw [← h₁₂, h₁₂₃]) ≪≫
      isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂) _ ≪≫ Functor.associator _ _ _ =
    shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ (by rw [← h₂₃, ← add_assoc, h₁₂₃]) ≪≫
      isoWhiskerLeft _ (shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃) := by
  

Proof state:
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₁₂₃ (_ : a₁₂ + a₃ = a₁₂₃) ≪≫
      isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂) (shiftFunctor C a₃) ≪≫
        Functor.associator (shiftFunctor C a₁) (shiftFunctor C a₂) (shiftFunctor C a₃) =
    shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ (_ : a₁ + a₂₃ = a₁₂₃) ≪≫
      isoWhiskerLeft (shiftFunctor C a₁) (shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃)

Next tactic:
subst h₁₂ h₂₃ h₁₂₃
lemma shiftFunctorAdd'_assoc (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₁₂₃ (by rw [← h₁₂, h₁₂₃]) ≪≫
      isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂) _ ≪≫ Functor.associator _ _ _ =
    shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ (by rw [← h₂₃, ← add_assoc, h₁₂₃]) ≪≫
      isoWhiskerLeft _ (shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃) := by
  subst h₁₂ h₂₃ h₁₂₃
  

Proof state:
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₃) (_ : a₁ + a₂ + a₃ = a₁ + a₂ + a₃) ≪≫
      isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ (a₁ + a₂) (_ : a₁ + a₂ = a₁ + a₂)) (shiftFunctor C a₃) ≪≫
        Functor.associator (shiftFunctor C a₁) (shiftFunctor C a₂) (shiftFunctor C a₃) =
    shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) (_ : a₁ + (a₂ + a₃) = a₁ + a₂ + a₃) ≪≫
      isoWhiskerLeft (shiftFunctor C a₁) (shiftFunctorAdd' C a₂ a₃ (a₂ + a₃) (_ : a₂ + a₃ = a₂ + a₃))

Next tactic:
ext X
lemma shiftFunctorAdd'_assoc (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₁₂₃ (by rw [← h₁₂, h₁₂₃]) ≪≫
      isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ a₁₂ h₁₂) _ ≪≫ Functor.associator _ _ _ =
    shiftFunctorAdd' C a₁ a₂₃ a₁₂₃ (by rw [← h₂₃, ← add_assoc, h₁₂₃]) ≪≫
      isoWhiskerLeft _ (shiftFunctorAdd' C a₂ a₃ a₂₃ h₂₃) := by
  subst h₁₂ h₂₃ h₁₂₃
  ext X
  

Proof state:
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₃) (_ : a₁ + a₂ + a₃ = a₁ + a₂ + a₃) ≪≫
            isoWhiskerRight (shiftFunctorAdd' C a₁ a₂ (a₁ + a₂) (_ : a₁ + a₂ = a₁ + a₂)) (shiftFunctor C a₃) ≪≫
              Functor.associator (shiftFunctor C a₁) (shiftFunctor C a₂) (shiftFunctor C a₃)).hom.app
      X =
    (shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) (_ : a₁ + (a₂ + a₃) = a₁ + a₂ + a₃) ≪≫
            isoWhiskerLeft (shiftFunctor C a₁) (shiftFunctorAdd' C a₂ a₃ (a₂ + a₃) (_ : a₂ + a₃ = a₂ + a₃))).hom.app
      X

Next tactic:
dsimp