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

full_name: CategoryTheory.Functor.preservesFiniteLimitsOfPreservesHomology
code: /-- An additive functor which preserves homology preserves finite limits. -/
noncomputable def preservesFiniteLimitsOfPreservesHomology
    [HasFiniteProducts C] [HasKernels C] : PreservesFiniteLimits F 
goal: CategoryTheory.Limits.PreservesFiniteLimits F

full_name: CategoryTheory.Functor.preservesFiniteColimitsOfPreservesHomology
code: /-- An additive which preserves homology preserves finite colimits. -/
noncomputable def preservesFiniteColimitsOfPreservesHomology
    [HasFiniteCoproducts C] [HasCokernels C] : PreservesFiniteColimits F 
goal: CategoryTheory.Limits.PreservesFiniteColimits F

full_name: CategoryTheory.Functor.preservesMonomorphisms_of_preserves_shortExact_left
code: /--
If a functor `F : C ⥤ D` preserves short exact sequences on the left hand side, (i.e.
if `0 ⟶ A ⟶ B ⟶ C ⟶ 0` is exact then `0 ⟶ F(A) ⟶ F(B) ⟶ F(C)` is exact)
then it preserves monomorphism.
-/
lemma preservesMonomorphisms_of_preserves_shortExact_left
    (h : ∀ (S : ShortComplex C), S.ShortExact → (S.map F).Exact ∧ Mono (F.map S.f)) :
    F.PreservesMonomorphisms 
goal: F.PreservesMonomorphisms

full_name: CategoryTheory.Functor.preservesFiniteLimits_tfae
code: /--
For an addivite functor `F : C ⥤ D` between abelian categories, the following are equivalent:
- `F` preserves short exact sequences on the left hand side, i.e. if `0 ⟶ A ⟶ B ⟶ C ⟶ 0` is exact
  then `0 ⟶ F(A) ⟶ F(B) ⟶ F(C)` is exact.
- `F` preserves exact sequences on the left hand side, i.e. if `A ⟶ B ⟶ C` is exact where `A ⟶ B`
  is mono, then `F(A) ⟶ F(B) ⟶ F(C)` is exact and `F(A) ⟶ F(B)` is mono as well.
- `F` preserves kernels.
- `F` preserves finite limits.
-/
lemma preservesFiniteLimits_tfae : List.TFAE
    [
      ∀ (S : ShortComplex C), S.ShortExact → (S.map F).Exact ∧ Mono (F.map S.f),
      ∀ (S : ShortComplex C), S.Exact ∧ Mono S.f → (S.map F).Exact ∧ Mono (F.map S.f),
      ∀ ⦃X Y : C⦄ (f : X ⟶ Y), Nonempty $ PreservesLimit (parallelPair f 0) F,
      Nonempty $ PreservesFiniteLimits F
    ] 
goal: [∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.map F).Exact ∧ CategoryTheory.Mono (F.map S.f),
    ∀ (S : CategoryTheory.ShortComplex C),
      S.Exact ∧ CategoryTheory.Mono S.f → (S.map F).Exact ∧ CategoryTheory.Mono (F.map S.f),
    ∀ ⦃X Y : C⦄ (f : X ⟶ Y), Nonempty (CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair f 0) F),
    Nonempty (CategoryTheory.Limits.PreservesFiniteLimits F)].TFAE

full_name: CategoryTheory.Functor.preservesEpimorphisms_of_preserves_shortExact_right
code: /--
If a functor `F : C ⥤ D` preserves exact sequences on the right hand side (i.e.
if `0 ⟶ A ⟶ B ⟶ C ⟶ 0` is exact then `F(A) ⟶ F(B) ⟶ F(C) ⟶ 0` is exact),
then it preserves epimorphisms.
-/
lemma preservesEpimorphisms_of_preserves_shortExact_right
    (h : ∀ (S : ShortComplex C), S.ShortExact → (S.map F).Exact ∧ Epi (F.map S.g)) :
    F.PreservesEpimorphisms 
goal: F.PreservesEpimorphisms

full_name: CategoryTheory.Functor.preservesFiniteColimits_tfae
code: /--
For an addivite functor `F : C ⥤ D` between abelian categories, the following are equivalent:
- `F` preserves short exact sequences on the right hand side, i.e. if `0 ⟶ A ⟶ B ⟶ C ⟶ 0` is
  exact then `F(A) ⟶ F(B) ⟶ F(C) ⟶ 0` is exact.
- `F` preserves exact sequences on the right hand side, i.e. if `A ⟶ B ⟶ C` is exact where `B ⟶ C`
  is epi, then `F(A) ⟶ F(B) ⟶ F(C) ⟶ 0` is exact and `F(B) ⟶ F(C)` is epi as well.
- `F` preserves cokernels.
- `F` preserves finite colimits.
-/
lemma preservesFiniteColimits_tfae : List.TFAE
    [
      ∀ (S : ShortComplex C), S.ShortExact → (S.map F).Exact ∧ Epi (F.map S.g),
      ∀ (S : ShortComplex C), S.Exact ∧ Epi S.g → (S.map F).Exact ∧ Epi (F.map S.g),
      ∀ ⦃X Y : C⦄ (f : X ⟶ Y), Nonempty $ PreservesColimit (parallelPair f 0) F,
      Nonempty $ PreservesFiniteColimits F
    ] 
goal: [∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.map F).Exact ∧ CategoryTheory.Epi (F.map S.g),
    ∀ (S : CategoryTheory.ShortComplex C),
      S.Exact ∧ CategoryTheory.Epi S.g → (S.map F).Exact ∧ CategoryTheory.Epi (F.map S.g),
    ∀ ⦃X Y : C⦄ (f : X ⟶ Y),
      Nonempty (CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f 0) F),
    Nonempty (CategoryTheory.Limits.PreservesFiniteColimits F)].TFAE

full_name: CategoryTheory.Functor.exact_tfae
code: /--
For an additive functor `F : C ⥤ D` between abelian categories, the following are equivalent:
- `F` preserves short exact sequences, i.e. if `0 ⟶ A ⟶ B ⟶ C ⟶ 0` is exact then
  `0 ⟶ F(A) ⟶ F(B) ⟶ F(C) ⟶ 0` is exact.
- `F` preserves exact sequences, i.e. if `A ⟶ B ⟶ C` is exact then `F(A) ⟶ F(B) ⟶ F(C)` is exact.
- `F` preserves homology.
- `F` preserves both finite limits and finite colimits.
-/
lemma exact_tfae : List.TFAE
    [
      ∀ (S : ShortComplex C), S.ShortExact → (S.map F).ShortExact,
      ∀ (S : ShortComplex C), S.Exact → (S.map F).Exact,
      Nonempty (PreservesHomology F),
      Nonempty (PreservesFiniteLimits F) ∧ Nonempty (PreservesFiniteColimits F)
    ] 
goal: [∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.map F).ShortExact,
    ∀ (S : CategoryTheory.ShortComplex C), S.Exact → (S.map F).Exact, Nonempty F.PreservesHomology,
    Nonempty (CategoryTheory.Limits.PreservesFiniteLimits F) ∧
      Nonempty (CategoryTheory.Limits.PreservesFiniteColimits F)].TFAE