File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

full_name: CategoryTheory.ShortComplex.Exact
code: /-- The assertion that the short complex `S : ShortComplex C` is exact. -/
structure Exact : Prop where
  /-- the condition that there exists an homology data whose `left.H` field is zero -/
  condition : ∃ (h : S.HomologyData), IsZero h.left.H
goal: Prop

full_name: CategoryTheory.ShortComplex.Exact.condition
code: /-- The assertion that the short complex `S : ShortComplex C` is exact. -/
structure Exact : Prop where
  /-- the condition that there exists an homology data whose `left.H` field is zero -/
  condition : ∃ (h : S.HomologyData), IsZero h.left.H
goal: ∃ h, CategoryTheory.Limits.IsZero h.left.H

full_name: CategoryTheory.ShortComplex.Exact.hasHomology
code: lemma Exact.hasHomology (h : S.Exact) : S.HasHomology 
goal: S.HasHomology

full_name: CategoryTheory.ShortComplex.Exact.hasZeroObject
code: lemma Exact.hasZeroObject (h : S.Exact) : HasZeroObject C 
goal: CategoryTheory.Limits.HasZeroObject C

full_name: CategoryTheory.ShortComplex.exact_iff_isZero_homology
code: lemma exact_iff_isZero_homology [S.HasHomology] :
    S.Exact ↔ IsZero S.homology 
goal: S.Exact ↔ CategoryTheory.Limits.IsZero S.homology

full_name: CategoryTheory.ShortComplex.LeftHomologyData.exact_iff
code: lemma LeftHomologyData.exact_iff [S.HasHomology]
    (h : S.LeftHomologyData) :
    S.Exact ↔ IsZero h.H 
goal: S.Exact ↔ CategoryTheory.Limits.IsZero h.H

full_name: CategoryTheory.ShortComplex.RightHomologyData.exact_iff
code: lemma RightHomologyData.exact_iff [S.HasHomology]
    (h : S.RightHomologyData) :
    S.Exact ↔ IsZero h.H 
goal: S.Exact ↔ CategoryTheory.Limits.IsZero h.H

full_name: CategoryTheory.ShortComplex.exact_iff_isZero_leftHomology
code: lemma exact_iff_isZero_leftHomology [S.HasHomology] :
    S.Exact ↔ IsZero S.leftHomology 
goal: S.Exact ↔ CategoryTheory.Limits.IsZero S.leftHomology

full_name: CategoryTheory.ShortComplex.exact_iff_isZero_rightHomology
code: lemma exact_iff_isZero_rightHomology [S.HasHomology] :
    S.Exact ↔ IsZero S.rightHomology 
goal: S.Exact ↔ CategoryTheory.Limits.IsZero S.rightHomology

full_name: CategoryTheory.ShortComplex.HomologyData.exact_iff
code: lemma HomologyData.exact_iff (h : S.HomologyData) :
    S.Exact ↔ IsZero h.left.H 
goal: S.Exact ↔ CategoryTheory.Limits.IsZero h.left.H

full_name: CategoryTheory.ShortComplex.HomologyData.exact_iff'
code: lemma HomologyData.exact_iff' (h : S.HomologyData) :
    S.Exact ↔ IsZero h.right.H 
goal: S.Exact ↔ CategoryTheory.Limits.IsZero h.right.H

full_name: CategoryTheory.ShortComplex.exact_iff_homology_iso_zero
code: lemma exact_iff_homology_iso_zero [S.HasHomology] [HasZeroObject C] :
    S.Exact ↔ Nonempty (S.homology ≅ 0) 
goal: S.Exact ↔ Nonempty (S.homology ≅ 0)

full_name: CategoryTheory.ShortComplex.exact_of_iso
code: lemma exact_of_iso (e : S₁ ≅ S₂) (h : S₁.Exact) : S₂.Exact 
goal: S₂.Exact

full_name: CategoryTheory.ShortComplex.exact_iff_of_iso
code: lemma exact_iff_of_iso (e : S₁ ≅ S₂) : S₁.Exact ↔ S₂.Exact 
goal: S₁.Exact ↔ S₂.Exact

full_name: CategoryTheory.ShortComplex.exact_and_mono_f_iff_of_iso
code: lemma exact_and_mono_f_iff_of_iso (e : S₁ ≅ S₂) :
    S₁.Exact ∧ Mono S₁.f ↔ S₂.Exact ∧ Mono S₂.f 
goal: S₁.Exact ∧ CategoryTheory.Mono S₁.f ↔ S₂.Exact ∧ CategoryTheory.Mono S₂.f

full_name: CategoryTheory.ShortComplex.exact_and_epi_g_iff_of_iso
code: lemma exact_and_epi_g_iff_of_iso (e : S₁ ≅ S₂) :
    S₁.Exact ∧ Epi S₁.g ↔ S₂.Exact ∧ Epi S₂.g 
goal: S₁.Exact ∧ CategoryTheory.Epi S₁.g ↔ S₂.Exact ∧ CategoryTheory.Epi S₂.g

full_name: CategoryTheory.ShortComplex.exact_of_isZero_X₂
code: lemma exact_of_isZero_X₂ (h : IsZero S.X₂) : S.Exact 
goal: S.Exact

full_name: CategoryTheory.ShortComplex.exact_iff_of_epi_of_isIso_of_mono
code: lemma exact_iff_of_epi_of_isIso_of_mono (φ : S₁ ⟶ S₂) [Epi φ.τ₁] [IsIso φ.τ₂] [Mono φ.τ₃] :
    S₁.Exact ↔ S₂.Exact 
goal: S₁.Exact ↔ S₂.Exact

full_name: CategoryTheory.ShortComplex.HomologyData.exact_iff_i_p_zero
code: lemma HomologyData.exact_iff_i_p_zero (h : S.HomologyData) :
    S.Exact ↔ h.left.i ≫ h.right.p = 0 
goal: S.Exact ↔ CategoryTheory.CategoryStruct.comp h.left.i h.right.p = 0

full_name: CategoryTheory.ShortComplex.exact_iff_i_p_zero
code: lemma exact_iff_i_p_zero [S.HasHomology] (h₁ : S.LeftHomologyData)
    (h₂ : S.RightHomologyData) :
    S.Exact ↔ h₁.i ≫ h₂.p = 0 
goal: S.Exact ↔ CategoryTheory.CategoryStruct.comp h₁.i h₂.p = 0

full_name: CategoryTheory.ShortComplex.exact_iff_iCycles_pOpcycles_zero
code: lemma exact_iff_iCycles_pOpcycles_zero [S.HasHomology] :
    S.Exact ↔ S.iCycles ≫ S.pOpcycles = 0 
goal: S.Exact ↔ CategoryTheory.CategoryStruct.comp S.iCycles S.pOpcycles = 0

full_name: CategoryTheory.ShortComplex.exact_iff_kernel_ι_comp_cokernel_π_zero
code: lemma exact_iff_kernel_ι_comp_cokernel_π_zero [S.HasHomology]
    [HasKernel S.g] [HasCokernel S.f] :
    S.Exact ↔ kernel.ι S.g ≫ cokernel.π S.f = 0 
goal: S.Exact ↔
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι S.g) (CategoryTheory.Limits.cokernel.π S.f) = 0

