@[nolint unusedHavesSuffices]
theorem coimageIsoImage_hom {X Y : C} (f : X ⟶ Y) :
    (coimageIsoImage F G i adj f).hom = Abelian.coimageImageComparison f := by
  -- porting note: the next `have` have been added, otherwise some instance were not found
  have : ∀ (X' Y' : C) (f' : X' ⟶ Y'), HasCokernel f' := inferInstance
  have : ∀ (X' Y' : C) (f' : X' ⟶ Y'), HasKernel f' := inferInstance
  have : ∀ (X' Y' : D) (f' : X' ⟶ Y'), HasCokernel f' := inferInstance
  have : ∀ (X' Y' : D) (f' : X' ⟶ Y'), HasKernel f' := inferInstance
  dsimp only [coimageIsoImage, Iso.instTransIso_trans, Iso.refl, Iso.trans, Iso.symm,
    Functor.mapIso, cokernelEpiComp, cokernelIso, cokernelCompIsIso_inv,
    asIso, coimageIsoImageAux, kernelCompMono]
  

Proof state:
C : Type u₁
inst✝⁸ : Category.{v, u₁} C
inst✝⁷ : Preadditive C
D : Type u₂
inst✝⁶ : Category.{v, u₂} D
inst✝⁵ : Abelian D
F : C ⥤ D
G : D ⥤ C
inst✝⁴ : Functor.PreservesZeroMorphisms G
i : F ⋙ G ≅ 𝟭 C
adj : G ⊣ F
inst✝³ : HasCokernels C
inst✝² : HasKernels C
inst✝¹ : PreservesFiniteLimits G
inst✝ : Functor.PreservesZeroMorphisms F
X Y : C
f : X ⟶ Y
this✝² : ∀ (X' Y' : C) (f' : X' ⟶ Y'), HasCokernel f'
this✝¹ : ∀ (X' Y' : C) (f' : X' ⟶ Y'), HasKernel f'
this✝ : ∀ (X' Y' : D) (f' : X' ⟶ Y'), HasCokernel f'
this : ∀ (X' Y' : D) (f' : X' ⟶ Y'), HasKernel f'
⊢ ((((((((𝟙 (Abelian.coimage f) ≫
                      cokernel.desc (kernel.ι f) (i.inv.app X ≫ cokernel.π (kernel.ι f ≫ i.inv.app X))
                          (_ : kernel.ι f ≫ i.inv.app X ≫ cokernel.π (kernel.ι f ≫ i.inv.app X) = 0) ≫
                        cokernel.desc (kernel.ι f ≫ i.inv.app X)
                            (cokernel.π (i.hom.app (kernel f) ≫ kernel.ι f ≫ i.inv.app X))
                            (_ :
                              (kernel.ι f ≫ i.inv.app X) ≫
                                  cokernel.π (i.hom.app (kernel f) ≫ kernel.ι f ≫ i.inv.app X) =
                                0) ≫
                          (cokernelIsoOfEq
                                (_ :
                                  (F ⋙ G).map (kernel.ι f) =
                                    i.hom.app (kernel f) ≫ (𝟭 C).map (kernel.ι f) ≫ i.inv.app X)).inv ≫
                            cokernelComparison (F.map (kernel.ι f)) G) ≫
                    G.map (cokernelIsoOfEq (_ : F.map (kernel.ι f) = kernelComparison f F ≫ kernel.ι (F.map f))).hom) ≫
                  G.map
                    (cokernel.desc (kernelComparison f F ≫ kernel.ι (F.map f)) (cokernel.π (kernel.ι (F.map f)))
                      (_ : (kernelComparison f F ≫ kernel.ι (F.map f)) ≫ cokernel.π (kernel.ι (F.map f)) = 0))) ≫
                𝟙 (G.obj (cokernel (kernel.ι (F.map f))))) ≫
              G.map (Abelian.coimageIsoImage (F.map f)).hom) ≫
            𝟙 (G.obj (Abelian.image (F.map f)))) ≫
          (PreservesKernel.iso G (cokernel.π (F.map f))).hom) ≫
        ((((((((kernelIsoOfEq
                            (_ :
                              G.map (cokernel.π (F.map f)) =
                                cokernel.π (G.map (F.map f)) ≫ cokernelComparison (F.map f) G)).hom ≫
                        kernel.lift (cokernel.π (G.map (F.map f)))
                          (kernel.ι (cokernel.π (G.map (F.map f)) ≫ cokernelComparison (F.map f) G))
                          (_ :
                            kernel.ι (cokernel.π (G.map (F.map f)) ≫ cokernelComparison (F.map f) G) ≫
                                cokernel.π (G.map (F.map f)) =
                              0)) ≫
                      (kernelIsoOfEq
                          (_ :
                            cokernel.π ((F ⋙ G).map f) =
                              cokernel.π (i.hom.app X ≫ (𝟭 C).map f ≫ i.inv.app Y) ≫
                                (cokernelIsoOfEq
                                    (_ : i.hom.app X ≫ (𝟭 C).map f ≫ i.inv.app Y = (F ⋙ G).map f)).hom)).hom) ≫
                    kernel.lift (cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y))
                      (kernel.ι
                        (cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y) ≫
                          (cokernelIsoOfEq (_ : i.hom.app X ≫ (𝟭 C).map f ≫ i.inv.app Y = (F ⋙ G).map f)).hom))
                      (_ :
                        kernel.ι
                              (cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y) ≫
                                (cokernelIsoOfEq (_ : i.hom.app X ≫ (𝟭 C).map f ≫ i.inv.app Y = (F ⋙ G).map f)).hom) ≫
                            cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y) =
                          0)) ≫
                  (kernelIsoOfEq
                      (_ :
                        cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y) =
                          cokernel.π (f ≫ i.inv.app Y) ≫
                            cokernel.desc (f ≫ i.inv.app Y) (cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y))
                              (_ : (f ≫ i.inv.app Y) ≫ cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y) = 0))).hom) ≫
                kernel.lift (cokernel.π (f ≫ i.inv.app Y))
                  (kernel.ι
                    (cokernel.π (f ≫ i.inv.app Y) ≫
                      cokernel.desc (f ≫ i.inv.app Y) (cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y))
                        (_ : (f ≫ i.inv.app Y) ≫ cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y) = 0)))
                  (_ :
                    kernel.ι
                          (cokernel.π (f ≫ i.inv.app Y) ≫
                            cokernel.desc (f ≫ i.inv.app Y) (cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y))
                              (_ : (f ≫ i.inv.app Y) ≫ cokernel.π (i.hom.app X ≫ f ≫ i.inv.app Y) = 0)) ≫
                        cokernel.π (f ≫ i.inv.app Y) =
                      0)) ≫
              (kernelIsoOfEq
                  (_ :
                    cokernel.π (f ≫ i.inv.app Y) =
                      inv (i.inv.app Y) ≫
                        cokernel.π f ≫
                          cokernel.desc f (i.inv.app Y ≫ cokernel.π (f ≫ i.inv.app Y))
                            (_ : f ≫ i.inv.app Y ≫ cokernel.π (f ≫ i.inv.app Y) = 0))).hom) ≫
            (kernelIsIsoComp (inv (i.inv.app Y))
                (cokernel.π f ≫
                  cokernel.desc f (i.inv.app Y ≫ cokernel.π (f ≫ i.inv.app Y))
                    (_ : f ≫ i.inv.app Y ≫ cokernel.π (f ≫ i.inv.app Y) = 0))).hom) ≫
          kernel.lift (cokernel.π f)
            (kernel.ι
              (cokernel.π f ≫
                cokernel.desc f (i.inv.app Y ≫ cokernel.π (f ≫ i.inv.app Y))
                  (_ : f ≫ i.inv.app Y ≫ cokernel.π (f ≫ i.inv.app Y) = 0)))
            (_ :
              kernel.ι
                    (cokernel.π f ≫
                      cokernel.desc f (i.inv.app Y ≫ cokernel.π (f ≫ i.inv.app Y))
                        (_ : f ≫ i.inv.app Y ≫ cokernel.π (f ≫ i.inv.app Y) = 0)) ≫
                  cokernel.π f =
                0)) ≫
      𝟙 (kernel (cokernel.π f)) =
    Abelian.coimageImageComparison f

Next tactic:
simpa only [← cancel_mono (Abelian.image.ι f), ← cancel_epi (Abelian.coimage.π f),
    Category.assoc, Category.id_comp, cokernel.π_desc_assoc,
    π_comp_cokernelIsoOfEq_inv_assoc, PreservesKernel.iso_hom,
    π_comp_cokernelComparison_assoc, ← G.map_comp_assoc, kernel.lift_ι,
    Abelian.coimage_image_factorisation, lift_comp_kernelIsoOfEq_hom_assoc,
    kernelIsIsoComp_hom, kernel.lift_ι_assoc, kernelIsoOfEq_hom_comp_ι_assoc,
    kernelComparison_comp_ι_assoc, π_comp_cokernelIsoOfEq_hom_assoc,
    asIso_hom, NatIso.inv_inv_app] using NatIso.naturality_1 i f