l3lab/ntp-mathlib huggingface dataset:
lemma map_leftHomologyMap' : F.map (ShortComplex.leftHomologyMap' φ hl₁ hl₂) =
    ShortComplex.leftHomologyMap' (F.mapShortComplex.map φ) (hl₁.map F) (hl₂.map F) := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_4, u_1} C
inst✝⁶ : Category.{u_3, 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✝¹ : IsPreservedBy hl₁ F
inst✝ : IsPreservedBy hl₂ F
⊢ F.map (leftHomologyMap' φ hl₁ hl₂) = leftHomologyMap' ((Functor.mapShortComplex F).map φ) (map hl₁ F) (map hl₂ F)

Next tactic:
have γ : ShortComplex.LeftHomologyMapData φ hl₁ hl₂ := default
lemma map_leftHomologyMap' : F.map (ShortComplex.leftHomologyMap' φ hl₁ hl₂) =
    ShortComplex.leftHomologyMap' (F.mapShortComplex.map φ) (hl₁.map F) (hl₂.map F) := by
  have γ : ShortComplex.LeftHomologyMapData φ hl₁ hl₂ := default
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_4, u_1} C
inst✝⁶ : Category.{u_3, 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✝¹ : IsPreservedBy hl₁ F
inst✝ : IsPreservedBy hl₂ F
γ : LeftHomologyMapData φ hl₁ hl₂
⊢ F.map (leftHomologyMap' φ hl₁ hl₂) = leftHomologyMap' ((Functor.mapShortComplex F).map φ) (map hl₁ F) (map hl₂ F)

Next tactic:
rw [γ.leftHomologyMap'_eq, (γ.map F).leftHomologyMap'_eq,
    ShortComplex.LeftHomologyMapData.map_φH]
lemma map_opcyclesMap' : F.map (ShortComplex.opcyclesMap' φ hr₁ hr₂) =
    ShortComplex.opcyclesMap' (F.mapShortComplex.map φ) (hr₁.map F) (hr₂.map F) := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_4, u_1} C
inst✝⁶ : Category.{u_3, 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✝¹ : IsPreservedBy hr₁ F
inst✝ : IsPreservedBy hr₂ F
⊢ F.map (opcyclesMap' φ hr₁ hr₂) = opcyclesMap' ((Functor.mapShortComplex F).map φ) (map hr₁ F) (map hr₂ F)

Next tactic:
have γ : ShortComplex.RightHomologyMapData φ hr₁ hr₂ := default
lemma map_opcyclesMap' : F.map (ShortComplex.opcyclesMap' φ hr₁ hr₂) =
    ShortComplex.opcyclesMap' (F.mapShortComplex.map φ) (hr₁.map F) (hr₂.map F) := by
  have γ : ShortComplex.RightHomologyMapData φ hr₁ hr₂ := default
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_4, u_1} C
inst✝⁶ : Category.{u_3, 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✝¹ : IsPreservedBy hr₁ F
inst✝ : IsPreservedBy hr₂ F
γ : RightHomologyMapData φ hr₁ hr₂
⊢ F.map (opcyclesMap' φ hr₁ hr₂) = opcyclesMap' ((Functor.mapShortComplex F).map φ) (map hr₁ F) (map hr₂ F)

Next tactic:
rw [γ.opcyclesMap'_eq, (γ.map F).opcyclesMap'_eq,  ShortComplex.RightHomologyMapData.map_φQ]
lemma map_rightHomologyMap' : F.map (ShortComplex.rightHomologyMap' φ hr₁ hr₂) =
    ShortComplex.rightHomologyMap' (F.mapShortComplex.map φ) (hr₁.map F) (hr₂.map F) := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_4, u_1} C
inst✝⁶ : Category.{u_3, 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✝¹ : IsPreservedBy hr₁ F
inst✝ : IsPreservedBy hr₂ F
⊢ F.map (rightHomologyMap' φ hr₁ hr₂) = rightHomologyMap' ((Functor.mapShortComplex F).map φ) (map hr₁ F) (map hr₂ F)

Next tactic:
have γ : ShortComplex.RightHomologyMapData φ hr₁ hr₂ := default
lemma map_rightHomologyMap' : F.map (ShortComplex.rightHomologyMap' φ hr₁ hr₂) =
    ShortComplex.rightHomologyMap' (F.mapShortComplex.map φ) (hr₁.map F) (hr₂.map F) := by
  have γ : ShortComplex.RightHomologyMapData φ hr₁ hr₂ := default
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁷ : Category.{u_4, u_1} C
inst✝⁶ : Category.{u_3, 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✝¹ : IsPreservedBy hr₁ F
inst✝ : IsPreservedBy hr₂ F
γ : RightHomologyMapData φ hr₁ hr₂
⊢ F.map (rightHomologyMap' φ hr₁ hr₂) = rightHomologyMap' ((Functor.mapShortComplex F).map φ) (map hr₁ F) (map hr₂ F)

Next tactic:
rw [γ.rightHomologyMap'_eq, (γ.map F).rightHomologyMap'_eq,
    ShortComplex.RightHomologyMapData.map_φH]
lemma LeftHomologyData.mapCyclesIso_eq [S.HasLeftHomology]
    [F.PreservesLeftHomologyOf S] :
    S.mapCyclesIso F = (hl.map F).cyclesIso ≪≫ F.mapIso hl.cyclesIso.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✝¹ : HasLeftHomology S
inst✝ : Functor.PreservesLeftHomologyOf F S
⊢ mapCyclesIso S F = cyclesIso (map hl F) ≪≫ F.mapIso (cyclesIso hl).symm

Next tactic:
ext
lemma LeftHomologyData.mapCyclesIso_eq [S.HasLeftHomology]
    [F.PreservesLeftHomologyOf S] :
    S.mapCyclesIso F = (hl.map F).cyclesIso ≪≫ F.mapIso hl.cyclesIso.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✝¹ : HasLeftHomology S
inst✝ : Functor.PreservesLeftHomologyOf F S
⊢ (mapCyclesIso S F).hom = (cyclesIso (map hl F) ≪≫ F.mapIso (cyclesIso hl).symm).hom

Next tactic:
dsimp [mapCyclesIso, cyclesIso]
lemma LeftHomologyData.mapCyclesIso_eq [S.HasLeftHomology]
    [F.PreservesLeftHomologyOf S] :
    S.mapCyclesIso F = (hl.map F).cyclesIso ≪≫ F.mapIso hl.cyclesIso.symm := by
  ext
  dsimp [mapCyclesIso, cyclesIso]
  

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✝¹ : HasLeftHomology S
inst✝ : Functor.PreservesLeftHomologyOf F S
⊢ cyclesMap' (𝟙 (ShortComplex.map S F)) (leftHomologyData (ShortComplex.map S F)) (map (leftHomologyData S) F) =
    cyclesMap' (𝟙 (ShortComplex.map S F)) (leftHomologyData (ShortComplex.map S F)) (map hl F) ≫
      F.map (cyclesMap' (𝟙 S) hl (leftHomologyData S))

Next tactic:
simp only [map_cyclesMap', ← cyclesMap'_comp, Functor.map_id, comp_id,
    Functor.mapShortComplex_obj]
lemma LeftHomologyData.mapLeftHomologyIso_eq [S.HasLeftHomology]
    [F.PreservesLeftHomologyOf S] :
    S.mapLeftHomologyIso F = (hl.map F).leftHomologyIso ≪≫ F.mapIso hl.leftHomologyIso.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✝¹ : HasLeftHomology S
inst✝ : Functor.PreservesLeftHomologyOf F S
⊢ mapLeftHomologyIso S F = leftHomologyIso (map hl F) ≪≫ F.mapIso (leftHomologyIso hl).symm

Next tactic:
ext
lemma LeftHomologyData.mapLeftHomologyIso_eq [S.HasLeftHomology]
    [F.PreservesLeftHomologyOf S] :
    S.mapLeftHomologyIso F = (hl.map F).leftHomologyIso ≪≫ F.mapIso hl.leftHomologyIso.symm := by
  ext
  

Proof state:
case w.h
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✝ : Functor.PreservesLeftHomologyOf F S
⊢ leftHomologyπ (ShortComplex.map S F) ≫ (mapLeftHomologyIso S F).hom =
    leftHomologyπ (ShortComplex.map S F) ≫ (leftHomologyIso (map hl F) ≪≫ F.mapIso (leftHomologyIso hl).symm).hom

Next tactic:
dsimp [mapLeftHomologyIso, leftHomologyIso]
lemma LeftHomologyData.mapLeftHomologyIso_eq [S.HasLeftHomology]
    [F.PreservesLeftHomologyOf S] :
    S.mapLeftHomologyIso F = (hl.map F).leftHomologyIso ≪≫ F.mapIso hl.leftHomologyIso.symm := by
  ext
  dsimp [mapLeftHomologyIso, leftHomologyIso]
  

Proof state:
case w.h
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✝ : Functor.PreservesLeftHomologyOf F S
⊢ leftHomologyπ (ShortComplex.map S F) ≫
      leftHomologyMap' (𝟙 (ShortComplex.map S F)) (leftHomologyData (ShortComplex.map S F))
        (map (leftHomologyData S) F) =
    leftHomologyπ (ShortComplex.map S F) ≫
      leftHomologyMap' (𝟙 (ShortComplex.map S F)) (leftHomologyData (ShortComplex.map S F)) (map hl F) ≫
        F.map (leftHomologyMap' (𝟙 S) hl (leftHomologyData S))

Next tactic:
simp only [map_leftHomologyMap', ← leftHomologyMap'_comp, Functor.map_id, comp_id,
    Functor.mapShortComplex_obj]
lemma RightHomologyData.mapOpcyclesIso_eq [S.HasRightHomology]
    [F.PreservesRightHomologyOf S] :
    S.mapOpcyclesIso F = (hr.map F).opcyclesIso ≪≫ F.mapIso hr.opcyclesIso.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✝¹ : HasRightHomology S
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ mapOpcyclesIso S F = opcyclesIso (map hr F) ≪≫ F.mapIso (opcyclesIso hr).symm

Next tactic:
ext
lemma RightHomologyData.mapOpcyclesIso_eq [S.HasRightHomology]
    [F.PreservesRightHomologyOf S] :
    S.mapOpcyclesIso F = (hr.map F).opcyclesIso ≪≫ F.mapIso hr.opcyclesIso.symm := by
  ext
  

Proof state:
case w.h
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✝ : Functor.PreservesRightHomologyOf F S
⊢ pOpcycles (ShortComplex.map S F) ≫ (mapOpcyclesIso S F).hom =
    pOpcycles (ShortComplex.map S F) ≫ (opcyclesIso (map hr F) ≪≫ F.mapIso (opcyclesIso hr).symm).hom

Next tactic:
dsimp [mapOpcyclesIso, opcyclesIso]
lemma RightHomologyData.mapOpcyclesIso_eq [S.HasRightHomology]
    [F.PreservesRightHomologyOf S] :
    S.mapOpcyclesIso F = (hr.map F).opcyclesIso ≪≫ F.mapIso hr.opcyclesIso.symm := by
  ext
  dsimp [mapOpcyclesIso, opcyclesIso]
  

Proof state:
case w.h
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✝ : Functor.PreservesRightHomologyOf F S
⊢ pOpcycles (ShortComplex.map S F) ≫
      opcyclesMap' (𝟙 (ShortComplex.map S F)) (rightHomologyData (ShortComplex.map S F)) (map (rightHomologyData S) F) =
    pOpcycles (ShortComplex.map S F) ≫
      opcyclesMap' (𝟙 (ShortComplex.map S F)) (rightHomologyData (ShortComplex.map S F)) (map hr F) ≫
        F.map (opcyclesMap' (𝟙 S) hr (rightHomologyData S))

Next tactic:
simp only [map_opcyclesMap', ← opcyclesMap'_comp, Functor.map_id, comp_id,
    Functor.mapShortComplex_obj]
lemma RightHomologyData.mapRightHomologyIso_eq [S.HasRightHomology]
    [F.PreservesRightHomologyOf S] :
    S.mapRightHomologyIso F = (hr.map F).rightHomologyIso ≪≫
      F.mapIso hr.rightHomologyIso.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✝¹ : HasRightHomology S
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ mapRightHomologyIso S F = rightHomologyIso (map hr F) ≪≫ F.mapIso (rightHomologyIso hr).symm

Next tactic:
ext
lemma RightHomologyData.mapRightHomologyIso_eq [S.HasRightHomology]
    [F.PreservesRightHomologyOf S] :
    S.mapRightHomologyIso F = (hr.map F).rightHomologyIso ≪≫
      F.mapIso hr.rightHomologyIso.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✝¹ : HasRightHomology S
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ (mapRightHomologyIso S F).hom = (rightHomologyIso (map hr F) ≪≫ F.mapIso (rightHomologyIso hr).symm).hom

Next tactic:
dsimp [mapRightHomologyIso, rightHomologyIso]
lemma RightHomologyData.mapRightHomologyIso_eq [S.HasRightHomology]
    [F.PreservesRightHomologyOf S] :
    S.mapRightHomologyIso F = (hr.map F).rightHomologyIso ≪≫
      F.mapIso hr.rightHomologyIso.symm := by
  ext
  dsimp [mapRightHomologyIso, 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✝¹ : HasRightHomology S
inst✝ : Functor.PreservesRightHomologyOf F S
⊢ rightHomologyMap' (𝟙 (ShortComplex.map S F)) (rightHomologyData (ShortComplex.map S F))
      (map (rightHomologyData S) F) =
    rightHomologyMap' (𝟙 (ShortComplex.map S F)) (rightHomologyData (ShortComplex.map S F)) (map hr F) ≫
      F.map (rightHomologyMap' (𝟙 S) hr (rightHomologyData S))

Next tactic:
simp only [map_rightHomologyMap', ← rightHomologyMap'_comp, Functor.map_id, comp_id,
    Functor.mapShortComplex_obj]
lemma LeftHomologyData.mapHomologyIso_eq [S.HasHomology]
    [(S.map F).HasHomology] [F.PreservesLeftHomologyOf S] :
    S.mapHomologyIso F = (hl.map F).homologyIso ≪≫ F.mapIso hl.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.PreservesLeftHomologyOf F S
⊢ mapHomologyIso S F = homologyIso (map hl F) ≪≫ F.mapIso (homologyIso hl).symm

Next tactic:
ext
lemma LeftHomologyData.mapHomologyIso_eq [S.HasHomology]
    [(S.map F).HasHomology] [F.PreservesLeftHomologyOf S] :
    S.mapHomologyIso F = (hl.map F).homologyIso ≪≫ F.mapIso hl.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.PreservesLeftHomologyOf F S
⊢ (mapHomologyIso S F).hom = (homologyIso (map hl F) ≪≫ F.mapIso (homologyIso hl).symm).hom

Next tactic:
dsimp only [mapHomologyIso, homologyIso, ShortComplex.leftHomologyIso,
    leftHomologyMapIso', leftHomologyIso, Functor.mapIso,
    Iso.symm, Iso.trans, Iso.refl]
lemma LeftHomologyData.mapHomologyIso_eq [S.HasHomology]
    [(S.map F).HasHomology] [F.PreservesLeftHomologyOf S] :
    S.mapHomologyIso F = (hl.map F).homologyIso ≪≫ F.mapIso hl.homologyIso.symm := by
  ext
  dsimp only [mapHomologyIso, homologyIso, ShortComplex.leftHomologyIso,
    leftHomologyMapIso', leftHomologyIso, Functor.mapIso,
    Iso.symm, Iso.trans, Iso.refl]
  

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.PreservesLeftHomologyOf F S
⊢ leftHomologyMap' (𝟙 (ShortComplex.map S F)) (homologyData (ShortComplex.map S F)).left
        (leftHomologyData (ShortComplex.map S F)) ≫
      leftHomologyMap' (𝟙 (ShortComplex.map S F)) (leftHomologyData (ShortComplex.map S F))
        (map (homologyData S).left F) =
    (leftHomologyMap' (𝟙 (ShortComplex.map S F)) (homologyData (ShortComplex.map S F)).left
          (leftHomologyData (ShortComplex.map S F)) ≫
        leftHomologyMap' (𝟙 (ShortComplex.map S F)) (leftHomologyData (ShortComplex.map S F)) (map hl F)) ≫
      F.map
        (leftHomologyMap' (𝟙 S) hl (leftHomologyData S) ≫
          leftHomologyMap' (𝟙 S) (leftHomologyData S) (homologyData S).left)

Next tactic:
simp only [F.map_comp, map_leftHomologyMap', ← leftHomologyMap'_comp, comp_id,
    Functor.map_id, Functor.mapShortComplex_obj]