full_name: CategoryTheory.ShortComplex.Exact.op
code: lemma Exact.op (h : S.Exact) : S.op.Exact 
goal: S.op.Exact

full_name: CategoryTheory.ShortComplex.Exact.unop
code: lemma Exact.unop {S : ShortComplex Cᵒᵖ} (h : S.Exact) : S.unop.Exact 
goal: S.unop.Exact

full_name: CategoryTheory.ShortComplex.exact_op_iff
code: @[simp]
lemma exact_op_iff : S.op.Exact ↔ S.Exact 
goal: S.op.Exact ↔ S.Exact

full_name: CategoryTheory.ShortComplex.exact_unop_iff
code: @[simp]
lemma exact_unop_iff (S : ShortComplex Cᵒᵖ) : S.unop.Exact ↔ S.Exact 
goal: S.unop.Exact ↔ S.Exact

full_name: CategoryTheory.ShortComplex.LeftHomologyData.exact_map_iff
code: lemma LeftHomologyData.exact_map_iff (h : S.LeftHomologyData) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [h.IsPreservedBy F] [(S.map F).HasHomology] :
    (S.map F).Exact ↔ IsZero (F.obj h.H) 
goal: (S.map F).Exact ↔ CategoryTheory.Limits.IsZero (F.obj h.H)

full_name: CategoryTheory.ShortComplex.RightHomologyData.exact_map_iff
code: lemma RightHomologyData.exact_map_iff (h : S.RightHomologyData) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [h.IsPreservedBy F] [(S.map F).HasHomology] :
    (S.map F).Exact ↔ IsZero (F.obj h.H) 
goal: (S.map F).Exact ↔ CategoryTheory.Limits.IsZero (F.obj h.H)

full_name: CategoryTheory.ShortComplex.Exact.map_of_preservesLeftHomologyOf
code: lemma Exact.map_of_preservesLeftHomologyOf (h : S.Exact) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [F.PreservesLeftHomologyOf S]
    [(S.map F).HasHomology] : (S.map F).Exact 
goal: (S.map F).Exact

full_name: CategoryTheory.ShortComplex.Exact.map_of_preservesRightHomologyOf
code: lemma Exact.map_of_preservesRightHomologyOf (h : S.Exact) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [F.PreservesRightHomologyOf S]
    [(S.map F).HasHomology] : (S.map F).Exact 
goal: (S.map F).Exact

full_name: CategoryTheory.ShortComplex.Exact.map
code: lemma Exact.map (h : S.Exact) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] : (S.map F).Exact 
goal: (S.map F).Exact

full_name: CategoryTheory.ShortComplex.exact_map_iff_of_faithful
code: lemma exact_map_iff_of_faithful [S.HasHomology]
    (F : C ⥤ D) [F.PreservesZeroMorphisms] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] [F.Faithful] :
    (S.map F).Exact ↔ S.Exact 
goal: (S.map F).Exact ↔ S.Exact

full_name: CategoryTheory.ShortComplex.Exact.comp_eq_zero
code: @[reassoc]
lemma Exact.comp_eq_zero (h : S.Exact) {X Y : C} {a : X ⟶ S.X₂} (ha : a ≫ S.g = 0)
    {b : S.X₂ ⟶ Y} (hb : S.f ≫ b = 0) : a ≫ b = 0 
goal: CategoryTheory.CategoryStruct.comp a b = 0

full_name: CategoryTheory.ShortComplex.Exact.isZero_of_both_zeros
code: lemma Exact.isZero_of_both_zeros (ex : S.Exact) (hf : S.f = 0) (hg : S.g = 0) :
    IsZero S.X₂ 
goal: CategoryTheory.Limits.IsZero S.X₂

full_name: CategoryTheory.ShortComplex.exact_iff_mono
code: lemma exact_iff_mono [HasZeroObject C] (hf : S.f = 0) :
    S.Exact ↔ Mono S.g 
goal: S.Exact ↔ CategoryTheory.Mono S.g

full_name: CategoryTheory.ShortComplex.exact_iff_epi
code: lemma exact_iff_epi [HasZeroObject C] (hg : S.g = 0) :
    S.Exact ↔ Epi S.f 
goal: S.Exact ↔ CategoryTheory.Epi S.f

full_name: CategoryTheory.ShortComplex.Exact.epi_f'
code: lemma Exact.epi_f' (hS : S.Exact) (h : LeftHomologyData S) : Epi h.f' 
goal: CategoryTheory.Epi h.f'

full_name: CategoryTheory.ShortComplex.Exact.mono_g'
code: lemma Exact.mono_g' (hS : S.Exact) (h : RightHomologyData S) : Mono h.g' 
goal: CategoryTheory.Mono h.g'

full_name: CategoryTheory.ShortComplex.Exact.epi_toCycles
code: lemma Exact.epi_toCycles (hS : S.Exact) [S.HasLeftHomology] : Epi S.toCycles 
goal: CategoryTheory.Epi S.toCycles

full_name: CategoryTheory.ShortComplex.Exact.mono_fromOpcycles
code: lemma Exact.mono_fromOpcycles (hS : S.Exact) [S.HasRightHomology] : Mono S.fromOpcycles 
goal: CategoryTheory.Mono S.fromOpcycles

full_name: CategoryTheory.ShortComplex.LeftHomologyData.exact_iff_epi_f'
code: lemma LeftHomologyData.exact_iff_epi_f' [S.HasHomology] (h : LeftHomologyData S) :
    S.Exact ↔ Epi h.f' 
goal: S.Exact ↔ CategoryTheory.Epi h.f'

full_name: CategoryTheory.ShortComplex.RightHomologyData.exact_iff_mono_g'
code: lemma RightHomologyData.exact_iff_mono_g' [S.HasHomology] (h : RightHomologyData S) :
    S.Exact ↔ Mono h.g' 
goal: S.Exact ↔ CategoryTheory.Mono h.g'

full_name: CategoryTheory.ShortComplex.Exact.leftHomologyDataOfIsLimitKernelFork_i
code: /-- Given an exact short complex `S` and a limit kernel fork `kf` for `S.g`, this is the
left homology data for `S` with `K := kf.pt` and `H := 0`. -/
@[simps]
noncomputable def Exact.leftHomologyDataOfIsLimitKernelFork
    (hS : S.Exact) [HasZeroObject C] (kf : KernelFork S.g) (hkf : IsLimit kf) :
    S.LeftHomologyData 
goal: (hS.leftHomologyDataOfIsLimitKernelFork kf hkf).i = CategoryTheory.Limits.Fork.ι kf

full_name: CategoryTheory.ShortComplex.Exact.leftHomologyDataOfIsLimitKernelFork_π
code: /-- Given an exact short complex `S` and a limit kernel fork `kf` for `S.g`, this is the
left homology data for `S` with `K := kf.pt` and `H := 0`. -/
@[simps]
noncomputable def Exact.leftHomologyDataOfIsLimitKernelFork
    (hS : S.Exact) [HasZeroObject C] (kf : KernelFork S.g) (hkf : IsLimit kf) :
    S.LeftHomologyData 
goal: (hS.leftHomologyDataOfIsLimitKernelFork kf hkf).π = 0

