l3lab/ntp-mathlib huggingface dataset:
lemma shiftFunctorZero_hom_app_f (K : CochainComplex C ℤ) (n : ℤ) :
    ((CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ).hom.app K).f n =
      (K.XIsoOfEq (by dsimp; rw [add_zero])).hom := by
  have : IsIso (((shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K).f n) := by
    

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
n : ℤ
⊢ IsIso (Hom.f ((shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K) n)

Next tactic:
rw [shiftFunctorZero_inv_app_f]
lemma shiftFunctorZero_hom_app_f (K : CochainComplex C ℤ) (n : ℤ) :
    ((CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ).hom.app K).f n =
      (K.XIsoOfEq (by dsimp; rw [add_zero])).hom := by
  have : IsIso (((shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K).f n) := by
    rw [shiftFunctorZero_inv_app_f]
    

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
n : ℤ
⊢ IsIso (XIsoOfEq K (_ : n = n + { as := 0 }.as)).hom

Next tactic:
infer_instance
lemma shiftFunctorZero_hom_app_f (K : CochainComplex C ℤ) (n : ℤ) :
    ((CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ).hom.app K).f n =
      (K.XIsoOfEq (by dsimp; rw [add_zero])).hom := by
  have : IsIso (((shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K).f n) := by
    rw [shiftFunctorZero_inv_app_f]
    infer_instance
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
n : ℤ
this : IsIso (Hom.f ((shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K) n)
⊢ Hom.f ((shiftFunctorZero (CochainComplex C ℤ) ℤ).hom.app K) n = (XIsoOfEq K (_ : n + { as := 0 }.as = n)).hom

Next tactic:
rw [← cancel_mono (((shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K).f n), ← comp_f,
    Iso.hom_inv_id_app, id_f, shiftFunctorZero_inv_app_f]
lemma shiftFunctorZero_hom_app_f (K : CochainComplex C ℤ) (n : ℤ) :
    ((CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ).hom.app K).f n =
      (K.XIsoOfEq (by dsimp; rw [add_zero])).hom := by
  have : IsIso (((shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K).f n) := by
    rw [shiftFunctorZero_inv_app_f]
    infer_instance
  rw [← cancel_mono (((shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K).f n), ← comp_f,
    Iso.hom_inv_id_app, id_f, shiftFunctorZero_inv_app_f]
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
n : ℤ
this : IsIso (Hom.f ((shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K) n)
⊢ 𝟙 (X ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) 0).obj K) n) =
    (XIsoOfEq K (_ : n + { as := 0 }.as = n)).hom ≫ (XIsoOfEq K (_ : n = n + { as := 0 }.as)).hom

Next tactic:
simp only [XIsoOfEq, eqToIso.hom, eqToHom_trans, eqToHom_refl]
lemma XIsoOfEq_shift (K : CochainComplex C ℤ) (n : ℤ) {p q : ℤ} (hpq : p = q) :
    (K⟦n⟧).XIsoOfEq hpq = K.XIsoOfEq (show p + n = q + n by 

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
n p q : ℤ
hpq : p = q
⊢ p + n = q + n

Next tactic:
rw [hpq]
lemma shiftFunctorAdd'_eq (a b c : ℤ) (h : a + b = c) :
    CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b c h =
      shiftFunctorAdd' C a b c h := by
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
a b c : ℤ
h : a + b = c
⊢ CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b c h = shiftFunctorAdd' C a b c h

Next tactic:
ext
lemma shiftFunctorAdd'_eq (a b c : ℤ) (h : a + b = c) :
    CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b c h =
      shiftFunctorAdd' C a b c h := by
  ext
  

Proof state:
case w.w.h.h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
a b c : ℤ
h : a + b = c
x✝ : CochainComplex C ℤ
i✝ : ℤ
⊢ Hom.f ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b c h).hom.app x✝) i✝ =
    Hom.f ((shiftFunctorAdd' C a b c h).hom.app x✝) i✝

Next tactic:
simp only [shiftFunctorAdd'_hom_app_f', XIsoOfEq, eqToIso.hom, shiftFunctorAdd'_hom_app_f]
lemma shiftFunctorAdd_eq (a b : ℤ) :
    CategoryTheory.shiftFunctorAdd (CochainComplex C ℤ) a b = shiftFunctorAdd' C a b _ rfl := by
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
a b : ℤ
⊢ shiftFunctorAdd (CochainComplex C ℤ) a b = shiftFunctorAdd' C a b (a + b) (_ : a + b = a + b)

Next tactic:
rw [← CategoryTheory.shiftFunctorAdd'_eq_shiftFunctorAdd, shiftFunctorAdd'_eq]
lemma shiftFunctorZero_eq :
    CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ = shiftFunctorZero' C 0 rfl := by
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
⊢ shiftFunctorZero (CochainComplex C ℤ) ℤ = shiftFunctorZero' C 0 (_ : 0 = 0)

Next tactic:
ext
lemma shiftFunctorZero_eq :
    CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ = shiftFunctorZero' C 0 rfl := by
  ext
  

Proof state:
case w.w.h.h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
x✝ : CochainComplex C ℤ
i✝ : ℤ
⊢ Hom.f ((shiftFunctorZero (CochainComplex C ℤ) ℤ).hom.app x✝) i✝ =
    Hom.f ((shiftFunctorZero' C 0 (_ : 0 = 0)).hom.app x✝) i✝

Next tactic:
rw [shiftFunctorZero_hom_app_f, shiftFunctorZero'_hom_app_f]
lemma shiftFunctorComm_hom_app_f (K : CochainComplex C ℤ) (a b p : ℤ) :
    ((shiftFunctorComm (CochainComplex C ℤ) a b).hom.app K).f p =
      (K.XIsoOfEq (show p + b + a = p + a + b
        by 

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ p + b + a = p + a + b

Next tactic:
rw [add_assoc, add_comm b, add_assoc]
lemma shiftFunctorComm_hom_app_f (K : CochainComplex C ℤ) (a b p : ℤ) :
    ((shiftFunctorComm (CochainComplex C ℤ) a b).hom.app K).f p =
      (K.XIsoOfEq (show p + b + a = p + a + b
        by rw [add_assoc, add_comm b, add_assoc])).hom := by
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ Hom.f ((shiftFunctorComm (CochainComplex C ℤ) a b).hom.app K) p = (XIsoOfEq K (_ : p + b + a = p + a + b)).hom

Next tactic:
rw [shiftFunctorComm_eq _ _ _ _ rfl]
lemma shiftFunctorComm_hom_app_f (K : CochainComplex C ℤ) (a b p : ℤ) :
    ((shiftFunctorComm (CochainComplex C ℤ) a b).hom.app K).f p =
      (K.XIsoOfEq (show p + b + a = p + a + b
        by rw [add_assoc, add_comm b, add_assoc])).hom := by
  rw [shiftFunctorComm_eq _ _ _ _ rfl]
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ Hom.f
      (((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b (a + b) (_ : a + b = a + b)).symm ≪≫
              CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) b a (a + b) (_ : b + a = a + b)).hom.app
        K)
      p =
    (XIsoOfEq K (_ : p + b + a = p + a + b)).hom

Next tactic:
dsimp
lemma shiftFunctorComm_hom_app_f (K : CochainComplex C ℤ) (a b p : ℤ) :
    ((shiftFunctorComm (CochainComplex C ℤ) a b).hom.app K).f p =
      (K.XIsoOfEq (show p + b + a = p + a + b
        by rw [add_assoc, add_comm b, add_assoc])).hom := by
  rw [shiftFunctorComm_eq _ _ _ _ rfl]
  dsimp
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ Hom.f ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b (a + b) (_ : a + b = a + b)).inv.app K) p ≫
      Hom.f ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) b a (a + b) (_ : b + a = a + b)).hom.app K) p =
    eqToHom (_ : X K (p + b + a) = X K (p + a + b))

Next tactic:
rw [shiftFunctorAdd'_inv_app_f', shiftFunctorAdd'_hom_app_f']
lemma shiftFunctorComm_hom_app_f (K : CochainComplex C ℤ) (a b p : ℤ) :
    ((shiftFunctorComm (CochainComplex C ℤ) a b).hom.app K).f p =
      (K.XIsoOfEq (show p + b + a = p + a + b
        by rw [add_assoc, add_comm b, add_assoc])).hom := by
  rw [shiftFunctorComm_eq _ _ _ _ rfl]
  dsimp
  rw [shiftFunctorAdd'_inv_app_f', shiftFunctorAdd'_hom_app_f']
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b p : ℤ
⊢ (XIsoOfEq K (_ : p + { as := b }.as + { as := a }.as = p + { as := a + b }.as)).hom ≫
      (XIsoOfEq K (_ : p + { as := a + b }.as = p + { as := a }.as + { as := b }.as)).hom =
    eqToHom (_ : X K (p + b + a) = X K (p + a + b))

Next tactic:
simp only [XIsoOfEq, eqToIso.hom, eqToHom_trans]
/-- The commutation with the shift isomorphism for the functor on cochain complexes
induced by an additive functor between preadditive categories. -/
@[simps!]
def mapCochainComplexShiftIso (n : ℤ) :
    shiftFunctor _ n ⋙ F.mapHomologicalComplex (ComplexShape.up ℤ) ≅
      F.mapHomologicalComplex (ComplexShape.up ℤ) ⋙ shiftFunctor _ n :=
  NatIso.ofComponents (fun K => HomologicalComplex.Hom.isoOfComponents (fun _ => Iso.refl _)
    (by 

Proof state:
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
n : ℤ
K : HomologicalComplex C (ComplexShape.up ℤ)
⊢ ∀ (i j : ℤ),
    ComplexShape.Rel (ComplexShape.up ℤ) i j →
      ((fun x =>
                Iso.refl
                  (HomologicalComplex.X
                    ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n ⋙
                          mapHomologicalComplex F (ComplexShape.up ℤ)).obj
                      K)
                    x))
              i).hom ≫
          HomologicalComplex.d
            ((mapHomologicalComplex F (ComplexShape.up ℤ) ⋙
                  shiftFunctor (HomologicalComplex D (ComplexShape.up ℤ)) n).obj
              K)
            i j =
        HomologicalComplex.d
            ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n ⋙
                  mapHomologicalComplex F (ComplexShape.up ℤ)).obj
              K)
            i j ≫
          ((fun x =>
                Iso.refl
                  (HomologicalComplex.X
                    ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n ⋙
                          mapHomologicalComplex F (ComplexShape.up ℤ)).obj
                      K)
                    x))
              j).hom

Next tactic:
aesop_cat
/-- The commutation with the shift isomorphism for the functor on cochain complexes
induced by an additive functor between preadditive categories. -/
@[simps!]
def mapCochainComplexShiftIso (n : ℤ) :
    shiftFunctor _ n ⋙ F.mapHomologicalComplex (ComplexShape.up ℤ) ≅
      F.mapHomologicalComplex (ComplexShape.up ℤ) ⋙ shiftFunctor _ n :=
  NatIso.ofComponents (fun K => HomologicalComplex.Hom.isoOfComponents (fun _ => Iso.refl _)
    (by aesop_cat)) (fun _ => by 

Proof state:
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
n : ℤ
X✝ Y✝ : HomologicalComplex C (ComplexShape.up ℤ)
x✝ : X✝ ⟶ Y✝
⊢ (shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n ⋙ mapHomologicalComplex F (ComplexShape.up ℤ)).map x✝ ≫
      ((fun K =>
            HomologicalComplex.Hom.isoOfComponents fun x =>
              Iso.refl
                (HomologicalComplex.X
                  ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n ⋙
                        mapHomologicalComplex F (ComplexShape.up ℤ)).obj
                    K)
                  x))
          Y✝).hom =
    ((fun K =>
            HomologicalComplex.Hom.isoOfComponents fun x =>
              Iso.refl
                (HomologicalComplex.X
                  ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n ⋙
                        mapHomologicalComplex F (ComplexShape.up ℤ)).obj
                    K)
                  x))
          X✝).hom ≫
      (mapHomologicalComplex F (ComplexShape.up ℤ) ⋙ shiftFunctor (HomologicalComplex D (ComplexShape.up ℤ)) n).map x✝

