l3lab/ntp-mathlib huggingface dataset:
/-- The shift functor on `DifferentialObject S C`. -/
@[simps]
def shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C where
  obj X :=
    { obj := X.obj⟦n⟧
      d := X.d⟦n⟧' ≫ (shiftComm _ _ _).hom
      d_squared := by
        rw [Functor.map_comp, Category.assoc, shiftComm_hom_comp_assoc, ← Functor.map_comp_assoc,
          X.d_squared, Functor.map_zero, zero_comp] }
  map f :=
    { f := f.f⟦n⟧'
      comm := by
        dsimp
        erw [Category.assoc, shiftComm_hom_comp, ← Functor.map_comp_assoc, f.comm,
          Functor.map_comp_assoc]
        rfl }
  map_id X := by ext1; dsimp; rw [Functor.map_id]
  map_comp f g := by ext1; 

Proof state:
case w
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
n : S
X✝ Y✝ Z✝ : DifferentialObject S C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ autoParam
    (({
              obj := fun X =>
                mk ((CategoryTheory.shiftFunctor C n).obj X.obj)
                  ((CategoryTheory.shiftFunctor C n).map X.d ≫ (shiftComm X.obj 1 n).hom),
              map := fun {X Y} f => Hom.mk ((CategoryTheory.shiftFunctor C n).map f.f) }.map
          (f ≫ g)).f =
      ({
                obj := fun X =>
                  mk ((CategoryTheory.shiftFunctor C n).obj X.obj)
                    ((CategoryTheory.shiftFunctor C n).map X.d ≫ (shiftComm X.obj 1 n).hom),
                map := fun {X Y} f => Hom.mk ((CategoryTheory.shiftFunctor C n).map f.f) }.map
            f ≫
          {
                obj := fun X =>
                  mk ((CategoryTheory.shiftFunctor C n).obj X.obj)
                    ((CategoryTheory.shiftFunctor C n).map X.d ≫ (shiftComm X.obj 1 n).hom),
                map := fun {X Y} f => Hom.mk ((CategoryTheory.shiftFunctor C n).map f.f) }.map
            g).f)
    _auto✝

Next tactic:
dsimp
/-- The shift functor on `DifferentialObject S C`. -/
@[simps]
def shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C where
  obj X :=
    { obj := X.obj⟦n⟧
      d := X.d⟦n⟧' ≫ (shiftComm _ _ _).hom
      d_squared := by
        rw [Functor.map_comp, Category.assoc, shiftComm_hom_comp_assoc, ← Functor.map_comp_assoc,
          X.d_squared, Functor.map_zero, zero_comp] }
  map f :=
    { f := f.f⟦n⟧'
      comm := by
        dsimp
        erw [Category.assoc, shiftComm_hom_comp, ← Functor.map_comp_assoc, f.comm,
          Functor.map_comp_assoc]
        rfl }
  map_id X := by ext1; dsimp; rw [Functor.map_id]
  map_comp f g := by ext1; dsimp; 

Proof state:
case w
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
n : S
X✝ Y✝ Z✝ : DifferentialObject S C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ autoParam
    ((CategoryTheory.shiftFunctor C n).map (f.f ≫ g.f) =
      (CategoryTheory.shiftFunctor C n).map f.f ≫ (CategoryTheory.shiftFunctor C n).map g.f)
    _auto✝

Next tactic:
rw [Functor.map_comp]
/-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
  

Proof state:
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m n : S
⊢ shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n

Next tactic:
refine' NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) _) (fun f => _)
/-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
  refine' NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) _) (fun f => _)
  · 

Proof state:
case refine'_1
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m n : S
X : DifferentialObject S C
⊢ ((shiftFunctor C (m + n)).obj X).d ≫ (CategoryTheory.shiftFunctor C 1).map (shiftAdd X.obj m n).hom =
    (shiftAdd X.obj m n).hom ≫ ((shiftFunctor C m ⋙ shiftFunctor C n).obj X).d

Next tactic:
dsimp
/-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
  refine' NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) _) (fun f => _)
  · dsimp
    