full_name: CategoryTheory.ShortComplex.Exact.leftHomologyDataOfIsLimitKernelFork_H
code: /-- Given an exact short complex `S` and a limit kernel fork `kf` for `S.g`, this is the
left homology data for `S` with `K := kf.pt` and `H := 0`. -/
@[simps]
noncomputable def Exact.leftHomologyDataOfIsLimitKernelFork
    (hS : S.Exact) [HasZeroObject C] (kf : KernelFork S.g) (hkf : IsLimit kf) :
    S.LeftHomologyData 
goal: (hS.leftHomologyDataOfIsLimitKernelFork kf hkf).H = 0

full_name: CategoryTheory.ShortComplex.Exact.leftHomologyDataOfIsLimitKernelFork
code: /-- Given an exact short complex `S` and a limit kernel fork `kf` for `S.g`, this is the
left homology data for `S` with `K := kf.pt` and `H := 0`. -/
@[simps]
noncomputable def Exact.leftHomologyDataOfIsLimitKernelFork
    (hS : S.Exact) [HasZeroObject C] (kf : KernelFork S.g) (hkf : IsLimit kf) :
    S.LeftHomologyData 
goal: S.LeftHomologyData

full_name: CategoryTheory.ShortComplex.Exact.leftHomologyDataOfIsLimitKernelFork_K
code: /-- Given an exact short complex `S` and a limit kernel fork `kf` for `S.g`, this is the
left homology data for `S` with `K := kf.pt` and `H := 0`. -/
@[simps]
noncomputable def Exact.leftHomologyDataOfIsLimitKernelFork
    (hS : S.Exact) [HasZeroObject C] (kf : KernelFork S.g) (hkf : IsLimit kf) :
    S.LeftHomologyData 
goal: (hS.leftHomologyDataOfIsLimitKernelFork kf hkf).K = kf.pt

full_name: CategoryTheory.ShortComplex.Exact.rightHomologyDataOfIsColimitCokernelCofork
code: /-- Given an exact short complex `S` and a colimit cokernel cofork `cc` for `S.f`, this is the
right homology data for `S` with `Q := cc.pt` and `H := 0`. -/
@[simps]
noncomputable def Exact.rightHomologyDataOfIsColimitCokernelCofork
    (hS : S.Exact) [HasZeroObject C] (cc : CokernelCofork S.f) (hcc : IsColimit cc) :
    S.RightHomologyData 
goal: S.RightHomologyData

full_name: CategoryTheory.ShortComplex.Exact.rightHomologyDataOfIsColimitCokernelCofork_ι
code: /-- Given an exact short complex `S` and a colimit cokernel cofork `cc` for `S.f`, this is the
right homology data for `S` with `Q := cc.pt` and `H := 0`. -/
@[simps]
noncomputable def Exact.rightHomologyDataOfIsColimitCokernelCofork
    (hS : S.Exact) [HasZeroObject C] (cc : CokernelCofork S.f) (hcc : IsColimit cc) :
    S.RightHomologyData 
goal: (hS.rightHomologyDataOfIsColimitCokernelCofork cc hcc).ι = 0

full_name: CategoryTheory.ShortComplex.Exact.rightHomologyDataOfIsColimitCokernelCofork_Q
code: /-- Given an exact short complex `S` and a colimit cokernel cofork `cc` for `S.f`, this is the
right homology data for `S` with `Q := cc.pt` and `H := 0`. -/
@[simps]
noncomputable def Exact.rightHomologyDataOfIsColimitCokernelCofork
    (hS : S.Exact) [HasZeroObject C] (cc : CokernelCofork S.f) (hcc : IsColimit cc) :
    S.RightHomologyData 
goal: (hS.rightHomologyDataOfIsColimitCokernelCofork cc hcc).Q = cc.pt

full_name: CategoryTheory.ShortComplex.Exact.rightHomologyDataOfIsColimitCokernelCofork_p
code: /-- Given an exact short complex `S` and a colimit cokernel cofork `cc` for `S.f`, this is the
right homology data for `S` with `Q := cc.pt` and `H := 0`. -/
@[simps]
noncomputable def Exact.rightHomologyDataOfIsColimitCokernelCofork
    (hS : S.Exact) [HasZeroObject C] (cc : CokernelCofork S.f) (hcc : IsColimit cc) :
    S.RightHomologyData 
goal: (hS.rightHomologyDataOfIsColimitCokernelCofork cc hcc).p = CategoryTheory.Limits.Cofork.π cc

full_name: CategoryTheory.ShortComplex.Exact.rightHomologyDataOfIsColimitCokernelCofork_H
code: /-- Given an exact short complex `S` and a colimit cokernel cofork `cc` for `S.f`, this is the
right homology data for `S` with `Q := cc.pt` and `H := 0`. -/
@[simps]
noncomputable def Exact.rightHomologyDataOfIsColimitCokernelCofork
    (hS : S.Exact) [HasZeroObject C] (cc : CokernelCofork S.f) (hcc : IsColimit cc) :
    S.RightHomologyData 
goal: (hS.rightHomologyDataOfIsColimitCokernelCofork cc hcc).H = 0

full_name: CategoryTheory.ShortComplex.exact_iff_epi_toCycles
code: lemma exact_iff_epi_toCycles [S.HasHomology] : S.Exact ↔ Epi S.toCycles 
goal: S.Exact ↔ CategoryTheory.Epi S.toCycles

full_name: CategoryTheory.ShortComplex.exact_iff_mono_fromOpcycles
code: lemma exact_iff_mono_fromOpcycles [S.HasHomology] : S.Exact ↔ Mono S.fromOpcycles 
goal: S.Exact ↔ CategoryTheory.Mono S.fromOpcycles

full_name: CategoryTheory.ShortComplex.exact_iff_epi_kernel_lift
code: lemma exact_iff_epi_kernel_lift [S.HasHomology] [HasKernel S.g] :
    S.Exact ↔ Epi (kernel.lift S.g S.f S.zero) 
goal: S.Exact ↔ CategoryTheory.Epi (CategoryTheory.Limits.kernel.lift S.g S.f ⋯)

full_name: CategoryTheory.ShortComplex.exact_iff_mono_cokernel_desc
code: lemma exact_iff_mono_cokernel_desc [S.HasHomology] [HasCokernel S.f] :
    S.Exact ↔ Mono (cokernel.desc S.f S.g S.zero) 
goal: S.Exact ↔ CategoryTheory.Mono (CategoryTheory.Limits.cokernel.desc S.f S.g ⋯)