Next tactic:
ext
/-- The commutation with the shift isomorphism for the functor on cochain complexes
induced by an additive functor between preadditive categories. -/
@[simps!]
def mapCochainComplexShiftIso (n : ℤ) :
    shiftFunctor _ n ⋙ F.mapHomologicalComplex (ComplexShape.up ℤ) ≅
      F.mapHomologicalComplex (ComplexShape.up ℤ) ⋙ shiftFunctor _ n :=
  NatIso.ofComponents (fun K => HomologicalComplex.Hom.isoOfComponents (fun _ => Iso.refl _)
    (by aesop_cat)) (fun _ => by ext; 

Proof state:
case h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
n : ℤ
X✝ Y✝ : HomologicalComplex C (ComplexShape.up ℤ)
x✝ : X✝ ⟶ Y✝
i✝ : ℤ
⊢ HomologicalComplex.Hom.f
      ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n ⋙ mapHomologicalComplex F (ComplexShape.up ℤ)).map
          x✝ ≫
        ((fun K =>
              HomologicalComplex.Hom.isoOfComponents fun x =>
                Iso.refl
                  (HomologicalComplex.X
                    ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n ⋙
                          mapHomologicalComplex F (ComplexShape.up ℤ)).obj
                      K)
                    x))
            Y✝).hom)
      i✝ =
    HomologicalComplex.Hom.f
      (((fun K =>
              HomologicalComplex.Hom.isoOfComponents fun x =>
                Iso.refl
                  (HomologicalComplex.X
                    ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n ⋙
                          mapHomologicalComplex F (ComplexShape.up ℤ)).obj
                      K)
                    x))
            X✝).hom ≫
        (mapHomologicalComplex F (ComplexShape.up ℤ) ⋙ shiftFunctor (HomologicalComplex D (ComplexShape.up ℤ)) n).map
          x✝)
      i✝