Proof state:
case refine'_1
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m n : S
X : DifferentialObject S C
⊢ ((CategoryTheory.shiftFunctor C (m + n)).map X.d ≫ (shiftFunctorComm C 1 (m + n)).hom.app X.obj) ≫
      (CategoryTheory.shiftFunctor C 1).map ((CategoryTheory.shiftFunctorAdd C m n).hom.app X.obj) =
    (CategoryTheory.shiftFunctorAdd C m n).hom.app X.obj ≫
      (CategoryTheory.shiftFunctor C n).map
          ((CategoryTheory.shiftFunctor C m).map X.d ≫ (shiftFunctorComm C 1 m).hom.app X.obj) ≫
        (shiftFunctorComm C 1 n).hom.app ((CategoryTheory.shiftFunctor C m).obj X.obj)

Next tactic:
rw [← cancel_epi ((shiftFunctorAdd C m n).inv.app X.obj)]
/-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
  refine' NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) _) (fun f => _)
  · dsimp
    rw [← cancel_epi ((shiftFunctorAdd C m n).inv.app X.obj)]
    

Proof state:
case refine'_1
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m n : S
X : DifferentialObject S C
⊢ (CategoryTheory.shiftFunctorAdd C m n).inv.app X.obj ≫
      ((CategoryTheory.shiftFunctor C (m + n)).map X.d ≫ (shiftFunctorComm C 1 (m + n)).hom.app X.obj) ≫
        (CategoryTheory.shiftFunctor C 1).map ((CategoryTheory.shiftFunctorAdd C m n).hom.app X.obj) =
    (CategoryTheory.shiftFunctorAdd C m n).inv.app X.obj ≫
      (CategoryTheory.shiftFunctorAdd C m n).hom.app X.obj ≫
        (CategoryTheory.shiftFunctor C n).map
            ((CategoryTheory.shiftFunctor C m).map X.d ≫ (shiftFunctorComm C 1 m).hom.app X.obj) ≫
          (shiftFunctorComm C 1 n).hom.app ((CategoryTheory.shiftFunctor C m).obj X.obj)

Next tactic:
simp only [Category.assoc, Iso.inv_hom_id_app_assoc]
/-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
  refine' NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) _) (fun f => _)
  · dsimp
    rw [← cancel_epi ((shiftFunctorAdd C m n).inv.app X.obj)]
    simp only [Category.assoc, Iso.inv_hom_id_app_assoc]
    

Proof state:
case refine'_1
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m n : S
X : DifferentialObject S C
⊢ (CategoryTheory.shiftFunctorAdd C m n).inv.app X.obj ≫
      (CategoryTheory.shiftFunctor C (m + n)).map X.d ≫
        (shiftFunctorComm C 1 (m + n)).hom.app X.obj ≫
          (CategoryTheory.shiftFunctor C 1).map ((CategoryTheory.shiftFunctorAdd C m n).hom.app X.obj) =
    (CategoryTheory.shiftFunctor C n).map
        ((CategoryTheory.shiftFunctor C m).map X.d ≫ (shiftFunctorComm C 1 m).hom.app X.obj) ≫
      (shiftFunctorComm C 1 n).hom.app ((CategoryTheory.shiftFunctor C m).obj X.obj)

Next tactic:
erw [← NatTrans.naturality_assoc]
/-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
  refine' NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) _) (fun f => _)
  · dsimp
    rw [← cancel_epi ((shiftFunctorAdd C m n).inv.app X.obj)]
    simp only [Category.assoc, Iso.inv_hom_id_app_assoc]
    erw [← NatTrans.naturality_assoc]
    

Proof state:
case refine'_1
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m n : S
X : DifferentialObject S C
⊢ (CategoryTheory.shiftFunctor C m ⋙ CategoryTheory.shiftFunctor C n).map X.d ≫
      (CategoryTheory.shiftFunctorAdd C m n).inv.app ((CategoryTheory.shiftFunctor C 1).obj X.obj) ≫
        (shiftFunctorComm C 1 (m + n)).hom.app X.obj ≫
          (CategoryTheory.shiftFunctor C 1).map ((CategoryTheory.shiftFunctorAdd C m n).hom.app X.obj) =
    (CategoryTheory.shiftFunctor C n).map
        ((CategoryTheory.shiftFunctor C m).map X.d ≫ (shiftFunctorComm C 1 m).hom.app X.obj) ≫
      (shiftFunctorComm C 1 n).hom.app ((CategoryTheory.shiftFunctor C m).obj X.obj)