full_name: CategoryTheory.ShortComplex.QuasiIso.exact_iff
code: lemma QuasiIso.exact_iff {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    [S₁.HasHomology] [S₂.HasHomology] [QuasiIso φ] : S₁.Exact ↔ S₂.Exact 
goal: S₁.Exact ↔ S₂.Exact

full_name: CategoryTheory.ShortComplex.exact_of_f_is_kernel
code: lemma exact_of_f_is_kernel (hS : IsLimit (KernelFork.ofι S.f S.zero))
    [S.HasHomology] : S.Exact 
goal: S.Exact

full_name: CategoryTheory.ShortComplex.exact_of_g_is_cokernel
code: lemma exact_of_g_is_cokernel (hS : IsColimit (CokernelCofork.ofπ S.g S.zero))
    [S.HasHomology] : S.Exact 
goal: S.Exact

full_name: CategoryTheory.ShortComplex.Exact.mono_g
code: lemma Exact.mono_g (hS : S.Exact) (hf : S.f = 0) : Mono S.g 
goal: CategoryTheory.Mono S.g

full_name: CategoryTheory.ShortComplex.Exact.epi_f
code: lemma Exact.epi_f (hS : S.Exact) (hg : S.g = 0) : Epi S.f 
goal: CategoryTheory.Epi S.f

full_name: CategoryTheory.ShortComplex.Exact.mono_g_iff
code: lemma Exact.mono_g_iff (hS : S.Exact) : Mono S.g ↔ S.f = 0 
goal: CategoryTheory.Mono S.g ↔ S.f = 0

full_name: CategoryTheory.ShortComplex.Exact.epi_f_iff
code: lemma Exact.epi_f_iff (hS : S.Exact) : Epi S.f ↔ S.g = 0 
goal: CategoryTheory.Epi S.f ↔ S.g = 0

full_name: CategoryTheory.ShortComplex.Exact.isZero_X₂
code: lemma Exact.isZero_X₂ (hS : S.Exact) (hf : S.f = 0) (hg : S.g = 0) : IsZero S.X₂ 
goal: CategoryTheory.Limits.IsZero S.X₂

full_name: CategoryTheory.ShortComplex.Exact.isZero_X₂_iff
code: lemma Exact.isZero_X₂_iff (hS : S.Exact) : IsZero S.X₂ ↔ S.f = 0 ∧ S.g = 0 
goal: CategoryTheory.Limits.IsZero S.X₂ ↔ S.f = 0 ∧ S.g = 0

full_name: CategoryTheory.ShortComplex.Splitting.s
code: /-- A splitting for a short complex `S` consists of the data of a retraction `r : X₂ ⟶ X₁`
of `S.f` and section `s : X₃ ⟶ X₂` of `S.g` which satisfy `r ≫ S.f + S.g ≫ s = 𝟙 _` -/
structure Splitting (S : ShortComplex C) where
  /-- a retraction of `S.f` -/
  r : S.X₂ ⟶ S.X₁
  /-- a section of `S.g` -/
  s : S.X₃ ⟶ S.X₂
  /-- the condition that `r` is a retraction of `S.f` -/
  f_r : S.f ≫ r = 𝟙 _ := by aesop_cat
  /-- the condition that `s` is a section of `S.g` -/
  s_g : s ≫ S.g = 𝟙 _ := by aesop_cat
  /-- the compatibility between the given section and retraction -/
  id : r ≫ S.f + S.g ≫ s = 𝟙 _ := by aesop_cat
goal: S.X₃ ⟶ S.X₂

full_name: CategoryTheory.ShortComplex.Splitting.id
code: /-- A splitting for a short complex `S` consists of the data of a retraction `r : X₂ ⟶ X₁`
of `S.f` and section `s : X₃ ⟶ X₂` of `S.g` which satisfy `r ≫ S.f + S.g ≫ s = 𝟙 _` -/
structure Splitting (S : ShortComplex C) where
  /-- a retraction of `S.f` -/
  r : S.X₂ ⟶ S.X₁
  /-- a section of `S.g` -/
  s : S.X₃ ⟶ S.X₂
  /-- the condition that `r` is a retraction of `S.f` -/
  f_r : S.f ≫ r = 𝟙 _ := by aesop_cat
  /-- the condition that `s` is a section of `S.g` -/
  s_g : s ≫ S.g = 𝟙 _ := by aesop_cat
  /-- the compatibility between the given section and retraction -/
  id : r ≫ S.f + S.g ≫ s = 𝟙 _ := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp self.r S.f + CategoryTheory.CategoryStruct.comp S.g self.s =
  CategoryTheory.CategoryStruct.id S.X₂

full_name: CategoryTheory.ShortComplex.Splitting.r
code: /-- A splitting for a short complex `S` consists of the data of a retraction `r : X₂ ⟶ X₁`
of `S.f` and section `s : X₃ ⟶ X₂` of `S.g` which satisfy `r ≫ S.f + S.g ≫ s = 𝟙 _` -/
structure Splitting (S : ShortComplex C) where
  /-- a retraction of `S.f` -/
  r : S.X₂ ⟶ S.X₁
  /-- a section of `S.g` -/
  s : S.X₃ ⟶ S.X₂
  /-- the condition that `r` is a retraction of `S.f` -/
  f_r : S.f ≫ r = 𝟙 _ := by aesop_cat
  /-- the condition that `s` is a section of `S.g` -/
  s_g : s ≫ S.g = 𝟙 _ := by aesop_cat
  /-- the compatibility between the given section and retraction -/
  id : r ≫ S.f + S.g ≫ s = 𝟙 _ := by aesop_cat
goal: S.X₂ ⟶ S.X₁

full_name: CategoryTheory.ShortComplex.Splitting.s_g
code: /-- A splitting for a short complex `S` consists of the data of a retraction `r : X₂ ⟶ X₁`
of `S.f` and section `s : X₃ ⟶ X₂` of `S.g` which satisfy `r ≫ S.f + S.g ≫ s = 𝟙 _` -/
structure Splitting (S : ShortComplex C) where
  /-- a retraction of `S.f` -/
  r : S.X₂ ⟶ S.X₁
  /-- a section of `S.g` -/
  s : S.X₃ ⟶ S.X₂
  /-- the condition that `r` is a retraction of `S.f` -/
  f_r : S.f ≫ r = 𝟙 _ := by aesop_cat
  /-- the condition that `s` is a section of `S.g` -/
  s_g : s ≫ S.g = 𝟙 _ := by aesop_cat
  /-- the compatibility between the given section and retraction -/
  id : r ≫ S.f + S.g ≫ s = 𝟙 _ := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp self.s S.g = CategoryTheory.CategoryStruct.id S.X₃

full_name: CategoryTheory.ShortComplex.Splitting.f_r
code: /-- A splitting for a short complex `S` consists of the data of a retraction `r : X₂ ⟶ X₁`
of `S.f` and section `s : X₃ ⟶ X₂` of `S.g` which satisfy `r ≫ S.f + S.g ≫ s = 𝟙 _` -/
structure Splitting (S : ShortComplex C) where
  /-- a retraction of `S.f` -/
  r : S.X₂ ⟶ S.X₁
  /-- a section of `S.g` -/
  s : S.X₃ ⟶ S.X₂
  /-- the condition that `r` is a retraction of `S.f` -/
  f_r : S.f ≫ r = 𝟙 _ := by aesop_cat
  /-- the condition that `s` is a section of `S.g` -/
  s_g : s ≫ S.g = 𝟙 _ := by aesop_cat
  /-- the compatibility between the given section and retraction -/
  id : r ≫ S.f + S.g ≫ s = 𝟙 _ := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp S.f self.r = CategoryTheory.CategoryStruct.id S.X₁

full_name: CategoryTheory.ShortComplex.Splitting
code: /-- A splitting for a short complex `S` consists of the data of a retraction `r : X₂ ⟶ X₁`
of `S.f` and section `s : X₃ ⟶ X₂` of `S.g` which satisfy `r ≫ S.f + S.g ≫ s = 𝟙 _` -/
structure Splitting (S : ShortComplex C) where
  /-- a retraction of `S.f` -/
  r : S.X₂ ⟶ S.X₁
  /-- a section of `S.g` -/
  s : S.X₃ ⟶ S.X₂
  /-- the condition that `r` is a retraction of `S.f` -/
  f_r : S.f ≫ r = 𝟙 _ := by aesop_cat
  /-- the condition that `s` is a section of `S.g` -/
  s_g : s ≫ S.g = 𝟙 _ := by aesop_cat
  /-- the compatibility between the given section and retraction -/
  id : r ≫ S.f + S.g ≫ s = 𝟙 _ := by aesop_cat
goal: Type u_3

full_name: CategoryTheory.ShortComplex.Splitting.r_f
code: @[reassoc]
lemma r_f (s : S.Splitting) : s.r ≫ S.f = 𝟙 _ - S.g ≫ s.s 
goal: CategoryTheory.CategoryStruct.comp s.r S.f =
  CategoryTheory.CategoryStruct.id S.X₂ - CategoryTheory.CategoryStruct.comp S.g s.s

full_name: CategoryTheory.ShortComplex.Splitting.g_s
code: @[reassoc]
lemma g_s (s : S.Splitting) : S.g ≫ s.s = 𝟙 _ - s.r ≫ S.f 
goal: CategoryTheory.CategoryStruct.comp S.g s.s =
  CategoryTheory.CategoryStruct.id S.X₂ - CategoryTheory.CategoryStruct.comp s.r S.f

full_name: CategoryTheory.ShortComplex.Splitting.splitMono_f
code: /-- Given a splitting of a short complex `S`, this shows that `S.f` is a split monomorphism. -/
@[simps] def splitMono_f (s : S.Splitting) : SplitMono S.f 
goal: CategoryTheory.SplitMono S.f

full_name: CategoryTheory.ShortComplex.Splitting.splitMono_f_retraction
code: /-- Given a splitting of a short complex `S`, this shows that `S.f` is a split monomorphism. -/
@[simps] def splitMono_f (s : S.Splitting) : SplitMono S.f 
goal: s.splitMono_f.retraction = s.r

full_name: CategoryTheory.ShortComplex.Splitting.isSplitMono_f
code: lemma isSplitMono_f (s : S.Splitting) : IsSplitMono S.f 
goal: CategoryTheory.IsSplitMono S.f

full_name: CategoryTheory.ShortComplex.Splitting.mono_f
code: lemma mono_f (s : S.Splitting) : Mono S.f 
goal: CategoryTheory.Mono S.f

full_name: CategoryTheory.ShortComplex.Splitting.splitEpi_g
code: /-- Given a splitting of a short complex `S`, this shows that `S.g` is a split epimorphism. -/
@[simps] def splitEpi_g (s : S.Splitting) : SplitEpi S.g 
goal: CategoryTheory.SplitEpi S.g

full_name: CategoryTheory.ShortComplex.Splitting.splitEpi_g_section_
code: /-- Given a splitting of a short complex `S`, this shows that `S.g` is a split epimorphism. -/
@[simps] def splitEpi_g (s : S.Splitting) : SplitEpi S.g 
goal: s.splitEpi_g.section_ = s.s

full_name: CategoryTheory.ShortComplex.Splitting.isSplitEpi_g
code: lemma isSplitEpi_g (s : S.Splitting) : IsSplitEpi S.g 
goal: CategoryTheory.IsSplitEpi S.g

full_name: CategoryTheory.ShortComplex.Splitting.epi_g
code: lemma epi_g (s : S.Splitting) : Epi S.g 
goal: CategoryTheory.Epi S.g

full_name: CategoryTheory.ShortComplex.Splitting.s_r
code: @[reassoc (attr := simp)]
lemma s_r (s : S.Splitting) : s.s ≫ s.r = 0 
goal: CategoryTheory.CategoryStruct.comp s.s s.r = 0

full_name: CategoryTheory.ShortComplex.Splitting.ext_r
code: lemma ext_r (s s' : S.Splitting) (h : s.r = s'.r) : s = s' 
goal: s = s'

full_name: CategoryTheory.ShortComplex.Splitting.ext_s
code: lemma ext_s (s s' : S.Splitting) (h : s.s = s'.s) : s = s' 
goal: s = s'

full_name: CategoryTheory.ShortComplex.Splitting.leftHomologyData_i
code: /-- The left homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def leftHomologyData [HasZeroObject C] (s : S.Splitting) :
    LeftHomologyData S 
goal: s.leftHomologyData.i = S.f

full_name: CategoryTheory.ShortComplex.Splitting.leftHomologyData_K
code: /-- The left homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def leftHomologyData [HasZeroObject C] (s : S.Splitting) :
    LeftHomologyData S 
goal: s.leftHomologyData.K = S.X₁

full_name: CategoryTheory.ShortComplex.Splitting.leftHomologyData
code: /-- The left homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def leftHomologyData [HasZeroObject C] (s : S.Splitting) :
    LeftHomologyData S 
goal: S.LeftHomologyData

full_name: CategoryTheory.ShortComplex.Splitting.leftHomologyData_π
code: /-- The left homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def leftHomologyData [HasZeroObject C] (s : S.Splitting) :
    LeftHomologyData S 
goal: s.leftHomologyData.π = 0

full_name: CategoryTheory.ShortComplex.Splitting.leftHomologyData_H
code: /-- The left homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def leftHomologyData [HasZeroObject C] (s : S.Splitting) :
    LeftHomologyData S 
goal: s.leftHomologyData.H = 0

full_name: CategoryTheory.ShortComplex.Splitting.rightHomologyData_H
code: /-- The right homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def rightHomologyData [HasZeroObject C] (s : S.Splitting) :
    RightHomologyData S 
goal: s.rightHomologyData.H = 0

full_name: CategoryTheory.ShortComplex.Splitting.rightHomologyData
code: /-- The right homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def rightHomologyData [HasZeroObject C] (s : S.Splitting) :
    RightHomologyData S 
goal: S.RightHomologyData

full_name: CategoryTheory.ShortComplex.Splitting.rightHomologyData_p
code: /-- The right homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def rightHomologyData [HasZeroObject C] (s : S.Splitting) :
    RightHomologyData S 
goal: s.rightHomologyData.p = S.g

full_name: CategoryTheory.ShortComplex.Splitting.rightHomologyData_Q
code: /-- The right homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def rightHomologyData [HasZeroObject C] (s : S.Splitting) :
    RightHomologyData S 
goal: s.rightHomologyData.Q = S.X₃

full_name: CategoryTheory.ShortComplex.Splitting.rightHomologyData_ι
code: /-- The right homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def rightHomologyData [HasZeroObject C] (s : S.Splitting) :
    RightHomologyData S 
goal: s.rightHomologyData.ι = 0

full_name: CategoryTheory.ShortComplex.Splitting.homologyData_right
code: /-- The homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def homologyData [HasZeroObject C] (s : S.Splitting) : S.HomologyData 
goal: s.homologyData.right = s.rightHomologyData

full_name: CategoryTheory.ShortComplex.Splitting.homologyData
code: /-- The homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def homologyData [HasZeroObject C] (s : S.Splitting) : S.HomologyData 
goal: S.HomologyData

full_name: CategoryTheory.ShortComplex.Splitting.homologyData_iso
code: /-- The homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def homologyData [HasZeroObject C] (s : S.Splitting) : S.HomologyData 
goal: s.homologyData.iso = CategoryTheory.Iso.refl 0

full_name: CategoryTheory.ShortComplex.Splitting.homologyData_left
code: /-- The homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def homologyData [HasZeroObject C] (s : S.Splitting) : S.HomologyData 
goal: s.homologyData.left = s.leftHomologyData

full_name: CategoryTheory.ShortComplex.Splitting.exact
code: /-- A short complex equipped with a splitting is exact. -/
lemma exact [HasZeroObject C] (s : S.Splitting) : S.Exact 
goal: S.Exact

full_name: CategoryTheory.ShortComplex.Splitting.fIsKernel
code: /-- If a short complex `S` is equipped with a splitting, then `S.X₁` is the kernel of `S.g`. -/
noncomputable def fIsKernel [HasZeroObject C] (s : S.Splitting) :
    IsLimit (KernelFork.ofι S.f S.zero) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι S.f ⋯)