Next tactic:
dsimp
/-- The commutation with the shift isomorphism for the functor on cochain complexes
induced by an additive functor between preadditive categories. -/
@[simps!]
def mapCochainComplexShiftIso (n : ℤ) :
    shiftFunctor _ n ⋙ F.mapHomologicalComplex (ComplexShape.up ℤ) ≅
      F.mapHomologicalComplex (ComplexShape.up ℤ) ⋙ shiftFunctor _ n :=
  NatIso.ofComponents (fun K => HomologicalComplex.Hom.isoOfComponents (fun _ => Iso.refl _)
    (by aesop_cat)) (fun _ => by ext; dsimp; 

Proof state:
case h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
n : ℤ
X✝ Y✝ : HomologicalComplex C (ComplexShape.up ℤ)
x✝ : X✝ ⟶ Y✝
i✝ : ℤ
⊢ F.map (HomologicalComplex.Hom.f x✝ (i✝ + n)) ≫
      𝟙 (F.obj (HomologicalComplex.X ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n).obj Y✝) i✝)) =
    𝟙 (F.obj (HomologicalComplex.X ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n).obj X✝) i✝)) ≫
      F.map (HomologicalComplex.Hom.f x✝ (i✝ + n))

Next tactic:
rw [id_comp, comp_id]
instance commShiftMapCochainComplex :
    (F.mapHomologicalComplex (ComplexShape.up ℤ)).CommShift ℤ where
  iso := F.mapCochainComplexShiftIso
  zero := by
    

