l3lab/ntp-mathlib huggingface dataset:
@[reassoc]
lemma mapHomologyIso_hom_naturality [S₁.HasHomology] [S₂.HasHomology]
    [(S₁.map F).HasHomology] [(S₂.map F).HasHomology]
    [F.PreservesLeftHomologyOf S₁] [F.PreservesLeftHomologyOf S₂] :
    @homologyMap _ _ _ (S₁.map F) (S₂.map F) (F.mapShortComplex.map φ) _ _ ≫
      (S₂.mapHomologyIso F).hom = (S₁.mapHomologyIso F).hom ≫ F.map (homologyMap φ) := by
  dsimp only [homologyMap, homologyMap', mapHomologyIso, LeftHomologyData.homologyIso,
    LeftHomologyData.leftHomologyIso, leftHomologyMapIso', leftHomologyIso,
    Iso.symm, Iso.trans, Iso.refl]
  

Proof state:
C : Type u_1
D : Type u_2
inst✝¹¹ : Category.{u_3, u_1} C
inst✝¹⁰ : Category.{u_4, u_2} D
inst✝⁹ : HasZeroMorphisms C
inst✝⁸ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁷ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms F
inst✝⁵ : HasHomology S₁
inst✝⁴ : HasHomology S₂
inst✝³ : HasHomology (map S₁ F)
inst✝² : HasHomology (map S₂ F)
inst✝¹ : Functor.PreservesLeftHomologyOf F S₁
inst✝ : Functor.PreservesLeftHomologyOf F S₂
⊢ leftHomologyMap' ((Functor.mapShortComplex F).map φ) (homologyData (map S₁ F)).left (homologyData (map S₂ F)).left ≫
      leftHomologyMap' (𝟙 (map S₂ F)) (homologyData (map S₂ F)).left (leftHomologyData (map S₂ F)) ≫
        leftHomologyMap' (𝟙 (map S₂ F)) (leftHomologyData (map S₂ F)) (LeftHomologyData.map (homologyData S₂).left F) =
    (leftHomologyMap' (𝟙 (map S₁ F)) (homologyData (map S₁ F)).left (leftHomologyData (map S₁ F)) ≫
        leftHomologyMap' (𝟙 (map S₁ F)) (leftHomologyData (map S₁ F)) (LeftHomologyData.map (homologyData S₁).left F)) ≫
      F.map (leftHomologyMap' φ (homologyData S₁).left (homologyData S₂).left)

Next tactic:
simp only [LeftHomologyData.map_leftHomologyMap', ← leftHomologyMap'_comp, comp_id, id_comp]
@[reassoc]
lemma mapHomologyIso_inv_naturality [S₁.HasHomology] [S₂.HasHomology]
    [(S₁.map F).HasHomology] [(S₂.map F).HasHomology]
    [F.PreservesLeftHomologyOf S₁] [F.PreservesLeftHomologyOf S₂] :
    F.map (homologyMap φ) ≫ (S₂.mapHomologyIso F).inv =
      (S₁.mapHomologyIso F).inv ≫
      @homologyMap _ _ _ (S₁.map F) (S₂.map F) (F.mapShortComplex.map φ) _ _ := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝¹¹ : Category.{u_3, u_1} C
inst✝¹⁰ : Category.{u_4, u_2} D
inst✝⁹ : HasZeroMorphisms C
inst✝⁸ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁷ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms F
inst✝⁵ : HasHomology S₁
inst✝⁴ : HasHomology S₂
inst✝³ : HasHomology (map S₁ F)
inst✝² : HasHomology (map S₂ F)
inst✝¹ : Functor.PreservesLeftHomologyOf F S₁
inst✝ : Functor.PreservesLeftHomologyOf F S₂
⊢ F.map (homologyMap φ) ≫ (mapHomologyIso S₂ F).inv =
    (mapHomologyIso S₁ F).inv ≫ homologyMap ((Functor.mapShortComplex F).map φ)

Next tactic:
rw [← cancel_epi (S₁.mapHomologyIso F).hom, ← mapHomologyIso_hom_naturality_assoc,
    Iso.hom_inv_id, comp_id, Iso.hom_inv_id_assoc]
@[reassoc]
lemma mapHomologyIso'_hom_naturality [S₁.HasHomology] [S₂.HasHomology]
    [(S₁.map F).HasHomology] [(S₂.map F).HasHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    @homologyMap _ _ _ (S₁.map F) (S₂.map F) (F.mapShortComplex.map φ) _ _ ≫
      (S₂.mapHomologyIso' F).hom = (S₁.mapHomologyIso' F).hom ≫ F.map (homologyMap φ) := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝¹¹ : Category.{u_3, u_1} C
inst✝¹⁰ : Category.{u_4, u_2} D
inst✝⁹ : HasZeroMorphisms C
inst✝⁸ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁷ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms F
inst✝⁵ : HasHomology S₁
inst✝⁴ : HasHomology S₂
inst✝³ : HasHomology (map S₁ F)
inst✝² : HasHomology (map S₂ F)
inst✝¹ : Functor.PreservesRightHomologyOf F S₁
inst✝ : Functor.PreservesRightHomologyOf F S₂
⊢ homologyMap ((Functor.mapShortComplex F).map φ) ≫ (mapHomologyIso' S₂ F).hom =
    (mapHomologyIso' S₁ F).hom ≫ F.map (homologyMap φ)

Next tactic:
dsimp only [Iso.trans, Iso.symm, Functor.mapIso, mapHomologyIso']
@[reassoc]
lemma mapHomologyIso'_hom_naturality [S₁.HasHomology] [S₂.HasHomology]
    [(S₁.map F).HasHomology] [(S₂.map F).HasHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    @homologyMap _ _ _ (S₁.map F) (S₂.map F) (F.mapShortComplex.map φ) _ _ ≫
      (S₂.mapHomologyIso' F).hom = (S₁.mapHomologyIso' F).hom ≫ F.map (homologyMap φ) := by
  dsimp only [Iso.trans, Iso.symm, Functor.mapIso, mapHomologyIso']
  

Proof state:
C : Type u_1
D : Type u_2
inst✝¹¹ : Category.{u_3, u_1} C
inst✝¹⁰ : Category.{u_4, u_2} D
inst✝⁹ : HasZeroMorphisms C
inst✝⁸ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁷ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms F
inst✝⁵ : HasHomology S₁
inst✝⁴ : HasHomology S₂
inst✝³ : HasHomology (map S₁ F)
inst✝² : HasHomology (map S₂ F)
inst✝¹ : Functor.PreservesRightHomologyOf F S₁
inst✝ : Functor.PreservesRightHomologyOf F S₂
⊢ homologyMap ((Functor.mapShortComplex F).map φ) ≫
      (RightHomologyData.homologyIso (RightHomologyData.map (homologyData S₂).right F)).hom ≫
        F.map (RightHomologyData.homologyIso (homologyData S₂).right).inv =
    ((RightHomologyData.homologyIso (RightHomologyData.map (homologyData S₁).right F)).hom ≫
        F.map (RightHomologyData.homologyIso (homologyData S₁).right).inv) ≫
      F.map (homologyMap φ)

Next tactic:
simp only [← RightHomologyData.rightHomologyIso_hom_naturality_assoc _
    ((homologyData S₁).right.map F) ((homologyData S₂).right.map F), assoc,
    ← RightHomologyData.map_rightHomologyMap', ← F.map_comp,
    RightHomologyData.rightHomologyIso_inv_naturality _
      (homologyData S₁).right (homologyData S₂).right]
@[reassoc]
lemma mapHomologyIso'_inv_naturality [S₁.HasHomology] [S₂.HasHomology]
    [(S₁.map F).HasHomology] [(S₂.map F).HasHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    F.map (homologyMap φ) ≫ (S₂.mapHomologyIso' F).inv = (S₁.mapHomologyIso' F).inv ≫
      @homologyMap _ _ _ (S₁.map F) (S₂.map F) (F.mapShortComplex.map φ) _ _ := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝¹¹ : Category.{u_3, u_1} C
inst✝¹⁰ : Category.{u_4, u_2} D
inst✝⁹ : HasZeroMorphisms C
inst✝⁸ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁷ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝⁶ : Functor.PreservesZeroMorphisms F
inst✝⁵ : HasHomology S₁
inst✝⁴ : HasHomology S₂
inst✝³ : HasHomology (map S₁ F)
inst✝² : HasHomology (map S₂ F)
inst✝¹ : Functor.PreservesRightHomologyOf F S₁
inst✝ : Functor.PreservesRightHomologyOf F S₂
⊢ F.map (homologyMap φ) ≫ (mapHomologyIso' S₂ F).inv =
    (mapHomologyIso' S₁ F).inv ≫ homologyMap ((Functor.mapShortComplex F).map φ)

Next tactic:
rw [← cancel_epi (S₁.mapHomologyIso' F).hom, ← mapHomologyIso'_hom_naturality_assoc,
    Iso.hom_inv_id, comp_id, Iso.hom_inv_id_assoc]
lemma mapHomologyIso'_eq_mapHomologyIso [S.HasHomology] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = S.mapHomologyIso F := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁸ : Category.{u_3, u_1} C
inst✝⁷ : Category.{u_4, u_2} D
inst✝⁶ : HasZeroMorphisms C
inst✝⁵ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁴ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms F
inst✝² : HasHomology S
inst✝¹ : Functor.PreservesLeftHomologyOf F S
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ mapHomologyIso' S F = mapHomologyIso S F

Next tactic:
ext
lemma mapHomologyIso'_eq_mapHomologyIso [S.HasHomology] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = S.mapHomologyIso F := by
  ext
  

Proof state:
case w
C : Type u_1
D : Type u_2
inst✝⁸ : Category.{u_3, u_1} C
inst✝⁷ : Category.{u_4, u_2} D
inst✝⁶ : HasZeroMorphisms C
inst✝⁵ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁴ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms F
inst✝² : HasHomology S
inst✝¹ : Functor.PreservesLeftHomologyOf F S
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ (mapHomologyIso' S F).hom = (mapHomologyIso S F).hom

Next tactic:
rw [S.homologyData.left.mapHomologyIso_eq F, S.homologyData.right.mapHomologyIso'_eq F]
lemma mapHomologyIso'_eq_mapHomologyIso [S.HasHomology] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = S.mapHomologyIso F := by
  ext
  rw [S.homologyData.left.mapHomologyIso_eq F, S.homologyData.right.mapHomologyIso'_eq F]
  

Proof state:
case w
C : Type u_1
D : Type u_2
inst✝⁸ : Category.{u_3, u_1} C
inst✝⁷ : Category.{u_4, u_2} D
inst✝⁶ : HasZeroMorphisms C
inst✝⁵ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁴ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms F
inst✝² : HasHomology S
inst✝¹ : Functor.PreservesLeftHomologyOf F S
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ (RightHomologyData.homologyIso (RightHomologyData.map (homologyData S).right F) ≪≫
        F.mapIso (RightHomologyData.homologyIso (homologyData S).right).symm).hom =
    (LeftHomologyData.homologyIso (LeftHomologyData.map (homologyData S).left F) ≪≫
        F.mapIso (LeftHomologyData.homologyIso (homologyData S).left).symm).hom

Next tactic:
dsimp only [Iso.trans, Iso.symm, Iso.refl, Functor.mapIso, RightHomologyData.homologyIso,
    rightHomologyIso, RightHomologyData.rightHomologyIso, LeftHomologyData.homologyIso,
    leftHomologyIso, LeftHomologyData.leftHomologyIso]
lemma mapHomologyIso'_eq_mapHomologyIso [S.HasHomology] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = S.mapHomologyIso F := by
  ext
  rw [S.homologyData.left.mapHomologyIso_eq F, S.homologyData.right.mapHomologyIso'_eq F]
  dsimp only [Iso.trans, Iso.symm, Iso.refl, Functor.mapIso, RightHomologyData.homologyIso,
    rightHomologyIso, RightHomologyData.rightHomologyIso, LeftHomologyData.homologyIso,
    leftHomologyIso, LeftHomologyData.leftHomologyIso]
  

Proof state:
case w
C : Type u_1
D : Type u_2
inst✝⁸ : Category.{u_3, u_1} C
inst✝⁷ : Category.{u_4, u_2} D
inst✝⁶ : HasZeroMorphisms C
inst✝⁵ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁴ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms F
inst✝² : HasHomology S
inst✝¹ : Functor.PreservesLeftHomologyOf F S
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ (((homologyData (map S F)).iso.hom ≫
          (rightHomologyMapIso' (Iso.mk (𝟙 (map S F)) (𝟙 (map S F))) (rightHomologyData (map S F))
              (homologyData (map S F)).right).inv) ≫
        (rightHomologyMapIso' (Iso.mk (𝟙 (map S F)) (𝟙 (map S F))) (rightHomologyData (map S F))
            (RightHomologyData.map (homologyData S).right F)).hom) ≫
      F.map
        ((rightHomologyMapIso' (Iso.mk (𝟙 S) (𝟙 S)) (rightHomologyData S) (homologyData S).right).inv ≫
          (rightHomologyMapIso' (Iso.mk (𝟙 S) (𝟙 S)) (rightHomologyData S) (homologyData S).right).hom ≫
            (homologyData S).iso.inv) =
    ((leftHomologyMapIso' (Iso.mk (𝟙 (map S F)) (𝟙 (map S F))) (leftHomologyData (map S F))
            (homologyData (map S F)).left).inv ≫
        (leftHomologyMapIso' (Iso.mk (𝟙 (map S F)) (𝟙 (map S F))) (leftHomologyData (map S F))
            (LeftHomologyData.map (homologyData S).left F)).hom) ≫
      F.map
        ((leftHomologyMapIso' (Iso.mk (𝟙 S) (𝟙 S)) (leftHomologyData S) (homologyData S).left).inv ≫
          (leftHomologyMapIso' (Iso.mk (𝟙 S) (𝟙 S)) (leftHomologyData S) (homologyData S).left).hom)

Next tactic:
simp only [RightHomologyData.map_H, rightHomologyMapIso'_inv, rightHomologyMapIso'_hom, assoc,
    Functor.map_comp, RightHomologyData.map_rightHomologyMap', Functor.mapShortComplex_obj,
    Functor.map_id, LeftHomologyData.map_H, leftHomologyMapIso'_inv, leftHomologyMapIso'_hom,
    LeftHomologyData.map_leftHomologyMap', ← rightHomologyMap'_comp_assoc, ← leftHomologyMap'_comp,
    ← leftHomologyMap'_comp_assoc, id_comp]
lemma mapHomologyIso'_eq_mapHomologyIso [S.HasHomology] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = S.mapHomologyIso F := by
  ext
  rw [S.homologyData.left.mapHomologyIso_eq F, S.homologyData.right.mapHomologyIso'_eq F]
  dsimp only [Iso.trans, Iso.symm, Iso.refl, Functor.mapIso, RightHomologyData.homologyIso,
    rightHomologyIso, RightHomologyData.rightHomologyIso, LeftHomologyData.homologyIso,
    leftHomologyIso, LeftHomologyData.leftHomologyIso]
  simp only [RightHomologyData.map_H, rightHomologyMapIso'_inv, rightHomologyMapIso'_hom, assoc,
    Functor.map_comp, RightHomologyData.map_rightHomologyMap', Functor.mapShortComplex_obj,
    Functor.map_id, LeftHomologyData.map_H, leftHomologyMapIso'_inv, leftHomologyMapIso'_hom,
    LeftHomologyData.map_leftHomologyMap', ← rightHomologyMap'_comp_assoc, ← leftHomologyMap'_comp,
    ← leftHomologyMap'_comp_assoc, id_comp]
  

Proof state:
case w
C : Type u_1
D : Type u_2
inst✝⁸ : Category.{u_3, u_1} C
inst✝⁷ : Category.{u_4, u_2} D
inst✝⁶ : HasZeroMorphisms C
inst✝⁵ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁴ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms F
inst✝² : HasHomology S
inst✝¹ : Functor.PreservesLeftHomologyOf F S
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ (homologyData (map S F)).iso.hom ≫
      rightHomologyMap' (𝟙 (map S F)) (homologyData (map S F)).right (RightHomologyData.map (homologyData S).right F) ≫
        F.map (homologyData S).iso.inv =
    leftHomologyMap' (𝟙 (map S F)) (homologyData (map S F)).left (LeftHomologyData.map (homologyData S).left F)

Next tactic:
have γ : HomologyMapData (𝟙 (S.map F)) (map S F).homologyData (S.homologyData.map F) := default
lemma mapHomologyIso'_eq_mapHomologyIso [S.HasHomology] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = S.mapHomologyIso F := by
  ext
  rw [S.homologyData.left.mapHomologyIso_eq F, S.homologyData.right.mapHomologyIso'_eq F]
  dsimp only [Iso.trans, Iso.symm, Iso.refl, Functor.mapIso, RightHomologyData.homologyIso,
    rightHomologyIso, RightHomologyData.rightHomologyIso, LeftHomologyData.homologyIso,
    leftHomologyIso, LeftHomologyData.leftHomologyIso]
  simp only [RightHomologyData.map_H, rightHomologyMapIso'_inv, rightHomologyMapIso'_hom, assoc,
    Functor.map_comp, RightHomologyData.map_rightHomologyMap', Functor.mapShortComplex_obj,
    Functor.map_id, LeftHomologyData.map_H, leftHomologyMapIso'_inv, leftHomologyMapIso'_hom,
    LeftHomologyData.map_leftHomologyMap', ← rightHomologyMap'_comp_assoc, ← leftHomologyMap'_comp,
    ← leftHomologyMap'_comp_assoc, id_comp]
  have γ : HomologyMapData (𝟙 (S.map F)) (map S F).homologyData (S.homologyData.map F) := default
  

Proof state:
case w
C : Type u_1
D : Type u_2
inst✝⁸ : Category.{u_3, u_1} C
inst✝⁷ : Category.{u_4, u_2} D
inst✝⁶ : HasZeroMorphisms C
inst✝⁵ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁴ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms F
inst✝² : HasHomology S
inst✝¹ : Functor.PreservesLeftHomologyOf F S
inst✝ : Functor.PreservesRightHomologyOf F S
γ : HomologyMapData (𝟙 (map S F)) (homologyData (map S F)) (HomologyData.map (homologyData S) F)
⊢ (homologyData (map S F)).iso.hom ≫
      rightHomologyMap' (𝟙 (map S F)) (homologyData (map S F)).right (RightHomologyData.map (homologyData S).right F) ≫
        F.map (homologyData S).iso.inv =
    leftHomologyMap' (𝟙 (map S F)) (homologyData (map S F)).left (LeftHomologyData.map (homologyData S).left F)

Next tactic:
have eq := γ.comm
lemma mapHomologyIso'_eq_mapHomologyIso [S.HasHomology] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = S.mapHomologyIso F := by
  ext
  rw [S.homologyData.left.mapHomologyIso_eq F, S.homologyData.right.mapHomologyIso'_eq F]
  dsimp only [Iso.trans, Iso.symm, Iso.refl, Functor.mapIso, RightHomologyData.homologyIso,
    rightHomologyIso, RightHomologyData.rightHomologyIso, LeftHomologyData.homologyIso,
    leftHomologyIso, LeftHomologyData.leftHomologyIso]
  simp only [RightHomologyData.map_H, rightHomologyMapIso'_inv, rightHomologyMapIso'_hom, assoc,
    Functor.map_comp, RightHomologyData.map_rightHomologyMap', Functor.mapShortComplex_obj,
    Functor.map_id, LeftHomologyData.map_H, leftHomologyMapIso'_inv, leftHomologyMapIso'_hom,
    LeftHomologyData.map_leftHomologyMap', ← rightHomologyMap'_comp_assoc, ← leftHomologyMap'_comp,
    ← leftHomologyMap'_comp_assoc, id_comp]
  have γ : HomologyMapData (𝟙 (S.map F)) (map S F).homologyData (S.homologyData.map F) := default
  have eq := γ.comm
  

Proof state:
case w
C : Type u_1
D : Type u_2
inst✝⁸ : Category.{u_3, u_1} C
inst✝⁷ : Category.{u_4, u_2} D
inst✝⁶ : HasZeroMorphisms C
inst✝⁵ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁴ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms F
inst✝² : HasHomology S
inst✝¹ : Functor.PreservesLeftHomologyOf F S
inst✝ : Functor.PreservesRightHomologyOf F S
γ : HomologyMapData (𝟙 (map S F)) (homologyData (map S F)) (HomologyData.map (homologyData S) F)
eq : γ.left.φH ≫ (HomologyData.map (homologyData S) F).iso.hom = (homologyData (map S F)).iso.hom ≫ γ.right.φH
⊢ (homologyData (map S F)).iso.hom ≫
      rightHomologyMap' (𝟙 (map S F)) (homologyData (map S F)).right (RightHomologyData.map (homologyData S).right F) ≫
        F.map (homologyData S).iso.inv =
    leftHomologyMap' (𝟙 (map S F)) (homologyData (map S F)).left (LeftHomologyData.map (homologyData S).left F)

Next tactic:
rw [← γ.left.leftHomologyMap'_eq, ← γ.right.rightHomologyMap'_eq] at eq
lemma mapHomologyIso'_eq_mapHomologyIso [S.HasHomology] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = S.mapHomologyIso F := by
  ext
  rw [S.homologyData.left.mapHomologyIso_eq F, S.homologyData.right.mapHomologyIso'_eq F]
  dsimp only [Iso.trans, Iso.symm, Iso.refl, Functor.mapIso, RightHomologyData.homologyIso,
    rightHomologyIso, RightHomologyData.rightHomologyIso, LeftHomologyData.homologyIso,
    leftHomologyIso, LeftHomologyData.leftHomologyIso]
  simp only [RightHomologyData.map_H, rightHomologyMapIso'_inv, rightHomologyMapIso'_hom, assoc,
    Functor.map_comp, RightHomologyData.map_rightHomologyMap', Functor.mapShortComplex_obj,
    Functor.map_id, LeftHomologyData.map_H, leftHomologyMapIso'_inv, leftHomologyMapIso'_hom,
    LeftHomologyData.map_leftHomologyMap', ← rightHomologyMap'_comp_assoc, ← leftHomologyMap'_comp,
    ← leftHomologyMap'_comp_assoc, id_comp]
  have γ : HomologyMapData (𝟙 (S.map F)) (map S F).homologyData (S.homologyData.map F) := default
  have eq := γ.comm
  rw [← γ.left.leftHomologyMap'_eq, ← γ.right.rightHomologyMap'_eq] at eq
  

Proof state:
case w
C : Type u_1
D : Type u_2
inst✝⁸ : Category.{u_3, u_1} C
inst✝⁷ : Category.{u_4, u_2} D
inst✝⁶ : HasZeroMorphisms C
inst✝⁵ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : LeftHomologyData S
h₂✝ : RightHomologyData S
F✝ : C ⥤ D
inst✝⁴ : Functor.PreservesZeroMorphisms F✝
hl : LeftHomologyData S
hr : RightHomologyData S
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : LeftHomologyData S₁
hr₁ : RightHomologyData S₁
hl₂ : LeftHomologyData S₂
hr₂ : RightHomologyData S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
F : C ⥤ D
inst✝³ : Functor.PreservesZeroMorphisms F
inst✝² : HasHomology S
inst✝¹ : Functor.PreservesLeftHomologyOf F S
inst✝ : Functor.PreservesRightHomologyOf F S
γ : HomologyMapData (𝟙 (map S F)) (homologyData (map S F)) (HomologyData.map (homologyData S) F)
eq :
  leftHomologyMap' (𝟙 (map S F)) (homologyData (map S F)).left (HomologyData.map (homologyData S) F).left ≫
      (HomologyData.map (homologyData S) F).iso.hom =
    (homologyData (map S F)).iso.hom ≫
      rightHomologyMap' (𝟙 (map S F)) (homologyData (map S F)).right (HomologyData.map (homologyData S) F).right
⊢ (homologyData (map S F)).iso.hom ≫
      rightHomologyMap' (𝟙 (map S F)) (homologyData (map S F)).right (RightHomologyData.map (homologyData S).right F) ≫
        F.map (homologyData S).iso.inv =
    leftHomologyMap' (𝟙 (map S F)) (homologyData (map S F)).left (LeftHomologyData.map (homologyData S).left F)

Next tactic:
dsimp at eq