full_name: CategoryTheory.ShortComplex.Splitting.gIsCokernel
code: /-- If a short complex `S` is equipped with a splitting, then `S.X₃` is the cokernel of `S.f`. -/
noncomputable def gIsCokernel [HasZeroObject C] (s : S.Splitting) :
    IsColimit (CokernelCofork.ofπ S.g S.zero) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯)

full_name: CategoryTheory.ShortComplex.Splitting.map
code: /-- If a short complex `S` has a splitting and `F` is an additive functor, then
`S.map F` also has a splitting. -/
@[simps]
def map (s : S.Splitting) (F : C ⥤ D) [F.Additive] : (S.map F).Splitting 
goal: (S.map F).Splitting

full_name: CategoryTheory.ShortComplex.Splitting.map_r
code: /-- If a short complex `S` has a splitting and `F` is an additive functor, then
`S.map F` also has a splitting. -/
@[simps]
def map (s : S.Splitting) (F : C ⥤ D) [F.Additive] : (S.map F).Splitting 
goal: (s.map F).r = F.map s.r

full_name: CategoryTheory.ShortComplex.Splitting.map_s
code: /-- If a short complex `S` has a splitting and `F` is an additive functor, then
`S.map F` also has a splitting. -/
@[simps]
def map (s : S.Splitting) (F : C ⥤ D) [F.Additive] : (S.map F).Splitting 
goal: (s.map F).s = F.map s.s