Proof state:
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
⊢ mapCochainComplexShiftIso F 0 = CommShift.isoZero (mapHomologicalComplex F (ComplexShape.up ℤ)) ℤ

Next tactic:
ext
instance commShiftMapCochainComplex :
    (F.mapHomologicalComplex (ComplexShape.up ℤ)).CommShift ℤ where
  iso := F.mapCochainComplexShiftIso
  zero := by
    ext
    

Proof state:
case w.w.h.h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
x✝ : HomologicalComplex C (ComplexShape.up ℤ)
i✝ : ℤ
⊢ HomologicalComplex.Hom.f ((mapCochainComplexShiftIso F 0).hom.app x✝) i✝ =
    HomologicalComplex.Hom.f ((CommShift.isoZero (mapHomologicalComplex F (ComplexShape.up ℤ)) ℤ).hom.app x✝) i✝

Next tactic:
rw [CommShift.isoZero_hom_app]
instance commShiftMapCochainComplex :
    (F.mapHomologicalComplex (ComplexShape.up ℤ)).CommShift ℤ where
  iso := F.mapCochainComplexShiftIso
  zero := by
    ext
    rw [CommShift.isoZero_hom_app]
    

Proof state:
case w.w.h.h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
x✝ : HomologicalComplex C (ComplexShape.up ℤ)
i✝ : ℤ
⊢ HomologicalComplex.Hom.f ((mapCochainComplexShiftIso F 0).hom.app x✝) i✝ =
    HomologicalComplex.Hom.f
      ((mapHomologicalComplex F (ComplexShape.up ℤ)).map
          ((shiftFunctorZero (HomologicalComplex C (ComplexShape.up ℤ)) ℤ).hom.app x✝) ≫
        (shiftFunctorZero (HomologicalComplex D (ComplexShape.up ℤ)) ℤ).inv.app
          ((mapHomologicalComplex F (ComplexShape.up ℤ)).obj x✝))
      i✝

