l3lab/ntp-mathlib huggingface dataset:
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  

Proof state:
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ ((kernelSubobjectIso g).inv ≫ kernelSubobjectMap β) ≫ cokernel.π (imageToKernel f' g' w') =
    kernel.map g g' α.right β.right (_ : g ≫ β.right = α.right ≫ g') ≫ π' f' g' w'

Next tactic:
have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    

Proof state:
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv

Next tactic:
rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    

Proof state:
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ kernelSubobjectMap β ≫ (kernelSubobjectIso (Arrow.mk g').hom).hom =
    (kernelSubobjectIso g).hom ≫
      kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom)

Next tactic:
ext
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    

Proof state:
case h
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ (kernelSubobjectMap β ≫ (kernelSubobjectIso (Arrow.mk g').hom).hom) ≫ equalizer.ι (Arrow.mk g').hom 0 =
    ((kernelSubobjectIso g).hom ≫
        kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
          (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom)) ≫
      equalizer.ι (Arrow.mk g').hom 0

Next tactic:
dsimp
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    

Proof state:
case h
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ (kernelSubobjectMap β ≫ (kernelSubobjectIso g').hom) ≫ kernel.ι g' =
    ((kernelSubobjectIso g).hom ≫ kernel.map g g' β.left β.right (_ : g ≫ β.right = β.left ≫ g')) ≫ kernel.ι g'

Next tactic:
simp
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
  

Proof state:
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
this :
  (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv
⊢ ((kernelSubobjectIso g).inv ≫ kernelSubobjectMap β) ≫ cokernel.π (imageToKernel f' g' w') =
    kernel.map g g' α.right β.right (_ : g ≫ β.right = α.right ≫ g') ≫ π' f' g' w'

Next tactic:
rw [this]
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
  rw [this]
  

Proof state:
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
this :
  (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv
⊢ (kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
          (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
        (kernelSubobjectIso (Arrow.mk g').hom).inv) ≫
      cokernel.π (imageToKernel f' g' w') =
    kernel.map g g' α.right β.right (_ : g ≫ β.right = α.right ≫ g') ≫ π' f' g' w'

Next tactic:
simp only [Category.assoc]
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
  rw [this]
  simp only [Category.assoc]
  

Proof state:
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
this :
  (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv
⊢ kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv ≫ cokernel.π (imageToKernel f' g' w') =
    kernel.map g g' α.right β.right (_ : g ≫ β.right = α.right ≫ g') ≫ π' f' g' w'

Next tactic:
dsimp [π', homology'IsoCokernelLift]
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
  rw [this]
  simp only [Category.assoc]
  dsimp [π', homology'IsoCokernelLift]
  

Proof state:
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
this :
  (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv
⊢ kernel.map g g' β.left β.right (_ : g ≫ β.right = β.left ≫ g') ≫
      (kernelSubobjectIso g').inv ≫ cokernel.π (imageToKernel f' g' w') =
    kernel.map g g' α.right β.right (_ : g ≫ β.right = α.right ≫ g') ≫
      cokernel.π (kernel.lift g' f' w') ≫
        ((cokernelIsoOfEq (_ : factorThruImage f' ≫ imageToKernel' f' g' w' = kernel.lift g' f' w')).inv ≫
            cokernel.desc (factorThruImage f' ≫ imageToKernel' f' g' w') (cokernel.π (imageToKernel' f' g' w'))
              (_ : (factorThruImage f' ≫ imageToKernel' f' g' w') ≫ cokernel.π (imageToKernel' f' g' w') = 0)) ≫
          (homology'IsoCokernelImageToKernel' f' g' w').inv

Next tactic:
simp only [cokernelIsoOfEq_inv_comp_desc, cokernel.π_desc_assoc]
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
  rw [this]
  simp only [Category.assoc]
  dsimp [π', homology'IsoCokernelLift]
  simp only [cokernelIsoOfEq_inv_comp_desc, cokernel.π_desc_assoc]
  

Proof state:
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
this :
  (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv
⊢ kernel.map g g' β.left β.right (_ : g ≫ β.right = β.left ≫ g') ≫
      (kernelSubobjectIso g').inv ≫ cokernel.π (imageToKernel f' g' w') =
    kernel.map g g' α.right β.right (_ : g ≫ β.right = α.right ≫ g') ≫
      cokernel.π (imageToKernel' f' g' w') ≫ (homology'IsoCokernelImageToKernel' f' g' w').inv

Next tactic:
congr 1
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
  rw [this]
  simp only [Category.assoc]
  dsimp [π', homology'IsoCokernelLift]
  simp only [cokernelIsoOfEq_inv_comp_desc, cokernel.π_desc_assoc]
  congr 1
  · 

Proof state:
case e_a
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
this :
  (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv
⊢ kernel.map g g' β.left β.right (_ : g ≫ β.right = β.left ≫ g') =
    kernel.map g g' α.right β.right (_ : g ≫ β.right = α.right ≫ g')

Next tactic:
congr
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
  rw [this]
  simp only [Category.assoc]
  dsimp [π', homology'IsoCokernelLift]
  simp only [cokernelIsoOfEq_inv_comp_desc, cokernel.π_desc_assoc]
  congr 1
  · congr
    

Proof state:
case e_a.e_p
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
this :
  (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv
⊢ β.left = α.right

Next tactic:
exact h.symm
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
  rw [this]
  simp only [Category.assoc]
  dsimp [π', homology'IsoCokernelLift]
  simp only [cokernelIsoOfEq_inv_comp_desc, cokernel.π_desc_assoc]
  congr 1
  · congr
    exact h.symm
  · 

Proof state:
case e_a
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
this :
  (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv
⊢ (kernelSubobjectIso g').inv ≫ cokernel.π (imageToKernel f' g' w') =
    cokernel.π (imageToKernel' f' g' w') ≫ (homology'IsoCokernelImageToKernel' f' g' w').inv

Next tactic:
rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
  rw [this]
  simp only [Category.assoc]
  dsimp [π', homology'IsoCokernelLift]
  simp only [cokernelIsoOfEq_inv_comp_desc, cokernel.π_desc_assoc]
  congr 1
  · congr
    exact h.symm
  · rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    

Proof state:
case e_a
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
this :
  (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv
⊢ cokernel.π (imageToKernel f' g' w') ≫ (homology'IsoCokernelImageToKernel' f' g' w').hom =
    (kernelSubobjectIso g').hom ≫ cokernel.π (imageToKernel' f' g' w')

Next tactic:
dsimp [homology'IsoCokernelImageToKernel']
@[reassoc (attr := simp)]
theorem π'_map (α β h) : π' _ _ _ ≫ map w w' α β h =
    kernel.map _ _ α.right β.right (by simp [h, β.w.symm]) ≫ π' _ _ _ := by
  apply_fun fun e => (kernelSubobjectIso _).hom ≫ e
  swap
  · intro i j hh
    apply_fun fun e => (kernelSubobjectIso _).inv ≫ e at hh
    simpa using hh
  dsimp [map]
  simp only [π'_eq_π_assoc]
  dsimp [π]
  simp only [cokernel.π_desc]
  rw [← Iso.inv_comp_eq, ← Category.assoc]
  have :
    (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
      kernel.map _ _ β.left β.right β.w.symm ≫ (kernelSubobjectIso _).inv := by
    rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    ext
    dsimp
    simp
  rw [this]
  simp only [Category.assoc]
  dsimp [π', homology'IsoCokernelLift]
  simp only [cokernelIsoOfEq_inv_comp_desc, cokernel.π_desc_assoc]
  congr 1
  · congr
    exact h.symm
  · rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv]
    dsimp [homology'IsoCokernelImageToKernel']
    

Proof state:
case e_a
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
this :
  (kernelSubobjectIso g).inv ≫ kernelSubobjectMap β =
    kernel.map (Arrow.mk g).hom (Arrow.mk g').hom β.left β.right
        (_ : (Arrow.mk g).hom ≫ (𝟭 A).map β.right = (𝟭 A).map β.left ≫ (Arrow.mk g').hom) ≫
      (kernelSubobjectIso (Arrow.mk g').hom).inv
⊢ cokernel.π (imageToKernel f' g' w') ≫
      cokernel.map (imageToKernel f' g' w') (imageToKernel' f' g' w') (imageSubobjectIso f').hom
        (kernelSubobjectIso g').hom
        (_ :
          imageToKernel f' g' w' ≫ (kernelSubobjectIso g').hom = (imageSubobjectIso f').hom ≫ imageToKernel' f' g' w') =
    (kernelSubobjectIso g').hom ≫ cokernel.π (imageToKernel' f' g' w')

Next tactic:
simp
theorem map_eq_desc'_lift_left (α β h) :
    map w w' α β h =
      homology'.desc' f g _ (homology'.lift f' g' _ (kernel.ι _ ≫ β.left ≫ cokernel.π _)
      (by 

Proof state:
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ (kernel.ι g ≫ β.left ≫ cokernel.π f') ≫ cokernel.desc f' g' w' = 0

Next tactic:
simp
theorem map_eq_desc'_lift_left (α β h) :
    map w w' α β h =
      homology'.desc' f g _ (homology'.lift f' g' _ (kernel.ι _ ≫ β.left ≫ cokernel.π _)
      (by simp)) (by
          

Proof state:
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ kernel.lift g f w ≫
      lift f' g' w' (kernel.ι g ≫ β.left ≫ cokernel.π f')
        (_ : (kernel.ι g ≫ β.left ≫ cokernel.π f') ≫ cokernel.desc f' g' w' = 0) =
    0

Next tactic:
ext
theorem map_eq_desc'_lift_left (α β h) :
    map w w' α β h =
      homology'.desc' f g _ (homology'.lift f' g' _ (kernel.ι _ ≫ β.left ≫ cokernel.π _)
      (by simp)) (by
          ext
          

Proof state:
case h
A : Type u
inst✝¹ : Category.{v, u} A
inst✝ : Abelian A
X Y Z : A
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
X' Y' Z' : A
f' : X' ⟶ Y'
g' : Y' ⟶ Z'
w' : f' ≫ g' = 0
α : Arrow.mk f ⟶ Arrow.mk f'
β : Arrow.mk g ⟶ Arrow.mk g'
h : α.right = β.left
⊢ (kernel.lift g f w ≫
        lift f' g' w' (kernel.ι g ≫ β.left ≫ cokernel.π f')
          (_ : (kernel.ι g ≫ β.left ≫ cokernel.π f') ≫ cokernel.desc f' g' w' = 0)) ≫
      ι f' g' w' =
    0 ≫ ι f' g' w'

Next tactic:
simp only [← h, Category.assoc, zero_comp, lift_ι, kernel.lift_ι_assoc]