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

full_name: CategoryTheory.ShortComplex.ShortExact
code: /-- A short complex `S` is short exact if it is exact, `S.f` is a mono and `S.g` is an epi. -/
structure ShortExact : Prop where
  exact : S.Exact
  [mono_f : Mono S.f]
  [epi_g : Epi S.g]
goal: Prop

full_name: CategoryTheory.ShortComplex.ShortExact.mono_f
code: /-- A short complex `S` is short exact if it is exact, `S.f` is a mono and `S.g` is an epi. -/
structure ShortExact : Prop where
  exact : S.Exact
  [mono_f : Mono S.f]
  [epi_g : Epi S.g]
goal: CategoryTheory.Mono S.f

full_name: CategoryTheory.ShortComplex.ShortExact.exact
code: /-- A short complex `S` is short exact if it is exact, `S.f` is a mono and `S.g` is an epi. -/
structure ShortExact : Prop where
  exact : S.Exact
  [mono_f : Mono S.f]
  [epi_g : Epi S.g]
goal: S.Exact

full_name: CategoryTheory.ShortComplex.ShortExact.epi_g
code: /-- A short complex `S` is short exact if it is exact, `S.f` is a mono and `S.g` is an epi. -/
structure ShortExact : Prop where
  exact : S.Exact
  [mono_f : Mono S.f]
  [epi_g : Epi S.g]
goal: CategoryTheory.Epi S.g

full_name: CategoryTheory.ShortComplex.ShortExact.mk'
code: lemma ShortExact.mk' (h : S.Exact) (_ : Mono S.f) (_ : Epi S.g) : S.ShortExact 
goal: CategoryTheory.Mono S.f → CategoryTheory.Epi S.g → S.ShortExact

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

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

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

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

full_name: CategoryTheory.ShortComplex.shortExact_iff_op
code: lemma shortExact_iff_op : S.ShortExact ↔ S.op.ShortExact 
goal: S.ShortExact ↔ S.op.ShortExact

full_name: CategoryTheory.ShortComplex.shortExact_iff_unop
code: lemma shortExact_iff_unop (S : ShortComplex Cᵒᵖ) : S.ShortExact ↔ S.unop.ShortExact 
goal: S.ShortExact ↔ S.unop.ShortExact

full_name: CategoryTheory.ShortComplex.ShortExact.map
code: lemma ShortExact.map (h : S.ShortExact) (F : C ⥤ D)
    [F.PreservesZeroMorphisms] [F.PreservesLeftHomologyOf S]
    [F.PreservesRightHomologyOf S] [Mono (F.map S.f)] [Epi (F.map S.g)] :
    (S.map F).ShortExact 
goal: (S.map F).ShortExact

full_name: CategoryTheory.ShortComplex.ShortExact.map_of_exact
code: lemma ShortExact.map_of_exact (hS : S.ShortExact)
    (F : C ⥤ D) [F.PreservesZeroMorphisms] [PreservesFiniteLimits F]
    [PreservesFiniteColimits F] : (S.map F).ShortExact 
goal: (S.map F).ShortExact

full_name: CategoryTheory.ShortComplex.ShortExact.isIso_f_iff
code: lemma ShortExact.isIso_f_iff {S : ShortComplex C} (hS : S.ShortExact) [Balanced C] :
    IsIso S.f ↔ IsZero S.X₃ 
goal: CategoryTheory.IsIso S.f ↔ CategoryTheory.Limits.IsZero S.X₃

full_name: CategoryTheory.ShortComplex.ShortExact.isIso_g_iff
code: lemma ShortExact.isIso_g_iff  {S : ShortComplex C} (hS : S.ShortExact) [Balanced C] :
    IsIso S.g ↔ IsZero S.X₁ 
goal: CategoryTheory.IsIso S.g ↔ CategoryTheory.Limits.IsZero S.X₁

full_name: CategoryTheory.ShortComplex.isIso₂_of_shortExact_of_isIso₁₃
code: lemma isIso₂_of_shortExact_of_isIso₁₃ [Balanced C] {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (h₁ : S₁.ShortExact) (h₂ : S₂.ShortExact) [IsIso φ.τ₁] [IsIso φ.τ₃] : IsIso φ.τ₂ 
goal: CategoryTheory.IsIso φ.τ₂

full_name: CategoryTheory.ShortComplex.isIso₂_of_shortExact_of_isIso₁₃'
code: lemma isIso₂_of_shortExact_of_isIso₁₃' [Balanced C] {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (h₁ : S₁.ShortExact) (h₂ : S₂.ShortExact) (_ : IsIso φ.τ₁) (_ : IsIso φ.τ₃) : IsIso φ.τ₂ 
goal: CategoryTheory.IsIso φ.τ₁ → CategoryTheory.IsIso φ.τ₃ → CategoryTheory.IsIso φ.τ₂

full_name: CategoryTheory.ShortComplex.ShortExact.fIsKernel
code: /-- If `S` is a short exact short complex in a balanced category,
then `S.X₁` is the kernel of `S.g`. -/
noncomputable def ShortExact.fIsKernel [Balanced C] {S : ShortComplex C} (hS : S.ShortExact) :
    IsLimit (KernelFork.ofι S.f S.zero) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι S.f ⋯)

full_name: CategoryTheory.ShortComplex.ShortExact.gIsCokernel
code: /-- If `S` is a short exact short complex in a balanced category,
then `S.X₃` is the cokernel of `S.f`. -/
noncomputable def ShortExact.gIsCokernel [Balanced C] {S : ShortComplex C} (hS : S.ShortExact) :
    IsColimit (CokernelCofork.ofπ S.g S.zero) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯)

full_name: CategoryTheory.ShortComplex.Splitting.shortExact
code: /-- A split short complex is short exact. -/
lemma Splitting.shortExact {S : ShortComplex C} [HasZeroObject C] (s : S.Splitting) :
    S.ShortExact 
goal: S.ShortExact

full_name: CategoryTheory.ShortComplex.ShortExact.splittingOfInjective
code: /-- A choice of splitting for a short exact short complex `S` in a balanced category
such that `S.X₁` is injective. -/
noncomputable def splittingOfInjective {S : ShortComplex C} (hS : S.ShortExact)
    [Injective S.X₁] [Balanced C] :
    S.Splitting 
goal: S.Splitting

full_name: CategoryTheory.ShortComplex.ShortExact.splittingOfProjective
code: /-- A choice of splitting for a short exact short complex `S` in a balanced category
such that `S.X₃` is projective. -/
noncomputable def splittingOfProjective {S : ShortComplex C} (hS : S.ShortExact)
    [Projective S.X₃] [Balanced C] :
    S.Splitting 
goal: S.Splitting