full_name: CategoryTheory.ShortComplex.Splitting.ofIso
code: /-- A splitting on a short complex induces splittings on isomorphic short complexes. -/
@[simps]
def ofIso {S₁ S₂ : ShortComplex C} (s : S₁.Splitting) (e : S₁ ≅ S₂) : S₂.Splitting 
goal: S₂.Splitting

full_name: CategoryTheory.ShortComplex.Splitting.ofIso_r
code: /-- A splitting on a short complex induces splittings on isomorphic short complexes. -/
@[simps]
def ofIso {S₁ S₂ : ShortComplex C} (s : S₁.Splitting) (e : S₁ ≅ S₂) : S₂.Splitting 
goal: (s.ofIso e).r = CategoryTheory.CategoryStruct.comp e.inv.τ₂ (CategoryTheory.CategoryStruct.comp s.r e.hom.τ₁)

full_name: CategoryTheory.ShortComplex.Splitting.ofIso_s
code: /-- A splitting on a short complex induces splittings on isomorphic short complexes. -/
@[simps]
def ofIso {S₁ S₂ : ShortComplex C} (s : S₁.Splitting) (e : S₁ ≅ S₂) : S₂.Splitting 
goal: (s.ofIso e).s = CategoryTheory.CategoryStruct.comp e.inv.τ₃ (CategoryTheory.CategoryStruct.comp s.s e.hom.τ₂)

full_name: CategoryTheory.ShortComplex.Splitting.ofHasBinaryBiproduct
code: /-- The obvious splitting of the short complex `X₁ ⟶ X₁ ⊞ X₂ ⟶ X₂`. -/
noncomputable def ofHasBinaryBiproduct (X₁ X₂ : C) [HasBinaryBiproduct X₁ X₂] :
    Splitting (ShortComplex.mk (biprod.inl : X₁ ⟶ _) (biprod.snd : _ ⟶ X₂) (by simp)) 
goal: (CategoryTheory.ShortComplex.mk CategoryTheory.Limits.biprod.inl CategoryTheory.Limits.biprod.snd ⋯).Splitting

full_name: CategoryTheory.ShortComplex.Splitting.ofIsZeroOfIsIso
code: /-- The obvious splitting of a short complex when `S.X₁` is zero and `S.g` is an isomorphism. -/
noncomputable def ofIsZeroOfIsIso (hf : IsZero S.X₁) (hg : IsIso S.g) : Splitting S 
goal: S.Splitting

full_name: CategoryTheory.ShortComplex.Splitting.ofIsIsoOfIsZero
code: /-- The obvious splitting of a short complex when `S.f` is an isomorphism and `S.X₃` is zero. -/
noncomputable def ofIsIsoOfIsZero (hf : IsIso S.f) (hg : IsZero S.X₃) : Splitting S 
goal: S.Splitting

full_name: CategoryTheory.ShortComplex.Splitting.op_r
code: /-- The splitting of the short complex `S.op` deduced from a splitting of `S`. -/
@[simps]
def op (h : Splitting S) : Splitting S.op 
goal: h.op.r = h.s.op

full_name: CategoryTheory.ShortComplex.Splitting.op_s
code: /-- The splitting of the short complex `S.op` deduced from a splitting of `S`. -/
@[simps]
def op (h : Splitting S) : Splitting S.op 
goal: h.op.s = h.r.op

full_name: CategoryTheory.ShortComplex.Splitting.op
code: /-- The splitting of the short complex `S.op` deduced from a splitting of `S`. -/
@[simps]
def op (h : Splitting S) : Splitting S.op 
goal: S.op.Splitting

full_name: CategoryTheory.ShortComplex.Splitting.unop_s
code: /-- The splitting of the short complex `S.unop` deduced from a splitting of `S`. -/
@[simps]
def unop {S : ShortComplex Cᵒᵖ} (h : Splitting S) : Splitting S.unop 
goal: h.unop.s = h.r.unop

full_name: CategoryTheory.ShortComplex.Splitting.unop
code: /-- The splitting of the short complex `S.unop` deduced from a splitting of `S`. -/
@[simps]
def unop {S : ShortComplex Cᵒᵖ} (h : Splitting S) : Splitting S.unop 
goal: S.unop.Splitting

full_name: CategoryTheory.ShortComplex.Splitting.unop_r
code: /-- The splitting of the short complex `S.unop` deduced from a splitting of `S`. -/
@[simps]
def unop {S : ShortComplex Cᵒᵖ} (h : Splitting S) : Splitting S.unop 
goal: h.unop.r = h.s.unop

full_name: CategoryTheory.ShortComplex.Splitting.isoBinaryBiproduct_inv
code: /-- The isomorphism `S.X₂ ≅ S.X₁ ⊞ S.X₃` induced by a splitting of the short complex `S`. -/
@[simps]
noncomputable def isoBinaryBiproduct (h : Splitting S) [HasBinaryBiproduct S.X₁ S.X₃] :
    S.X₂ ≅ S.X₁ ⊞ S.X₃ 