Next tactic:
dsimp
/-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
  refine' NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) _) (fun f => _)
  · dsimp
    rw [← cancel_epi ((shiftFunctorAdd C m n).inv.app X.obj)]
    simp only [Category.assoc, Iso.inv_hom_id_app_assoc]
    erw [← NatTrans.naturality_assoc]
    dsimp
    

Proof state:
case refine'_1
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m n : S
X : DifferentialObject S C
⊢ (CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctor C m).map X.d) ≫
      (CategoryTheory.shiftFunctorAdd C m n).inv.app ((CategoryTheory.shiftFunctor C 1).obj X.obj) ≫
        (shiftFunctorComm C 1 (m + n)).hom.app X.obj ≫
          (CategoryTheory.shiftFunctor C 1).map ((CategoryTheory.shiftFunctorAdd C m n).hom.app X.obj) =
    (CategoryTheory.shiftFunctor C n).map
        ((CategoryTheory.shiftFunctor C m).map X.d ≫ (shiftFunctorComm C 1 m).hom.app X.obj) ≫
      (shiftFunctorComm C 1 n).hom.app ((CategoryTheory.shiftFunctor C m).obj X.obj)

Next tactic:
simp only [Functor.map_comp, Category.assoc,
      shiftFunctorComm_hom_app_comp_shift_shiftFunctorAdd_hom_app 1 m n X.obj,
      Iso.inv_hom_id_app_assoc]
/-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
  refine' NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) _) (fun f => _)
  · dsimp
    rw [← cancel_epi ((shiftFunctorAdd C m n).inv.app X.obj)]
    simp only [Category.assoc, Iso.inv_hom_id_app_assoc]
    erw [← NatTrans.naturality_assoc]
    dsimp
    simp only [Functor.map_comp, Category.assoc,
      shiftFunctorComm_hom_app_comp_shift_shiftFunctorAdd_hom_app 1 m n X.obj,
      Iso.inv_hom_id_app_assoc]
  · 

Proof state:
case refine'_2
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m n : S
X✝ Y✝ : DifferentialObject S C
f : X✝ ⟶ Y✝
⊢ (shiftFunctor C (m + n)).map f ≫
      ((fun X =>
            mkIso (shiftAdd X.obj m n)
              (_ :
                ((shiftFunctor C (m + n)).obj X).d ≫ (CategoryTheory.shiftFunctor C 1).map (shiftAdd X.obj m n).hom =
                  (shiftAdd X.obj m n).hom ≫ ((shiftFunctor C m ⋙ shiftFunctor C n).obj X).d))
          Y✝).hom =
    ((fun X =>
            mkIso (shiftAdd X.obj m n)
              (_ :
                ((shiftFunctor C (m + n)).obj X).d ≫ (CategoryTheory.shiftFunctor C 1).map (shiftAdd X.obj m n).hom =
                  (shiftAdd X.obj m n).hom ≫ ((shiftFunctor C m ⋙ shiftFunctor C n).obj X).d))
          X✝).hom ≫
      (shiftFunctor C m ⋙ shiftFunctor C n).map f

Next tactic:
ext
/-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
  refine' NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) _) (fun f => _)
  · dsimp
    rw [← cancel_epi ((shiftFunctorAdd C m n).inv.app X.obj)]
    simp only [Category.assoc, Iso.inv_hom_id_app_assoc]
    erw [← NatTrans.naturality_assoc]
    dsimp
    simp only [Functor.map_comp, Category.assoc,
      shiftFunctorComm_hom_app_comp_shift_shiftFunctorAdd_hom_app 1 m n X.obj,
      Iso.inv_hom_id_app_assoc]
  · ext; 

Proof state:
case refine'_2.w
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m n : S
X✝ Y✝ : DifferentialObject S C
f : X✝ ⟶ Y✝
⊢ autoParam
    (((shiftFunctor C (m + n)).map f ≫
          ((fun X =>
                mkIso (shiftAdd X.obj m n)
                  (_ :
                    ((shiftFunctor C (m + n)).obj X).d ≫
                        (CategoryTheory.shiftFunctor C 1).map (shiftAdd X.obj m n).hom =
                      (shiftAdd X.obj m n).hom ≫ ((shiftFunctor C m ⋙ shiftFunctor C n).obj X).d))
              Y✝).hom).f =
      (((fun X =>
                mkIso (shiftAdd X.obj m n)
                  (_ :
                    ((shiftFunctor C (m + n)).obj X).d ≫
                        (CategoryTheory.shiftFunctor C 1).map (shiftAdd X.obj m n).hom =
                      (shiftAdd X.obj m n).hom ≫ ((shiftFunctor C m ⋙ shiftFunctor C n).obj X).d))
              X✝).hom ≫
          (shiftFunctor C m ⋙ shiftFunctor C n).map f).f)
    _auto✝