Next tactic:
dsimp
instance commShiftMapCochainComplex :
    (F.mapHomologicalComplex (ComplexShape.up ℤ)).CommShift ℤ where
  iso := F.mapCochainComplexShiftIso
  zero := by
    ext
    rw [CommShift.isoZero_hom_app]
    dsimp
    

Proof state:
case w.w.h.h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
x✝ : HomologicalComplex C (ComplexShape.up ℤ)
i✝ : ℤ
⊢ 𝟙 (F.obj (HomologicalComplex.X ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) 0).obj x✝) i✝)) =
    F.map (HomologicalComplex.Hom.f ((shiftFunctorZero (HomologicalComplex C (ComplexShape.up ℤ)) ℤ).hom.app x✝) i✝) ≫
      HomologicalComplex.Hom.f
        ((shiftFunctorZero (HomologicalComplex D (ComplexShape.up ℤ)) ℤ).inv.app
          ((mapHomologicalComplex F (ComplexShape.up ℤ)).obj x✝))
        i✝

Next tactic:
simp only [mapCochainComplexShiftIso_hom_app_f, CochainComplex.shiftFunctorZero_inv_app_f,
       CochainComplex.shiftFunctorZero_hom_app_f, HomologicalComplex.XIsoOfEq, eqToIso,
       eqToHom_map, eqToHom_trans, eqToHom_refl]
instance commShiftMapCochainComplex :
    (F.mapHomologicalComplex (ComplexShape.up ℤ)).CommShift ℤ where
  iso := F.mapCochainComplexShiftIso
  zero := by
    ext
    rw [CommShift.isoZero_hom_app]
    dsimp
    simp only [mapCochainComplexShiftIso_hom_app_f, CochainComplex.shiftFunctorZero_inv_app_f,
       CochainComplex.shiftFunctorZero_hom_app_f, HomologicalComplex.XIsoOfEq, eqToIso,
       eqToHom_map, eqToHom_trans, eqToHom_refl]
  add := fun a b => by
    

Proof state:
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
a b : ℤ
⊢ mapCochainComplexShiftIso F (a + b) = CommShift.isoAdd (mapCochainComplexShiftIso F a) (mapCochainComplexShiftIso F b)

Next tactic:
ext
instance commShiftMapCochainComplex :
    (F.mapHomologicalComplex (ComplexShape.up ℤ)).CommShift ℤ where
  iso := F.mapCochainComplexShiftIso
  zero := by
    ext
    rw [CommShift.isoZero_hom_app]
    dsimp
    simp only [mapCochainComplexShiftIso_hom_app_f, CochainComplex.shiftFunctorZero_inv_app_f,
       CochainComplex.shiftFunctorZero_hom_app_f, HomologicalComplex.XIsoOfEq, eqToIso,
       eqToHom_map, eqToHom_trans, eqToHom_refl]
  add := fun a b => by
    ext
    

