l3lab/ntp-mathlib huggingface dataset:
lemma RightHomologyData.mapHomologyIso'_eq [S.HasHomology]
    [(S.map F).HasHomology] [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = (hr.map F).homologyIso ≪≫ F.mapIso hr.homologyIso.symm := 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 (ShortComplex.map S F)
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ mapHomologyIso' S F = homologyIso (map hr F) ≪≫ F.mapIso (homologyIso hr).symm

Next tactic:
ext
lemma RightHomologyData.mapHomologyIso'_eq [S.HasHomology]
    [(S.map F).HasHomology] [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = (hr.map F).homologyIso ≪≫ F.mapIso hr.homologyIso.symm := 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✝¹ : HasHomology (ShortComplex.map S F)
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ (mapHomologyIso' S F).hom = (homologyIso (map hr F) ≪≫ F.mapIso (homologyIso hr).symm).hom

Next tactic:
dsimp only [Iso.trans, Iso.symm, Iso.refl, Functor.mapIso, mapHomologyIso', homologyIso,
    rightHomologyIso, rightHomologyMapIso', ShortComplex.rightHomologyIso]
lemma RightHomologyData.mapHomologyIso'_eq [S.HasHomology]
    [(S.map F).HasHomology] [F.PreservesRightHomologyOf S] :
    S.mapHomologyIso' F = (hr.map F).homologyIso ≪≫ F.mapIso hr.homologyIso.symm := by
  ext
  dsimp only [Iso.trans, Iso.symm, Iso.refl, Functor.mapIso, mapHomologyIso', homologyIso,
    rightHomologyIso, rightHomologyMapIso', ShortComplex.rightHomologyIso]
  

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✝¹ : HasHomology (ShortComplex.map S F)
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ (((homologyData (ShortComplex.map S F)).iso.hom ≫
          rightHomologyMap' (𝟙 (ShortComplex.map S F)) (homologyData (ShortComplex.map S F)).right
            (rightHomologyData (ShortComplex.map S F))) ≫
        rightHomologyMap' (𝟙 (ShortComplex.map S F)) (rightHomologyData (ShortComplex.map S F))
          (map (homologyData S).right F)) ≫
      F.map
        (rightHomologyMap' (𝟙 S) (homologyData S).right (rightHomologyData S) ≫
          rightHomologyMap' (𝟙 S) (rightHomologyData S) (homologyData S).right ≫ (homologyData S).iso.inv) =
    (((homologyData (ShortComplex.map S F)).iso.hom ≫
          rightHomologyMap' (𝟙 (ShortComplex.map S F)) (homologyData (ShortComplex.map S F)).right
            (rightHomologyData (ShortComplex.map S F))) ≫
        rightHomologyMap' (𝟙 (ShortComplex.map S F)) (rightHomologyData (ShortComplex.map S F)) (map hr F)) ≫
      F.map
        (rightHomologyMap' (𝟙 S) hr (rightHomologyData S) ≫
          rightHomologyMap' (𝟙 S) (rightHomologyData S) (homologyData S).right ≫ (homologyData S).iso.inv)

Next tactic:
simp only [assoc, F.map_comp, map_rightHomologyMap', ← rightHomologyMap'_comp_assoc]
@[reassoc]
lemma mapCyclesIso_hom_naturality [S₁.HasLeftHomology] [S₂.HasLeftHomology]
    [F.PreservesLeftHomologyOf S₁] [F.PreservesLeftHomologyOf S₂] :
    cyclesMap (F.mapShortComplex.map φ) ≫ (S₂.mapCyclesIso F).hom =
      (S₁.mapCyclesIso F).hom ≫ F.map (cyclesMap φ) := 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✝³ : HasLeftHomology S₁
inst✝² : HasLeftHomology S₂
inst✝¹ : Functor.PreservesLeftHomologyOf F S₁
inst✝ : Functor.PreservesLeftHomologyOf F S₂
⊢ cyclesMap ((Functor.mapShortComplex F).map φ) ≫ (mapCyclesIso S₂ F).hom =
    (mapCyclesIso S₁ F).hom ≫ F.map (cyclesMap φ)

Next tactic:
dsimp only [cyclesMap, mapCyclesIso, LeftHomologyData.cyclesIso, cyclesMapIso', Iso.refl]
@[reassoc]
lemma mapCyclesIso_hom_naturality [S₁.HasLeftHomology] [S₂.HasLeftHomology]
    [F.PreservesLeftHomologyOf S₁] [F.PreservesLeftHomologyOf S₂] :
    cyclesMap (F.mapShortComplex.map φ) ≫ (S₂.mapCyclesIso F).hom =
      (S₁.mapCyclesIso F).hom ≫ F.map (cyclesMap φ) := by
  dsimp only [cyclesMap, mapCyclesIso, LeftHomologyData.cyclesIso, cyclesMapIso', 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✝³ : HasLeftHomology S₁
inst✝² : HasLeftHomology S₂
inst✝¹ : Functor.PreservesLeftHomologyOf F S₁
inst✝ : Functor.PreservesLeftHomologyOf F S₂
⊢ cyclesMap' ((Functor.mapShortComplex F).map φ) (leftHomologyData ((Functor.mapShortComplex F).obj S₁))
        (leftHomologyData ((Functor.mapShortComplex F).obj S₂)) ≫
      cyclesMap' (𝟙 (map S₂ F)) (leftHomologyData (map S₂ F)) (LeftHomologyData.map (leftHomologyData S₂) F) =
    cyclesMap' (𝟙 (map S₁ F)) (leftHomologyData (map S₁ F)) (LeftHomologyData.map (leftHomologyData S₁) F) ≫
      F.map (cyclesMap' φ (leftHomologyData S₁) (leftHomologyData S₂))

Next tactic:
simp only [LeftHomologyData.map_cyclesMap', Functor.mapShortComplex_obj, ← cyclesMap'_comp,
    comp_id, id_comp]
@[reassoc]
lemma mapCyclesIso_inv_naturality [S₁.HasLeftHomology] [S₂.HasLeftHomology]
    [F.PreservesLeftHomologyOf S₁] [F.PreservesLeftHomologyOf S₂] :
    F.map (cyclesMap φ) ≫ (S₂.mapCyclesIso F).inv =
      (S₁.mapCyclesIso F).inv ≫ cyclesMap (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✝³ : HasLeftHomology S₁
inst✝² : HasLeftHomology S₂
inst✝¹ : Functor.PreservesLeftHomologyOf F S₁
inst✝ : Functor.PreservesLeftHomologyOf F S₂
⊢ F.map (cyclesMap φ) ≫ (mapCyclesIso S₂ F).inv =
    (mapCyclesIso S₁ F).inv ≫ cyclesMap ((Functor.mapShortComplex F).map φ)

Next tactic:
rw [← cancel_epi (S₁.mapCyclesIso F).hom, ← mapCyclesIso_hom_naturality_assoc,
    Iso.hom_inv_id, comp_id, Iso.hom_inv_id_assoc]
@[reassoc]
lemma mapLeftHomologyIso_hom_naturality [S₁.HasLeftHomology] [S₂.HasLeftHomology]
    [F.PreservesLeftHomologyOf S₁] [F.PreservesLeftHomologyOf S₂] :
    leftHomologyMap (F.mapShortComplex.map φ) ≫ (S₂.mapLeftHomologyIso F).hom =
      (S₁.mapLeftHomologyIso F).hom ≫ F.map (leftHomologyMap φ) := 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✝³ : HasLeftHomology S₁
inst✝² : HasLeftHomology S₂
inst✝¹ : Functor.PreservesLeftHomologyOf F S₁
inst✝ : Functor.PreservesLeftHomologyOf F S₂
⊢ leftHomologyMap ((Functor.mapShortComplex F).map φ) ≫ (mapLeftHomologyIso S₂ F).hom =
    (mapLeftHomologyIso S₁ F).hom ≫ F.map (leftHomologyMap φ)

Next tactic:
dsimp only [leftHomologyMap, mapLeftHomologyIso, LeftHomologyData.leftHomologyIso,
    leftHomologyMapIso', Iso.refl]
@[reassoc]
lemma mapLeftHomologyIso_hom_naturality [S₁.HasLeftHomology] [S₂.HasLeftHomology]
    [F.PreservesLeftHomologyOf S₁] [F.PreservesLeftHomologyOf S₂] :
    leftHomologyMap (F.mapShortComplex.map φ) ≫ (S₂.mapLeftHomologyIso F).hom =
      (S₁.mapLeftHomologyIso F).hom ≫ F.map (leftHomologyMap φ) := by
  dsimp only [leftHomologyMap, mapLeftHomologyIso, LeftHomologyData.leftHomologyIso,
    leftHomologyMapIso', 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✝³ : HasLeftHomology S₁
inst✝² : HasLeftHomology S₂
inst✝¹ : Functor.PreservesLeftHomologyOf F S₁
inst✝ : Functor.PreservesLeftHomologyOf F S₂
⊢ leftHomologyMap' ((Functor.mapShortComplex F).map φ) (leftHomologyData ((Functor.mapShortComplex F).obj S₁))
        (leftHomologyData ((Functor.mapShortComplex F).obj S₂)) ≫
      leftHomologyMap' (𝟙 (map S₂ F)) (leftHomologyData (map S₂ F)) (LeftHomologyData.map (leftHomologyData S₂) F) =
    leftHomologyMap' (𝟙 (map S₁ F)) (leftHomologyData (map S₁ F)) (LeftHomologyData.map (leftHomologyData S₁) F) ≫
      F.map (leftHomologyMap' φ (leftHomologyData S₁) (leftHomologyData S₂))

Next tactic:
simp only [LeftHomologyData.map_leftHomologyMap', Functor.mapShortComplex_obj,
    ← leftHomologyMap'_comp, comp_id, id_comp]
@[reassoc]
lemma mapLeftHomologyIso_inv_naturality [S₁.HasLeftHomology] [S₂.HasLeftHomology]
    [F.PreservesLeftHomologyOf S₁] [F.PreservesLeftHomologyOf S₂] :
    F.map (leftHomologyMap φ) ≫ (S₂.mapLeftHomologyIso F).inv =
      (S₁.mapLeftHomologyIso F).inv ≫ leftHomologyMap (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✝³ : HasLeftHomology S₁
inst✝² : HasLeftHomology S₂
inst✝¹ : Functor.PreservesLeftHomologyOf F S₁
inst✝ : Functor.PreservesLeftHomologyOf F S₂
⊢ F.map (leftHomologyMap φ) ≫ (mapLeftHomologyIso S₂ F).inv =
    (mapLeftHomologyIso S₁ F).inv ≫ leftHomologyMap ((Functor.mapShortComplex F).map φ)

Next tactic:
rw [← cancel_epi (S₁.mapLeftHomologyIso F).hom, ← mapLeftHomologyIso_hom_naturality_assoc,
    Iso.hom_inv_id, comp_id, Iso.hom_inv_id_assoc]
@[reassoc]
lemma mapOpcyclesIso_hom_naturality [S₁.HasRightHomology] [S₂.HasRightHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    opcyclesMap (F.mapShortComplex.map φ) ≫ (S₂.mapOpcyclesIso F).hom =
      (S₁.mapOpcyclesIso F).hom ≫ F.map (opcyclesMap φ) := 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✝³ : HasRightHomology S₁
inst✝² : HasRightHomology S₂
inst✝¹ : Functor.PreservesRightHomologyOf F S₁
inst✝ : Functor.PreservesRightHomologyOf F S₂
⊢ opcyclesMap ((Functor.mapShortComplex F).map φ) ≫ (mapOpcyclesIso S₂ F).hom =
    (mapOpcyclesIso S₁ F).hom ≫ F.map (opcyclesMap φ)

Next tactic:
dsimp only [opcyclesMap, mapOpcyclesIso, RightHomologyData.opcyclesIso,
    opcyclesMapIso', Iso.refl]
@[reassoc]
lemma mapOpcyclesIso_hom_naturality [S₁.HasRightHomology] [S₂.HasRightHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    opcyclesMap (F.mapShortComplex.map φ) ≫ (S₂.mapOpcyclesIso F).hom =
      (S₁.mapOpcyclesIso F).hom ≫ F.map (opcyclesMap φ) := by
  dsimp only [opcyclesMap, mapOpcyclesIso, RightHomologyData.opcyclesIso,
    opcyclesMapIso', 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✝³ : HasRightHomology S₁
inst✝² : HasRightHomology S₂
inst✝¹ : Functor.PreservesRightHomologyOf F S₁
inst✝ : Functor.PreservesRightHomologyOf F S₂
⊢ opcyclesMap' ((Functor.mapShortComplex F).map φ) (rightHomologyData ((Functor.mapShortComplex F).obj S₁))
        (rightHomologyData ((Functor.mapShortComplex F).obj S₂)) ≫
      opcyclesMap' (𝟙 (map S₂ F)) (rightHomologyData (map S₂ F)) (RightHomologyData.map (rightHomologyData S₂) F) =
    opcyclesMap' (𝟙 (map S₁ F)) (rightHomologyData (map S₁ F)) (RightHomologyData.map (rightHomologyData S₁) F) ≫
      F.map (opcyclesMap' φ (rightHomologyData S₁) (rightHomologyData S₂))

Next tactic:
simp only [RightHomologyData.map_opcyclesMap', Functor.mapShortComplex_obj, ← opcyclesMap'_comp,
    comp_id, id_comp]
@[reassoc]
lemma mapOpcyclesIso_inv_naturality [S₁.HasRightHomology] [S₂.HasRightHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    F.map (opcyclesMap φ) ≫ (S₂.mapOpcyclesIso F).inv =
      (S₁.mapOpcyclesIso F).inv ≫ opcyclesMap (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✝³ : HasRightHomology S₁
inst✝² : HasRightHomology S₂
inst✝¹ : Functor.PreservesRightHomologyOf F S₁
inst✝ : Functor.PreservesRightHomologyOf F S₂
⊢ F.map (opcyclesMap φ) ≫ (mapOpcyclesIso S₂ F).inv =
    (mapOpcyclesIso S₁ F).inv ≫ opcyclesMap ((Functor.mapShortComplex F).map φ)

Next tactic:
rw [← cancel_epi (S₁.mapOpcyclesIso F).hom, ← mapOpcyclesIso_hom_naturality_assoc,
    Iso.hom_inv_id, comp_id, Iso.hom_inv_id_assoc]
@[reassoc]
lemma mapRightHomologyIso_hom_naturality [S₁.HasRightHomology] [S₂.HasRightHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    rightHomologyMap (F.mapShortComplex.map φ) ≫ (S₂.mapRightHomologyIso F).hom =
      (S₁.mapRightHomologyIso F).hom ≫ F.map (rightHomologyMap φ) := 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✝³ : HasRightHomology S₁
inst✝² : HasRightHomology S₂
inst✝¹ : Functor.PreservesRightHomologyOf F S₁
inst✝ : Functor.PreservesRightHomologyOf F S₂
⊢ rightHomologyMap ((Functor.mapShortComplex F).map φ) ≫ (mapRightHomologyIso S₂ F).hom =
    (mapRightHomologyIso S₁ F).hom ≫ F.map (rightHomologyMap φ)

Next tactic:
dsimp only [rightHomologyMap, mapRightHomologyIso, RightHomologyData.rightHomologyIso,
    rightHomologyMapIso', Iso.refl]
@[reassoc]
lemma mapRightHomologyIso_hom_naturality [S₁.HasRightHomology] [S₂.HasRightHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    rightHomologyMap (F.mapShortComplex.map φ) ≫ (S₂.mapRightHomologyIso F).hom =
      (S₁.mapRightHomologyIso F).hom ≫ F.map (rightHomologyMap φ) := by
  dsimp only [rightHomologyMap, mapRightHomologyIso, RightHomologyData.rightHomologyIso,
    rightHomologyMapIso', 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✝³ : HasRightHomology S₁
inst✝² : HasRightHomology S₂
inst✝¹ : Functor.PreservesRightHomologyOf F S₁
inst✝ : Functor.PreservesRightHomologyOf F S₂
⊢ rightHomologyMap' ((Functor.mapShortComplex F).map φ) (rightHomologyData ((Functor.mapShortComplex F).obj S₁))
        (rightHomologyData ((Functor.mapShortComplex F).obj S₂)) ≫
      rightHomologyMap' (𝟙 (map S₂ F)) (rightHomologyData (map S₂ F)) (RightHomologyData.map (rightHomologyData S₂) F) =
    rightHomologyMap' (𝟙 (map S₁ F)) (rightHomologyData (map S₁ F)) (RightHomologyData.map (rightHomologyData S₁) F) ≫
      F.map (rightHomologyMap' φ (rightHomologyData S₁) (rightHomologyData S₂))

Next tactic:
simp only [RightHomologyData.map_rightHomologyMap', Functor.mapShortComplex_obj,
    ← rightHomologyMap'_comp, comp_id, id_comp]
@[reassoc]
lemma mapRightHomologyIso_inv_naturality [S₁.HasRightHomology] [S₂.HasRightHomology]
    [F.PreservesRightHomologyOf S₁] [F.PreservesRightHomologyOf S₂] :
    F.map (rightHomologyMap φ) ≫ (S₂.mapRightHomologyIso F).inv =
      (S₁.mapRightHomologyIso F).inv ≫ rightHomologyMap (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✝³ : HasRightHomology S₁
inst✝² : HasRightHomology S₂
inst✝¹ : Functor.PreservesRightHomologyOf F S₁
inst✝ : Functor.PreservesRightHomologyOf F S₂
⊢ F.map (rightHomologyMap φ) ≫ (mapRightHomologyIso S₂ F).inv =
    (mapRightHomologyIso S₁ F).inv ≫ rightHomologyMap ((Functor.mapShortComplex F).map φ)

Next tactic:
rw [← cancel_epi (S₁.mapRightHomologyIso F).hom, ← mapRightHomologyIso_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.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
  

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₂
⊢ homologyMap ((Functor.mapShortComplex F).map φ) ≫ (mapHomologyIso S₂ F).hom =
    (mapHomologyIso S₁ F).hom ≫ F.map (homologyMap φ)

Next tactic:
dsimp only [homologyMap, homologyMap', mapHomologyIso, LeftHomologyData.homologyIso,
    LeftHomologyData.leftHomologyIso, leftHomologyMapIso', leftHomologyIso,
    Iso.symm, Iso.trans, Iso.refl]