Next tactic:
dsimp
/-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n := by
  refine' NatIso.ofComponents (fun X => mkIso (shiftAdd X.obj _ _) _) (fun f => _)
  · dsimp
    rw [← cancel_epi ((shiftFunctorAdd C m n).inv.app X.obj)]
    simp only [Category.assoc, Iso.inv_hom_id_app_assoc]
    erw [← NatTrans.naturality_assoc]
    dsimp
    simp only [Functor.map_comp, Category.assoc,
      shiftFunctorComm_hom_app_comp_shift_shiftFunctorAdd_hom_app 1 m n X.obj,
      Iso.inv_hom_id_app_assoc]
  · ext; dsimp; 

Proof state:
case refine'_2.w
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m n : S
X✝ Y✝ : DifferentialObject S C
f : X✝ ⟶ Y✝
⊢ autoParam
    ((CategoryTheory.shiftFunctor C (m + n)).map f.f ≫ (CategoryTheory.shiftFunctorAdd C m n).hom.app Y✝.obj =
      (CategoryTheory.shiftFunctorAdd C m n).hom.app X✝.obj ≫
        (CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctor C m).map f.f))
    _auto✝

Next tactic:
exact NatTrans.naturality _ _
/-- The shift by zero is naturally isomorphic to the identity. -/
@[simps!]
def shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) := by
  

Proof state:
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
⊢ shiftFunctor C 0 ≅ 𝟭 (DifferentialObject S C)

Next tactic:
refine' NatIso.ofComponents (fun X => mkIso ((shiftFunctorZero C S).app X.obj) _) (fun f => _)
/-- The shift by zero is naturally isomorphic to the identity. -/
@[simps!]
def shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) := by
  refine' NatIso.ofComponents (fun X => mkIso ((shiftFunctorZero C S).app X.obj) _) (fun f => _)
  · 

Proof state:
case refine'_1
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
X : DifferentialObject S C
⊢ ((shiftFunctor C 0).obj X).d ≫ (CategoryTheory.shiftFunctor C 1).map ((shiftFunctorZero C S).app X.obj).hom =
    ((shiftFunctorZero C S).app X.obj).hom ≫ ((𝟭 (DifferentialObject S C)).obj X).d

Next tactic:
erw [← NatTrans.naturality]
/-- The shift by zero is naturally isomorphic to the identity. -/
@[simps!]
def shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) := by
  refine' NatIso.ofComponents (fun X => mkIso ((shiftFunctorZero C S).app X.obj) _) (fun f => _)
  · erw [← NatTrans.naturality]
    

Proof state:
case refine'_1
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
X : DifferentialObject S C
⊢ ((shiftFunctor C 0).obj X).d ≫ (CategoryTheory.shiftFunctor C 1).map ((shiftFunctorZero C S).app X.obj).hom =
    (CategoryTheory.shiftFunctor C 0).map ((𝟭 (DifferentialObject S C)).obj X).2 ≫
      (shiftFunctorZero C S).hom.app ((CategoryTheory.shiftFunctor C 1).obj ((𝟭 (DifferentialObject S C)).obj X).1)

Next tactic:
dsimp
/-- The shift by zero is naturally isomorphic to the identity. -/
@[simps!]
def shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) := by
  refine' NatIso.ofComponents (fun X => mkIso ((shiftFunctorZero C S).app X.obj) _) (fun f => _)
  · erw [← NatTrans.naturality]
    dsimp
    

Proof state:
case refine'_1
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
X : DifferentialObject S C
⊢ ((CategoryTheory.shiftFunctor C 0).map X.d ≫ (shiftFunctorComm C 1 0).hom.app X.obj) ≫
      (CategoryTheory.shiftFunctor C 1).map ((shiftFunctorZero C S).hom.app X.obj) =
    (CategoryTheory.shiftFunctor C 0).map X.2 ≫
      (shiftFunctorZero C S).hom.app ((CategoryTheory.shiftFunctor C 1).obj X.1)