Proof state:
case w.w.h.h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
a b : ℤ
x✝ : HomologicalComplex C (ComplexShape.up ℤ)
i✝ : ℤ
⊢ HomologicalComplex.Hom.f ((mapCochainComplexShiftIso F (a + b)).hom.app x✝) i✝ =
    HomologicalComplex.Hom.f
      ((CommShift.isoAdd (mapCochainComplexShiftIso F a) (mapCochainComplexShiftIso F b)).hom.app x✝) i✝

Next tactic:
rw [CommShift.isoAdd_hom_app]
instance commShiftMapCochainComplex :
    (F.mapHomologicalComplex (ComplexShape.up ℤ)).CommShift ℤ where
  iso := F.mapCochainComplexShiftIso
  zero := by
    ext
    rw [CommShift.isoZero_hom_app]
    dsimp
    simp only [mapCochainComplexShiftIso_hom_app_f, CochainComplex.shiftFunctorZero_inv_app_f,
       CochainComplex.shiftFunctorZero_hom_app_f, HomologicalComplex.XIsoOfEq, eqToIso,
       eqToHom_map, eqToHom_trans, eqToHom_refl]
  add := fun a b => by
    ext
    rw [CommShift.isoAdd_hom_app]
    

Proof state:
case w.w.h.h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
a b : ℤ
x✝ : HomologicalComplex C (ComplexShape.up ℤ)
i✝ : ℤ
⊢ HomologicalComplex.Hom.f ((mapCochainComplexShiftIso F (a + b)).hom.app x✝) i✝ =
    HomologicalComplex.Hom.f
      ((mapHomologicalComplex F (ComplexShape.up ℤ)).map
          ((shiftFunctorAdd (HomologicalComplex C (ComplexShape.up ℤ)) a b).hom.app x✝) ≫
        (mapCochainComplexShiftIso F b).hom.app ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) a).obj x✝) ≫
          (shiftFunctor (HomologicalComplex D (ComplexShape.up ℤ)) b).map ((mapCochainComplexShiftIso F a).hom.app x✝) ≫
            (shiftFunctorAdd (HomologicalComplex D (ComplexShape.up ℤ)) a b).inv.app
              ((mapHomologicalComplex F (ComplexShape.up ℤ)).obj x✝))
      i✝

Next tactic:
dsimp
instance commShiftMapCochainComplex :
    (F.mapHomologicalComplex (ComplexShape.up ℤ)).CommShift ℤ where
  iso := F.mapCochainComplexShiftIso
  zero := by
    ext
    rw [CommShift.isoZero_hom_app]
    dsimp
    simp only [mapCochainComplexShiftIso_hom_app_f, CochainComplex.shiftFunctorZero_inv_app_f,
       CochainComplex.shiftFunctorZero_hom_app_f, HomologicalComplex.XIsoOfEq, eqToIso,
       eqToHom_map, eqToHom_trans, eqToHom_refl]
  add := fun a b => by
    ext
    rw [CommShift.isoAdd_hom_app]
    dsimp
    

Proof state:
case w.w.h.h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Preadditive C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : Additive F
a b : ℤ
x✝ : HomologicalComplex C (ComplexShape.up ℤ)
i✝ : ℤ
⊢ 𝟙 (F.obj (HomologicalComplex.X ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) (a + b)).obj x✝) i✝)) =
    F.map (HomologicalComplex.Hom.f ((shiftFunctorAdd (HomologicalComplex C (ComplexShape.up ℤ)) a b).hom.app x✝) i✝) ≫
      𝟙
          (F.obj
            (HomologicalComplex.X
              ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) b).obj
                ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) a).obj x✝))
              i✝)) ≫
        𝟙 (F.obj (HomologicalComplex.X ((shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) a).obj x✝) (i✝ + b))) ≫
          HomologicalComplex.Hom.f
            ((shiftFunctorAdd (HomologicalComplex D (ComplexShape.up ℤ)) a b).inv.app
              ((mapHomologicalComplex F (ComplexShape.up ℤ)).obj x✝))
            i✝

Next tactic:
erw [id_comp, id_comp]