goal: h.isoBinaryBiproduct.inv = CategoryTheory.Limits.biprod.desc S.f h.s

full_name: CategoryTheory.ShortComplex.Splitting.isoBinaryBiproduct
code: /-- The isomorphism `S.X₂ ≅ S.X₁ ⊞ S.X₃` induced by a splitting of the short complex `S`. -/
@[simps]
noncomputable def isoBinaryBiproduct (h : Splitting S) [HasBinaryBiproduct S.X₁ S.X₃] :
    S.X₂ ≅ S.X₁ ⊞ S.X₃ 
goal: S.X₂ ≅ S.X₁ ⊞ S.X₃

full_name: CategoryTheory.ShortComplex.Splitting.isoBinaryBiproduct_hom
code: /-- The isomorphism `S.X₂ ≅ S.X₁ ⊞ S.X₃` induced by a splitting of the short complex `S`. -/
@[simps]
noncomputable def isoBinaryBiproduct (h : Splitting S) [HasBinaryBiproduct S.X₁ S.X₃] :
    S.X₂ ≅ S.X₁ ⊞ S.X₃ 
goal: h.isoBinaryBiproduct.hom = CategoryTheory.Limits.biprod.lift h.r S.g

full_name: CategoryTheory.ShortComplex.Exact.isIso_f'
code: lemma isIso_f' (hS : S.Exact) (h : S.LeftHomologyData) [Mono S.f] :
    IsIso h.f' 
goal: CategoryTheory.IsIso h.f'

full_name: CategoryTheory.ShortComplex.Exact.isIso_toCycles
code: lemma isIso_toCycles (hS : S.Exact) [Mono S.f] [S.HasLeftHomology]:
    IsIso S.toCycles 
goal: CategoryTheory.IsIso S.toCycles

full_name: CategoryTheory.ShortComplex.Exact.isIso_g'
code: lemma isIso_g' (hS : S.Exact) (h : S.RightHomologyData) [Epi S.g] :
    IsIso h.g' 
goal: CategoryTheory.IsIso h.g'

full_name: CategoryTheory.ShortComplex.Exact.isIso_fromOpcycles
code: lemma isIso_fromOpcycles (hS : S.Exact) [Epi S.g] [S.HasRightHomology] :
    IsIso S.fromOpcycles 
goal: CategoryTheory.IsIso S.fromOpcycles

full_name: CategoryTheory.ShortComplex.Exact.fIsKernel
code: /-- In a balanced category, if a short complex `S` is exact and `S.f` is a mono, then
`S.X₁` is the kernel of `S.g`. -/
noncomputable def fIsKernel (hS : S.Exact) [Mono S.f] : IsLimit (KernelFork.ofι S.f S.zero) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι S.f ⋯)

full_name: CategoryTheory.ShortComplex.Exact.map_of_mono_of_preservesKernel
code: lemma map_of_mono_of_preservesKernel (hS : S.Exact) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [(S.map F).HasHomology] (_ : Mono S.f)
    (_ : PreservesLimit (parallelPair S.g 0) F) :
    (S.map F).Exact 
goal: CategoryTheory.Mono S.f →
  CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair S.g 0) F → (S.map F).Exact

full_name: CategoryTheory.ShortComplex.Exact.gIsCokernel
code: /-- In a balanced category, if a short complex `S` is exact and `S.g` is an epi, then
`S.X₃` is the cokernel of `S.g`. -/
noncomputable def gIsCokernel (hS : S.Exact) [Epi S.g] :
    IsColimit (CokernelCofork.ofπ S.g S.zero) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯)

full_name: CategoryTheory.ShortComplex.Exact.map_of_epi_of_preservesCokernel
code: lemma map_of_epi_of_preservesCokernel (hS : S.Exact) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [(S.map F).HasHomology] (_ : Epi S.g)
    (_ : PreservesColimit (parallelPair S.f 0) F) :
    (S.map F).Exact 
goal: CategoryTheory.Epi S.g →
  CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair S.f 0) F → (S.map F).Exact

full_name: CategoryTheory.ShortComplex.Exact.lift
code: /-- If a short complex `S` in a balanced category is exact and such that `S.f` is a mono,
then a morphism `k : A ⟶ S.X₂` such that `k ≫ S.g = 0` lifts to a morphism `A ⟶ S.X₁`. -/
noncomputable def lift (hS : S.Exact) {A : C} (k : A ⟶ S.X₂) (hk : k ≫ S.g = 0) [Mono S.f] :
    A ⟶ S.X₁ 
goal: A ⟶ S.X₁

full_name: CategoryTheory.ShortComplex.Exact.lift_f
code: @[reassoc (attr := simp)]
lemma lift_f (hS : S.Exact) {A : C} (k : A ⟶ S.X₂) (hk : k ≫ S.g = 0) [Mono S.f] :
    hS.lift k hk ≫ S.f = k 
goal: CategoryTheory.CategoryStruct.comp (hS.lift k hk) S.f = k

full_name: CategoryTheory.ShortComplex.Exact.lift'
code: lemma lift' (hS : S.Exact) {A : C} (k : A ⟶ S.X₂) (hk : k ≫ S.g = 0) [Mono S.f] :
    ∃ (l : A ⟶ S.X₁), l ≫ S.f = k 
goal: ∃ l, CategoryTheory.CategoryStruct.comp l S.f = k

full_name: CategoryTheory.ShortComplex.Exact.desc
code: /-- If a short complex `S` in a balanced category is exact and such that `S.g` is an epi,
then a morphism `k : S.X₂ ⟶ A` such that `S.f ≫ k = 0` descends to a morphism `S.X₃ ⟶ A`. -/
noncomputable def desc (hS : S.Exact) {A : C} (k : S.X₂ ⟶ A) (hk : S.f ≫ k = 0) [Epi S.g] :
    S.X₃ ⟶ A 
goal: S.X₃ ⟶ A

full_name: CategoryTheory.ShortComplex.Exact.g_desc
code: @[reassoc (attr := simp)]
lemma g_desc (hS : S.Exact) {A : C} (k : S.X₂ ⟶ A) (hk : S.f ≫ k = 0) [Epi S.g] :
    S.g ≫ hS.desc k hk = k 
goal: CategoryTheory.CategoryStruct.comp S.g (hS.desc k hk) = k

full_name: CategoryTheory.ShortComplex.Exact.desc'
code: lemma desc' (hS : S.Exact) {A : C} (k : S.X₂ ⟶ A) (hk : S.f ≫ k = 0) [Epi S.g] :
    ∃ (l : S.X₃ ⟶ A), S.g ≫ l = k 
goal: ∃ l, CategoryTheory.CategoryStruct.comp S.g l = k