Next tactic:
simp only [shiftFunctorZero_hom_app_shift, Category.assoc]
/-- The shift by zero is naturally isomorphic to the identity. -/
@[simps!]
def shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) := by
  refine' NatIso.ofComponents (fun X => mkIso ((shiftFunctorZero C S).app X.obj) _) (fun f => _)
  · erw [← NatTrans.naturality]
    dsimp
    simp only [shiftFunctorZero_hom_app_shift, Category.assoc]
  · 

Proof state:
case refine'_2
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
X✝ Y✝ : DifferentialObject S C
f : X✝ ⟶ Y✝
⊢ (shiftFunctor C 0).map f ≫
      ((fun X =>
            mkIso ((shiftFunctorZero C S).app X.obj)
              (_ :
                ((shiftFunctor C 0).obj X).d ≫
                    (CategoryTheory.shiftFunctor C 1).map ((shiftFunctorZero C S).app X.obj).hom =
                  ((shiftFunctorZero C S).app X.obj).hom ≫ ((𝟭 (DifferentialObject S C)).obj X).d))
          Y✝).hom =
    ((fun X =>
            mkIso ((shiftFunctorZero C S).app X.obj)
              (_ :
                ((shiftFunctor C 0).obj X).d ≫
                    (CategoryTheory.shiftFunctor C 1).map ((shiftFunctorZero C S).app X.obj).hom =
                  ((shiftFunctorZero C S).app X.obj).hom ≫ ((𝟭 (DifferentialObject S C)).obj X).d))
          X✝).hom ≫
      (𝟭 (DifferentialObject S C)).map f

