l3lab/ntp-mathlib huggingface dataset:
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
⊢ Cofork.π (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0)) =
    Cofork.π (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F) ≫
      F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)

Next tactic:
simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
hg' : g' = F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)
⊢ RightHomologyData (ShortComplex.map S F)

Next tactic:
have wι : F.map h.ι ≫ g' = 0 := by rw [hg', ← F.map_comp, ι_g', F.map_zero]
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
  have wι : F.map h.ι ≫ g' = 0 := by 

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
hg' : g' = F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)
⊢ F.map h.ι ≫ g' = 0

Next tactic:
rw [hg', ← F.map_comp, ι_g', F.map_zero]
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
  have wι : F.map h.ι ≫ g' = 0 := by rw [hg', ← F.map_comp, ι_g', F.map_zero]
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
hg' : g' = F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)
wι : F.map h.ι ≫ g' = 0
⊢ RightHomologyData (ShortComplex.map S F)

Next tactic:
have hι : IsLimit (KernelFork.ofι (F.map h.ι) wι) := by
    let e : parallelPair g' 0 ≅ parallelPair (F.map h.g') 0 :=
      parallelPair.ext (Iso.refl _) (Iso.refl _) (by simpa using hg') (by simp)
    refine' IsLimit.postcomposeHomEquiv e _
      (IsLimit.ofIsoLimit (KernelFork.mapIsLimit _ h.hι' F) _)
    exact Fork.ext (Iso.refl _) (by simp)
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
  have wι : F.map h.ι ≫ g' = 0 := by rw [hg', ← F.map_comp, ι_g', F.map_zero]
  have hι : IsLimit (KernelFork.ofι (F.map h.ι) wι) := by
    

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
hg' : g' = F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)
wι : F.map h.ι ≫ g' = 0
⊢ IsLimit (KernelFork.ofι (F.map h.ι) wι)

Next tactic:
let e : parallelPair g' 0 ≅ parallelPair (F.map h.g') 0 :=
      parallelPair.ext (Iso.refl _) (Iso.refl _) (by simpa using hg') (by simp)
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
  have wι : F.map h.ι ≫ g' = 0 := by rw [hg', ← F.map_comp, ι_g', F.map_zero]
  have hι : IsLimit (KernelFork.ofι (F.map h.ι) wι) := by
    let e : parallelPair g' 0 ≅ parallelPair (F.map h.g') 0 :=
      parallelPair.ext (Iso.refl _) (Iso.refl _) (by 

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
hg' : g' = F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)
wι : F.map h.ι ≫ g' = 0
⊢ (parallelPair g' 0).map WalkingParallelPairHom.left ≫
      (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.one)).hom =
    (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.zero)).hom ≫
      (parallelPair (F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)) 0).map WalkingParallelPairHom.left

Next tactic:
simpa using hg'
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
  have wι : F.map h.ι ≫ g' = 0 := by rw [hg', ← F.map_comp, ι_g', F.map_zero]
  have hι : IsLimit (KernelFork.ofι (F.map h.ι) wι) := by
    let e : parallelPair g' 0 ≅ parallelPair (F.map h.g') 0 :=
      parallelPair.ext (Iso.refl _) (Iso.refl _) (by simpa using hg') (by 

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
hg' : g' = F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)
wι : F.map h.ι ≫ g' = 0
⊢ (parallelPair g' 0).map WalkingParallelPairHom.right ≫
      (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.one)).hom =
    (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.zero)).hom ≫
      (parallelPair (F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)) 0).map WalkingParallelPairHom.right

Next tactic:
simp
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
  have wι : F.map h.ι ≫ g' = 0 := by rw [hg', ← F.map_comp, ι_g', F.map_zero]
  have hι : IsLimit (KernelFork.ofι (F.map h.ι) wι) := by
    let e : parallelPair g' 0 ≅ parallelPair (F.map h.g') 0 :=
      parallelPair.ext (Iso.refl _) (Iso.refl _) (by simpa using hg') (by simp)
    

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
hg' : g' = F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)
wι : F.map h.ι ≫ g' = 0
e : parallelPair g' 0 ≅ parallelPair (F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)) 0 :=
  parallelPair.ext (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.zero))
    (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.one))
    (_ :
      (parallelPair g' 0).map WalkingParallelPairHom.left ≫
          (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.one)).hom =
        (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.zero)).hom ≫
          (parallelPair (F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)) 0).map WalkingParallelPairHom.left)
    (_ : 0 ≫ 𝟙 (F.obj S.X₃) = 𝟙 (F.obj h.Q) ≫ 0)
⊢ IsLimit (KernelFork.ofι (F.map h.ι) wι)

Next tactic:
refine' IsLimit.postcomposeHomEquiv e _
      (IsLimit.ofIsoLimit (KernelFork.mapIsLimit _ h.hι' F) _)
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
  have wι : F.map h.ι ≫ g' = 0 := by rw [hg', ← F.map_comp, ι_g', F.map_zero]
  have hι : IsLimit (KernelFork.ofι (F.map h.ι) wι) := by
    let e : parallelPair g' 0 ≅ parallelPair (F.map h.g') 0 :=
      parallelPair.ext (Iso.refl _) (Iso.refl _) (by simpa using hg') (by simp)
    refine' IsLimit.postcomposeHomEquiv e _
      (IsLimit.ofIsoLimit (KernelFork.mapIsLimit _ h.hι' F) _)
    

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
hg' : g' = F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)
wι : F.map h.ι ≫ g' = 0
e : parallelPair g' 0 ≅ parallelPair (F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)) 0 :=
  parallelPair.ext (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.zero))
    (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.one))
    (_ :
      (parallelPair g' 0).map WalkingParallelPairHom.left ≫
          (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.one)).hom =
        (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.zero)).hom ≫
          (parallelPair (F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)) 0).map WalkingParallelPairHom.left)
    (_ : 0 ≫ 𝟙 (F.obj S.X₃) = 𝟙 (F.obj h.Q) ≫ 0)