full_name: CategoryTheory.ShortComplex.mono_τ₂_of_exact_of_mono
code: lemma mono_τ₂_of_exact_of_mono {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (h₁ : S₁.Exact) [Mono S₁.f] [Mono S₂.f] [Mono φ.τ₁] [Mono φ.τ₃] : Mono φ.τ₂ 
goal: CategoryTheory.Mono φ.τ₂

full_name: CategoryTheory.ShortComplex.epi_τ₂_of_exact_of_epi
code: lemma epi_τ₂_of_exact_of_epi {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (h₂ : S₂.Exact) [Epi S₁.g] [Epi S₂.g] [Epi φ.τ₁] [Epi φ.τ₃] : Epi φ.τ₂ 
goal: CategoryTheory.Epi φ.τ₂

full_name: CategoryTheory.ShortComplex.exact_and_mono_f_iff_f_is_kernel
code: lemma exact_and_mono_f_iff_f_is_kernel [S.HasHomology] :
    S.Exact ∧ Mono S.f ↔ Nonempty (IsLimit (KernelFork.ofι S.f S.zero)) 
goal: S.Exact ∧ CategoryTheory.Mono S.f ↔
  Nonempty (CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι S.f ⋯))

full_name: CategoryTheory.ShortComplex.exact_and_epi_g_iff_g_is_cokernel
code: lemma exact_and_epi_g_iff_g_is_cokernel [S.HasHomology] :
    S.Exact ∧ Epi S.g ↔ Nonempty (IsColimit (CokernelCofork.ofπ S.g S.zero)) 
goal: S.Exact ∧ CategoryTheory.Epi S.g ↔
  Nonempty (CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯))

full_name: CategoryTheory.ShortComplex.quasiIso_iff_of_zeros
code: /-- Given a morphism of short complexes `φ : S₁ ⟶ S₂` in an abelian category, if `S₁.f`
and `S₁.g` are zero (e.g. when `S₁` is of the form `0 ⟶ S₁.X₂ ⟶ 0`) and `S₂.f = 0`
(e.g when `S₂` is of the form `0 ⟶ S₂.X₂ ⟶ S₂.X₃`), then `φ` is a quasi-isomorphism iff
the obvious short complex `S₁.X₂ ⟶ S₂.X₂ ⟶ S₂.X₃` is exact and `φ.τ₂` is a mono). -/
lemma quasiIso_iff_of_zeros {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (hf₁ : S₁.f = 0) (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0) :
    QuasiIso φ ↔
      (ShortComplex.mk φ.τ₂ S₂.g (by rw [φ.comm₂₃, hg₁, zero_comp])).Exact ∧ Mono φ.τ₂ 
goal: CategoryTheory.ShortComplex.QuasiIso φ ↔ (CategoryTheory.ShortComplex.mk φ.τ₂ S₂.g ⋯).Exact ∧ CategoryTheory.Mono φ.τ₂

full_name: CategoryTheory.ShortComplex.quasiIso_iff_of_zeros'
code: /-- Given a morphism of short complexes `φ : S₁ ⟶ S₂` in an abelian category, if `S₁.g = 0`
(e.g when `S₁` is of the form `S₁.X₁ ⟶ S₁.X₂ ⟶ 0`) and both `S₂.f` and `S₂.g` are zero
(e.g when `S₂` is of the form `0 ⟶ S₂.X₂ ⟶ 0`), then `φ` is a quasi-isomorphism iff
the obvious short complex `S₁.X₂ ⟶ S₁.X₂ ⟶ S₂.X₂` is exact and `φ.τ₂` is an epi). -/
lemma quasiIso_iff_of_zeros' {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0) (hg₂ : S₂.g = 0) :
    QuasiIso φ ↔
      (ShortComplex.mk S₁.f φ.τ₂ (by rw [← φ.comm₁₂, hf₂, comp_zero])).Exact ∧ Epi φ.τ₂ 
goal: CategoryTheory.ShortComplex.QuasiIso φ ↔ (CategoryTheory.ShortComplex.mk S₁.f φ.τ₂ ⋯).Exact ∧ CategoryTheory.Epi φ.τ₂

full_name: CategoryTheory.ShortComplex.Exact.descToInjective
code: /-- If `S` is an exact short complex and `f : S.X₂ ⟶ J` is a morphism to an injective object `J`
such that `S.f ≫ f = 0`, this is a morphism `φ : S.X₃ ⟶ J` such that `S.g ≫ φ = f`. -/
noncomputable def Exact.descToInjective
    (hS : S.Exact) {J : C} (f : S.X₂ ⟶ J) [Injective J] (hf : S.f ≫ f = 0) :
    S.X₃ ⟶ J 
goal: S.X₃ ⟶ J

full_name: CategoryTheory.ShortComplex.Exact.comp_descToInjective
code: @[reassoc (attr := simp, nolint unusedHavesSuffices)]
lemma Exact.comp_descToInjective
    (hS : S.Exact) {J : C} (f : S.X₂ ⟶ J) [Injective J] (hf : S.f ≫ f = 0) :
    S.g ≫ hS.descToInjective f hf = f 
goal: CategoryTheory.CategoryStruct.comp S.g (hS.descToInjective f hf) = f

full_name: CategoryTheory.ShortComplex.Exact.liftFromProjective
code: /-- If `S` is an exact short complex and `f : P ⟶ S.X₂` is a morphism from a projective object `P`
such that `f ≫ S.g = 0`, this is a morphism `φ : P ⟶ S.X₁` such that `φ ≫ S.f = f`. -/
noncomputable def Exact.liftFromProjective
    (hS : S.Exact) {P : C} (f : P ⟶ S.X₂) [Projective P] (hf : f ≫ S.g = 0) :
    P ⟶ S.X₁ 
goal: P ⟶ S.X₁

full_name: CategoryTheory.ShortComplex.Exact.liftFromProjective_comp
code: @[reassoc (attr := simp, nolint unusedHavesSuffices)]
lemma Exact.liftFromProjective_comp
    (hS : S.Exact) {P : C} (f : P ⟶ S.X₂) [Projective P] (hf : f ≫ S.g = 0) :
    hS.liftFromProjective f hf ≫ S.f = f 
goal: CategoryTheory.CategoryStruct.comp (hS.liftFromProjective f hf) S.f = f

full_name: CategoryTheory.Functor.instPreservesMonomorphisms
code: instance : F.PreservesMonomorphisms 
goal: F.PreservesMonomorphisms

full_name: CategoryTheory.Functor.instPreservesEpimorphisms
code: instance : F.PreservesEpimorphisms 
goal: F.PreservesEpimorphisms

full_name: CategoryTheory.ShortComplex.Splitting.ofExactOfSection
code: /-- This is the splitting of a short complex `S` in a balanced category induced by
a section of the morphism `S.g : S.X₂ ⟶ S.X₃` -/
noncomputable def ofExactOfSection (S : ShortComplex C) (hS : S.Exact) (s : S.X₃ ⟶ S.X₂)
    (s_g : s ≫ S.g = 𝟙 S.X₃) (hf : Mono S.f) :
    S.Splitting 
goal: S.Splitting

full_name: CategoryTheory.ShortComplex.Splitting.ofExactOfRetraction
code: /-- This is the splitting of a short complex `S` in a balanced category induced by
a retraction of the morphism `S.f : S.X₁ ⟶ S.X₂` -/
noncomputable def ofExactOfRetraction (S : ShortComplex C) (hS : S.Exact) (r : S.X₂ ⟶ S.X₁)
    (f_r : S.f ≫ r = 𝟙 S.X₁) (hg : Epi S.g) :
    S.Splitting 
goal: S.Splitting