Next tactic:
aesop_cat
instance : HasShift (DifferentialObject S C) S :=
  hasShiftMk _ _
    { F := shiftFunctor C
      zero := shiftZero C
      add := shiftFunctorAdd C
      assoc_hom_app := fun m₁ m₂ m₃ X => by
        

Proof state:
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m₁ m₂ m₃ : S
X : DifferentialObject S C
⊢ (shiftFunctorAdd C (m₁ + m₂) m₃).hom.app X ≫ (shiftFunctor C m₃).map ((shiftFunctorAdd C m₁ m₂).hom.app X) =
    eqToHom (_ : (shiftFunctor C (m₁ + m₂ + m₃)).obj X = (shiftFunctor C (m₁ + (m₂ + m₃))).obj X) ≫
      (shiftFunctorAdd C m₁ (m₂ + m₃)).hom.app X ≫ (shiftFunctorAdd C m₂ m₃).hom.app ((shiftFunctor C m₁).obj X)

Next tactic:
ext1
instance : HasShift (DifferentialObject S C) S :=
  hasShiftMk _ _
    { F := shiftFunctor C
      zero := shiftZero C
      add := shiftFunctorAdd C
      assoc_hom_app := fun m₁ m₂ m₃ X => by
        ext1
        

Proof state:
case w
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m₁ m₂ m₃ : S
X : DifferentialObject S C
⊢ autoParam
    (((shiftFunctorAdd C (m₁ + m₂) m₃).hom.app X ≫ (shiftFunctor C m₃).map ((shiftFunctorAdd C m₁ m₂).hom.app X)).f =
      (eqToHom (_ : (shiftFunctor C (m₁ + m₂ + m₃)).obj X = (shiftFunctor C (m₁ + (m₂ + m₃))).obj X) ≫
          (shiftFunctorAdd C m₁ (m₂ + m₃)).hom.app X ≫ (shiftFunctorAdd C m₂ m₃).hom.app ((shiftFunctor C m₁).obj X)).f)
    _auto✝

Next tactic:
convert shiftFunctorAdd_assoc_hom_app m₁ m₂ m₃ X.obj
instance : HasShift (DifferentialObject S C) S :=
  hasShiftMk _ _
    { F := shiftFunctor C
      zero := shiftZero C
      add := shiftFunctorAdd C
      assoc_hom_app := fun m₁ m₂ m₃ X => by
        ext1
        convert shiftFunctorAdd_assoc_hom_app m₁ m₂ m₃ X.obj
        

Proof state:
case h.e'_3.h
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m₁ m₂ m₃ : S
X : DifferentialObject S C
e_1✝ :
  (((shiftFunctor C (m₁ + m₂ + m₃)).obj X).obj ⟶
      ((shiftFunctor C m₃).obj ((shiftFunctor C m₁ ⋙ shiftFunctor C m₂).obj X)).obj) =
    ((CategoryTheory.shiftFunctor C (m₁ + m₂ + m₃)).obj X.obj ⟶
      (CategoryTheory.shiftFunctor C m₃).obj
        ((CategoryTheory.shiftFunctor C m₁ ⋙ CategoryTheory.shiftFunctor C m₂).obj X.obj))
⊢ (eqToHom (_ : (shiftFunctor C (m₁ + m₂ + m₃)).obj X = (shiftFunctor C (m₁ + (m₂ + m₃))).obj X) ≫
        (shiftFunctorAdd C m₁ (m₂ + m₃)).hom.app X ≫ (shiftFunctorAdd C m₂ m₃).hom.app ((shiftFunctor C m₁).obj X)).f =
    (shiftFunctorAdd' C m₁ (m₂ + m₃) (m₁ + m₂ + m₃) (_ : m₁ + (m₂ + m₃) = m₁ + m₂ + m₃)).hom.app X.obj ≫
      (CategoryTheory.shiftFunctorAdd C m₂ m₃).hom.app ((CategoryTheory.shiftFunctor C m₁).obj X.obj)

Next tactic:
dsimp [shiftFunctorAdd']
instance : HasShift (DifferentialObject S C) S :=
  hasShiftMk _ _
    { F := shiftFunctor C
      zero := shiftZero C
      add := shiftFunctorAdd C
      assoc_hom_app := fun m₁ m₂ m₃ X => by
        ext1
        convert shiftFunctorAdd_assoc_hom_app m₁ m₂ m₃ X.obj
        dsimp [shiftFunctorAdd']
        

Proof state:
case h.e'_3.h
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
m₁ m₂ m₃ : S
X : DifferentialObject S C
e_1✝ :
  (((shiftFunctor C (m₁ + m₂ + m₃)).obj X).obj ⟶
      ((shiftFunctor C m₃).obj ((shiftFunctor C m₁ ⋙ shiftFunctor C m₂).obj X)).obj) =
    ((CategoryTheory.shiftFunctor C (m₁ + m₂ + m₃)).obj X.obj ⟶
      (CategoryTheory.shiftFunctor C m₃).obj
        ((CategoryTheory.shiftFunctor C m₁ ⋙ CategoryTheory.shiftFunctor C m₂).obj X.obj))
⊢ (eqToHom (_ : (shiftFunctor C (m₁ + m₂ + m₃)).obj X = (shiftFunctor C (m₁ + (m₂ + m₃))).obj X)).f ≫
      (CategoryTheory.shiftFunctorAdd C m₁ (m₂ + m₃)).hom.app X.obj ≫
        (CategoryTheory.shiftFunctorAdd C m₂ m₃).hom.app ((CategoryTheory.shiftFunctor C m₁).obj X.obj) =
    ((eqToHom (_ : CategoryTheory.shiftFunctor C (m₁ + m₂ + m₃) = CategoryTheory.shiftFunctor C (m₁ + (m₂ + m₃)))).app
          X.obj ≫
        (CategoryTheory.shiftFunctorAdd C m₁ (m₂ + m₃)).hom.app X.obj) ≫
      (CategoryTheory.shiftFunctorAdd C m₂ m₃).hom.app ((CategoryTheory.shiftFunctor C m₁).obj X.obj)

Next tactic:
simp
instance : HasShift (DifferentialObject S C) S :=
  hasShiftMk _ _
    { F := shiftFunctor C
      zero := shiftZero C
      add := shiftFunctorAdd C
      assoc_hom_app := fun m₁ m₂ m₃ X => by
        ext1
        convert shiftFunctorAdd_assoc_hom_app m₁ m₂ m₃ X.obj
        dsimp [shiftFunctorAdd']
        simp
      zero_add_hom_app := fun n X => by
        

Proof state:
S : Type u_1
inst✝³ : AddCommGroupWithOne S
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasShift C S
n : S
X : DifferentialObject S C
⊢ (shiftFunctorAdd C 0 n).hom.app X =
    eqToHom (_ : (shiftFunctor C (0 + n)).obj X = (shiftFunctor C n).obj ((𝟭 (DifferentialObject S C)).obj X)) ≫
      (shiftFunctor C n).map ((shiftZero C).inv.app X)

Next tactic:
ext1