⊢ KernelFork.map (KernelFork.ofι h.ι (_ : h.ι ≫ CategoryTheory.ShortComplex.RightHomologyData.g' h = 0)) F ≅
    (Cones.postcompose e.hom).obj (KernelFork.ofι (F.map h.ι) wι)

Next tactic:
exact Fork.ext (Iso.refl _) (by simp)
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
  have wι : F.map h.ι ≫ g' = 0 := by rw [hg', ← F.map_comp, ι_g', F.map_zero]
  have hι : IsLimit (KernelFork.ofι (F.map h.ι) wι) := by
    let e : parallelPair g' 0 ≅ parallelPair (F.map h.g') 0 :=
      parallelPair.ext (Iso.refl _) (Iso.refl _) (by simpa using hg') (by simp)
    refine' IsLimit.postcomposeHomEquiv e _
      (IsLimit.ofIsoLimit (KernelFork.mapIsLimit _ h.hι' F) _)
    exact Fork.ext (Iso.refl _) (by 

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
hg' : g' = F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)
wι : F.map h.ι ≫ g' = 0
e : parallelPair g' 0 ≅ parallelPair (F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)) 0 :=
  parallelPair.ext (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.zero))
    (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.one))
    (_ :
      (parallelPair g' 0).map WalkingParallelPairHom.left ≫
          (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.one)).hom =
        (Iso.refl ((parallelPair g' 0).obj WalkingParallelPair.zero)).hom ≫
          (parallelPair (F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)) 0).map WalkingParallelPairHom.left)
    (_ : 0 ≫ 𝟙 (F.obj S.X₃) = 𝟙 (F.obj h.Q) ≫ 0)
⊢ (Iso.refl
          (KernelFork.map (KernelFork.ofι h.ι (_ : h.ι ≫ CategoryTheory.ShortComplex.RightHomologyData.g' h = 0))
              F).pt).hom ≫
      Fork.ι ((Cones.postcompose e.hom).obj (KernelFork.ofι (F.map h.ι) wι)) =
    Fork.ι (KernelFork.map (KernelFork.ofι h.ι (_ : h.ι ≫ CategoryTheory.ShortComplex.RightHomologyData.g' h = 0)) F)

Next tactic:
simp
/-- When a right homology data `h` of a short complex `S` is preserved by a functor `F`,
this is the induced right homology data `h.map F` for the short complex `S.map F`. -/
@[simps]
noncomputable def map : (S.map F).RightHomologyData := by
  have := IsPreservedBy.hf h F
  have := IsPreservedBy.hg' h F
  have wp : F.map S.f ≫ F.map h.p = 0 := by rw [← F.map_comp, h.wp, F.map_zero]
  have hp := CokernelCofork.mapIsColimit _ h.hp F
  let g' : F.obj h.Q ⟶ F.obj S.X₃ := hp.desc (CokernelCofork.ofπ (S.map F).g (S.map F).zero)
  have hg' : g' = F.map h.g' := by
    apply Cofork.IsColimit.hom_ext hp
    rw [Cofork.IsColimit.π_desc hp]
    simp only [Cofork.π_ofπ, CokernelCofork.map_π, map_g, ← F.map_comp, p_g']
  have wι : F.map h.ι ≫ g' = 0 := by rw [hg', ← F.map_comp, ι_g', F.map_zero]
  have hι : IsLimit (KernelFork.ofι (F.map h.ι) wι) := by
    let e : parallelPair g' 0 ≅ parallelPair (F.map h.g') 0 :=
      parallelPair.ext (Iso.refl _) (Iso.refl _) (by simpa using hg') (by simp)
    refine' IsLimit.postcomposeHomEquiv e _
      (IsLimit.ofIsoLimit (KernelFork.mapIsLimit _ h.hι' F) _)
    exact Fork.ext (Iso.refl _) (by simp)
  

Proof state:
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{?u.33603, u_1} C
inst✝⁴ : Category.{?u.33607, u_2} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
this✝ : PreservesColimit (parallelPair S.f 0) F
this : PreservesLimit (parallelPair (CategoryTheory.ShortComplex.RightHomologyData.g' h) 0) F
wp : F.map S.f ≫ F.map h.p = 0
hp : IsColimit (CokernelCofork.map (CokernelCofork.ofπ h.p (_ : S.f ≫ h.p = 0)) F)
g' : F.obj h.Q ⟶ F.obj S.X₃ :=
  IsColimit.desc hp
    (CokernelCofork.ofπ (ShortComplex.map S F).g (_ : (ShortComplex.map S F).f ≫ (ShortComplex.map S F).g = 0))
hg' : g' = F.map (CategoryTheory.ShortComplex.RightHomologyData.g' h)
wι : F.map h.ι ≫ g' = 0
hι : IsLimit (KernelFork.ofι (F.map h.ι) wι)
⊢ RightHomologyData (ShortComplex.map S F)

Next tactic:
exact
    { Q := F.obj h.Q
      H := F.obj h.H
      p := F.map h.p
      ι := F.map h.ι
      wp := wp
      hp := hp
      wι := wι
      hι := hι }
@[simp]
lemma map_g' : (h.map F).g' = F.map h.g' := 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 S₁ S₂ : ShortComplex C
h : RightHomologyData S
F : C ⥤ D
inst✝¹ : Functor.PreservesZeroMorphisms F
inst✝ : IsPreservedBy h F
⊢ g' (map h F) = F.map (g' h)

Next tactic:
rw [← cancel_epi (h.map F).p, p_g', map_g, map_p, ← F.map_comp, p_g']