File: Mathlib/CategoryTheory/Abelian/LeftDerived.lean

full_name: CategoryTheory.Functor.leftDerivedToHomotopyCategory
code: /-- When `F : C ⥤ D` is an additive functor, this is
the functor `C ⥤ HomotopyCategory D (ComplexShape.down ℕ)` which
sends `X : C` to `F` applied to a projective resolution of `X`. -/
noncomputable def Functor.leftDerivedToHomotopyCategory (F : C ⥤ D) [F.Additive] :
    C ⥤ HomotopyCategory D (ComplexShape.down ℕ) 
goal: CategoryTheory.Functor C (HomotopyCategory D (ComplexShape.down ℕ))

full_name: CategoryTheory.ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj
code: /-- If `P : ProjectiveResolution Z` and `F : C ⥤ D` is an additive functor, this is
an isomorphism between `F.leftDerivedToHomotopyCategory.obj X` and the complex
obtained by applying `F` to `P.complex`. -/
noncomputable def ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj {X : C}
    (P : ProjectiveResolution X) (F : C ⥤ D) [F.Additive] :
    F.leftDerivedToHomotopyCategory.obj X ≅
      (F.mapHomologicalComplex _ ⋙ HomotopyCategory.quotient _ _).obj P.complex 
goal: F.leftDerivedToHomotopyCategory.obj X ≅
  ((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp (HomotopyCategory.quotient D (ComplexShape.down ℕ))).obj
    P.complex

full_name: CategoryTheory.ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj_inv_naturality
code: @[reassoc]
lemma ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj_inv_naturality
    {X Y : C} (f : X ⟶ Y) (P : ProjectiveResolution X) (Q : ProjectiveResolution Y)
    (φ : P.complex ⟶ Q.complex) (comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f)
    (F : C ⥤ D) [F.Additive] :
    (P.isoLeftDerivedToHomotopyCategoryObj F).inv ≫ F.leftDerivedToHomotopyCategory.map f =
      (F.mapHomologicalComplex _ ⋙ HomotopyCategory.quotient _ _).map φ ≫
        (Q.isoLeftDerivedToHomotopyCategoryObj F).inv 
goal: CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedToHomotopyCategoryObj F).inv
    (F.leftDerivedToHomotopyCategory.map f) =
  CategoryTheory.CategoryStruct.comp
    (((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp (HomotopyCategory.quotient D (ComplexShape.down ℕ))).map φ)
    (Q.isoLeftDerivedToHomotopyCategoryObj F).inv

full_name: CategoryTheory.ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj_hom_naturality
code: @[reassoc]
lemma ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj_hom_naturality
    {X Y : C} (f : X ⟶ Y) (P : ProjectiveResolution X) (Q : ProjectiveResolution Y)
    (φ : P.complex ⟶ Q.complex) (comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f)
    (F : C ⥤ D) [F.Additive] :
    F.leftDerivedToHomotopyCategory.map f ≫ (Q.isoLeftDerivedToHomotopyCategoryObj F).hom =
      (P.isoLeftDerivedToHomotopyCategoryObj F).hom ≫
        (F.mapHomologicalComplex _ ⋙ HomotopyCategory.quotient _ _).map φ 
goal: CategoryTheory.CategoryStruct.comp (F.leftDerivedToHomotopyCategory.map f)
    (Q.isoLeftDerivedToHomotopyCategoryObj F).hom =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedToHomotopyCategoryObj F).hom
    (((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp (HomotopyCategory.quotient D (ComplexShape.down ℕ))).map φ)

full_name: CategoryTheory.Functor.leftDerived
code: /-- The left derived functors of an additive functor. -/
noncomputable def Functor.leftDerived (F : C ⥤ D) [F.Additive] (n : ℕ) : C ⥤ D 
goal: CategoryTheory.Functor C D

full_name: CategoryTheory.ProjectiveResolution.isoLeftDerivedObj
code: /-- We can compute a left derived functor using a chosen projective resolution. -/
noncomputable def ProjectiveResolution.isoLeftDerivedObj {X : C} (P : ProjectiveResolution X)
    (F : C ⥤ D) [F.Additive] (n : ℕ) :
    (F.leftDerived n).obj X ≅
      (HomologicalComplex.homologyFunctor D _ n).obj
        ((F.mapHomologicalComplex _).obj P.complex) 
goal: (F.leftDerived n).obj X ≅
  (HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n).obj
    ((F.mapHomologicalComplex (ComplexShape.down ℕ)).obj P.complex)

full_name: CategoryTheory.ProjectiveResolution.isoLeftDerivedObj_hom_naturality
code: @[reassoc]
lemma ProjectiveResolution.isoLeftDerivedObj_hom_naturality
    {X Y : C} (f : X ⟶ Y) (P : ProjectiveResolution X) (Q : ProjectiveResolution Y)
    (φ : P.complex ⟶ Q.complex) (comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f)
    (F : C ⥤ D) [F.Additive] (n : ℕ) :
    (F.leftDerived n).map f ≫ (Q.isoLeftDerivedObj F n).hom =
      (P.isoLeftDerivedObj F n).hom ≫
        (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map φ 
goal: CategoryTheory.CategoryStruct.comp ((F.leftDerived n).map f) (Q.isoLeftDerivedObj F n).hom =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedObj F n).hom
    (((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp
          (HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n)).map
      φ)

full_name: CategoryTheory.ProjectiveResolution.isoLeftDerivedObj_inv_naturality
code: @[reassoc]
lemma ProjectiveResolution.isoLeftDerivedObj_inv_naturality
    {X Y : C} (f : X ⟶ Y) (P : ProjectiveResolution X) (Q : ProjectiveResolution Y)
    (φ : P.complex ⟶ Q.complex) (comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f)
    (F : C ⥤ D) [F.Additive] (n : ℕ) :
    (P.isoLeftDerivedObj F n).inv ≫ (F.leftDerived n).map f =
        (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map φ ≫
          (Q.isoLeftDerivedObj F n).inv 
goal: CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedObj F n).inv ((F.leftDerived n).map f) =
  CategoryTheory.CategoryStruct.comp
    (((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp
          (HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n)).map
      φ)
    (Q.isoLeftDerivedObj F n).inv

full_name: CategoryTheory.Functor.isZero_leftDerived_obj_projective_succ
code: /-- The higher derived functors vanish on projective objects. -/
lemma Functor.isZero_leftDerived_obj_projective_succ
    (F : C ⥤ D) [F.Additive] (n : ℕ) (X : C) [Projective X] :
    IsZero ((F.leftDerived (n + 1)).obj X) 
goal: CategoryTheory.Limits.IsZero ((F.leftDerived (n + 1)).obj X)

full_name: CategoryTheory.Functor.leftDerived_map_eq
code: /-- We can compute a left derived functor on a morphism using a descent of that morphism
to a chain map between chosen projective resolutions.
-/
theorem Functor.leftDerived_map_eq (F : C ⥤ D) [F.Additive] (n : ℕ) {X Y : C} (f : X ⟶ Y)
    {P : ProjectiveResolution X} {Q : ProjectiveResolution Y} (g : P.complex ⟶ Q.complex)
    (w : g ≫ Q.π = P.π ≫ (ChainComplex.single₀ C).map f) :
    (F.leftDerived n).map f =
      (P.isoLeftDerivedObj F n).hom ≫
        (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map g ≫
          (Q.isoLeftDerivedObj F n).inv 
goal: (F.leftDerived n).map f =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedObj F n).hom
    (CategoryTheory.CategoryStruct.comp
      (((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp
            (HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n)).map
        g)
      (Q.isoLeftDerivedObj F n).inv)

full_name: CategoryTheory.NatTrans.leftDerivedToHomotopyCategory
code: /-- The natural transformation
`F.leftDerivedToHomotopyCategory ⟶ G.leftDerivedToHomotopyCategory` induced by
a natural transformation `F ⟶ G` between additive functors. -/
noncomputable def NatTrans.leftDerivedToHomotopyCategory
    {F G : C ⥤ D} [F.Additive] [G.Additive] (α : F ⟶ G) :
    F.leftDerivedToHomotopyCategory ⟶ G.leftDerivedToHomotopyCategory 
goal: F.leftDerivedToHomotopyCategory ⟶ G.leftDerivedToHomotopyCategory

full_name: CategoryTheory.ProjectiveResolution.leftDerivedToHomotopyCategory_app_eq
code: lemma ProjectiveResolution.leftDerivedToHomotopyCategory_app_eq
    {F G : C ⥤ D} [F.Additive] [G.Additive] (α : F ⟶ G) {X : C} (P : ProjectiveResolution X) :
    (NatTrans.leftDerivedToHomotopyCategory α).app X =
      (P.isoLeftDerivedToHomotopyCategoryObj F).hom ≫
        (HomotopyCategory.quotient _ _).map
          ((NatTrans.mapHomologicalComplex α _).app P.complex) ≫
          (P.isoLeftDerivedToHomotopyCategoryObj G).inv 
goal: (CategoryTheory.NatTrans.leftDerivedToHomotopyCategory α).app X =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedToHomotopyCategoryObj F).hom
    (CategoryTheory.CategoryStruct.comp
      ((HomotopyCategory.quotient D (ComplexShape.down ℕ)).map
        ((CategoryTheory.NatTrans.mapHomologicalComplex α (ComplexShape.down ℕ)).app P.complex))
      (P.isoLeftDerivedToHomotopyCategoryObj G).inv)

full_name: CategoryTheory.NatTrans.leftDerivedToHomotopyCategory_id
code: @[simp]
lemma NatTrans.leftDerivedToHomotopyCategory_id (F : C ⥤ D) [F.Additive] :
    NatTrans.leftDerivedToHomotopyCategory (𝟙 F) = 𝟙 _ 
goal: CategoryTheory.NatTrans.leftDerivedToHomotopyCategory (CategoryTheory.CategoryStruct.id F) =
  CategoryTheory.CategoryStruct.id F.leftDerivedToHomotopyCategory

full_name: CategoryTheory.NatTrans.leftDerivedToHomotopyCategory_comp
code: @[simp, reassoc]
lemma NatTrans.leftDerivedToHomotopyCategory_comp {F G H : C ⥤ D} (α : F ⟶ G) (β : G ⟶ H)
    [F.Additive] [G.Additive] [H.Additive] :
    NatTrans.leftDerivedToHomotopyCategory (α ≫ β) =
      NatTrans.leftDerivedToHomotopyCategory α ≫
        NatTrans.leftDerivedToHomotopyCategory β 
goal: CategoryTheory.NatTrans.leftDerivedToHomotopyCategory (CategoryTheory.CategoryStruct.comp α β) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.leftDerivedToHomotopyCategory α)
    (CategoryTheory.NatTrans.leftDerivedToHomotopyCategory β)

full_name: CategoryTheory.NatTrans.leftDerived
code: /-- The natural transformation between left-derived functors induced by a natural transformation. -/
noncomputable def NatTrans.leftDerived
    {F G : C ⥤ D} [F.Additive] [G.Additive] (α : F ⟶ G) (n : ℕ) :
    F.leftDerived n ⟶ G.leftDerived n 
goal: F.leftDerived n ⟶ G.leftDerived n

full_name: CategoryTheory.NatTrans.leftDerived_id
code: @[simp]
theorem NatTrans.leftDerived_id (F : C ⥤ D) [F.Additive] (n : ℕ) :
    NatTrans.leftDerived (𝟙 F) n = 𝟙 (F.leftDerived n) 
goal: CategoryTheory.NatTrans.leftDerived (CategoryTheory.CategoryStruct.id F) n =
  CategoryTheory.CategoryStruct.id (F.leftDerived n)

full_name: CategoryTheory.NatTrans.leftDerived_comp
code: @[simp, reassoc]
theorem NatTrans.leftDerived_comp {F G H : C ⥤ D} [F.Additive] [G.Additive] [H.Additive]
    (α : F ⟶ G) (β : G ⟶ H) (n : ℕ) :
    NatTrans.leftDerived (α ≫ β) n = NatTrans.leftDerived α n ≫ NatTrans.leftDerived β n 
goal: CategoryTheory.NatTrans.leftDerived (CategoryTheory.CategoryStruct.comp α β) n =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTrans.leftDerived α n) (CategoryTheory.NatTrans.leftDerived β n)

full_name: CategoryTheory.ProjectiveResolution.leftDerived_app_eq
code: /-- A component of the natural transformation between left-derived functors can be computed
using a chosen projective resolution. -/
lemma leftDerived_app_eq
    {F G : C ⥤ D} [F.Additive] [G.Additive] (α : F ⟶ G) {X : C} (P : ProjectiveResolution X)
    (n : ℕ) : (NatTrans.leftDerived α n).app X =
      (P.isoLeftDerivedObj F n).hom ≫
        (HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n).map
        ((NatTrans.mapHomologicalComplex α _).app P.complex) ≫
        (P.isoLeftDerivedObj G n).inv 
goal: (CategoryTheory.NatTrans.leftDerived α n).app X =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedObj F n).hom
    (CategoryTheory.CategoryStruct.comp
      ((HomologicalComplex.homologyFunctor D (ComplexShape.down ℕ) n).map
        ((CategoryTheory.NatTrans.mapHomologicalComplex α (ComplexShape.down ℕ)).app P.complex))
      (P.isoLeftDerivedObj G n).inv)

full_name: CategoryTheory.ProjectiveResolution.fromLeftDerivedZero'
code: /-- If `P : ProjectiveResolution X` and `F` is an additive functor, this is
the canonical morphism from the opcycles in degree `0` of
`(F.mapHomologicalComplex _).obj P.complex` to `F.obj X`. -/
noncomputable def fromLeftDerivedZero' {X : C}
    (P : ProjectiveResolution X) (F : C ⥤ D) [F.Additive] :
    ((F.mapHomologicalComplex _).obj P.complex).opcycles 0 ⟶ F.obj X 
goal: ((F.mapHomologicalComplex (ComplexShape.down ℕ)).obj P.complex).opcycles 0 ⟶ F.obj X

full_name: CategoryTheory.ProjectiveResolution.pOpcycles_comp_fromLeftDerivedZero'
code: @[reassoc (attr := simp)]
lemma pOpcycles_comp_fromLeftDerivedZero' {X : C}
    (P : ProjectiveResolution X) (F : C ⥤ D) [F.Additive] :
    HomologicalComplex.pOpcycles _ _ ≫ P.fromLeftDerivedZero' F = F.map (P.π.f 0) 
goal: CategoryTheory.CategoryStruct.comp (((F.mapHomologicalComplex (ComplexShape.down ℕ)).obj P.complex).pOpcycles 0)
    (P.fromLeftDerivedZero' F) =
  F.map (P.π.f 0)

full_name: CategoryTheory.ProjectiveResolution.fromLeftDerivedZero'_naturality
code: @[reassoc]
lemma fromLeftDerivedZero'_naturality {X Y : C} (f : X ⟶ Y)
    (P : ProjectiveResolution X) (Q : ProjectiveResolution Y)
    (φ : P.complex ⟶ Q.complex) (comm : φ.f 0 ≫ Q.π.f 0 = P.π.f 0 ≫ f)
    (F : C ⥤ D) [F.Additive] :
    HomologicalComplex.opcyclesMap ((F.mapHomologicalComplex _).map φ) 0 ≫
        Q.fromLeftDerivedZero' F = P.fromLeftDerivedZero' F ≫ F.map f 
goal: CategoryTheory.CategoryStruct.comp
    (HomologicalComplex.opcyclesMap ((F.mapHomologicalComplex (ComplexShape.down ℕ)).map φ) 0)
    (Q.fromLeftDerivedZero' F) =
  CategoryTheory.CategoryStruct.comp (P.fromLeftDerivedZero' F) (F.map f)

full_name: CategoryTheory.ProjectiveResolution.instIsIsoFromLeftDerivedZero'Self
code: instance (F : C ⥤ D) [F.Additive] (X : C) [Projective X] :
    IsIso ((ProjectiveResolution.self X).fromLeftDerivedZero' F) 
goal: CategoryTheory.IsIso ((CategoryTheory.ProjectiveResolution.self X).fromLeftDerivedZero' F)

full_name: CategoryTheory.Functor.fromLeftDerivedZero
code: /-- The natural transformation `F.leftDerived 0 ⟶ F`. -/
noncomputable def Functor.fromLeftDerivedZero (F : C ⥤ D) [F.Additive] :
    F.leftDerived 0 ⟶ F 
goal: F.leftDerived 0 ⟶ F

full_name: CategoryTheory.ProjectiveResolution.fromLeftDerivedZero_eq
code: lemma ProjectiveResolution.fromLeftDerivedZero_eq
    {X : C} (P : ProjectiveResolution X) (F : C ⥤ D) [F.Additive] :
    F.fromLeftDerivedZero.app X = (P.isoLeftDerivedObj F 0).hom ≫
      (ChainComplex.isoHomologyι₀ _).hom ≫
        P.fromLeftDerivedZero' F 
goal: F.fromLeftDerivedZero.app X =
  CategoryTheory.CategoryStruct.comp (P.isoLeftDerivedObj F 0).hom
    (CategoryTheory.CategoryStruct.comp
      (ChainComplex.isoHomologyι₀ ((F.mapHomologicalComplex (ComplexShape.down ℕ)).obj P.complex)).hom
      (P.fromLeftDerivedZero' F))

full_name: CategoryTheory.instIsIsoAppFromLeftDerivedZeroOfProjective
code: instance (F : C ⥤ D) [F.Additive] (X : C) [Projective X] :
    IsIso (F.fromLeftDerivedZero.app X) 
goal: CategoryTheory.IsIso (F.fromLeftDerivedZero.app X)

full_name: CategoryTheory.instIsIsoFromLeftDerivedZero'
code: instance {X : C} (P : ProjectiveResolution X) :
    IsIso (P.fromLeftDerivedZero' F) 
goal: CategoryTheory.IsIso (P.fromLeftDerivedZero' F)

full_name: CategoryTheory.instIsIsoAppFromLeftDerivedZero
code: instance (X : C) : IsIso (F.fromLeftDerivedZero.app X) 
goal: CategoryTheory.IsIso (F.fromLeftDerivedZero.app X)

full_name: CategoryTheory.instIsIsoFunctorFromLeftDerivedZero
code: instance : IsIso F.fromLeftDerivedZero 
goal: CategoryTheory.IsIso F.fromLeftDerivedZero

full_name: CategoryTheory.Functor.leftDerivedZeroIsoSelf_hom
code: /-- The canonical isomorphism `F.leftDerived 0 ≅ F` when `F` is right exact
(i.e. preserves finite colimits). -/
@[simps! hom]
noncomputable def leftDerivedZeroIsoSelf : F.leftDerived 0 ≅ F 
goal: F.leftDerivedZeroIsoSelf.hom = F.fromLeftDerivedZero

full_name: CategoryTheory.Functor.leftDerivedZeroIsoSelf
code: /-- The canonical isomorphism `F.leftDerived 0 ≅ F` when `F` is right exact
(i.e. preserves finite colimits). -/
@[simps! hom]
noncomputable def leftDerivedZeroIsoSelf : F.leftDerived 0 ≅ F 
goal: F.leftDerived 0 ≅ F

full_name: CategoryTheory.Functor.leftDerivedZeroIsoSelf_hom_inv_id
code: @[reassoc (attr := simp)]
lemma leftDerivedZeroIsoSelf_hom_inv_id :
    F.fromLeftDerivedZero ≫ F.leftDerivedZeroIsoSelf.inv = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp F.fromLeftDerivedZero F.leftDerivedZeroIsoSelf.inv =
  CategoryTheory.CategoryStruct.id (F.leftDerived 0)

full_name: CategoryTheory.Functor.leftDerivedZeroIsoSelf_inv_hom_id
code: @[reassoc (attr := simp)]
lemma leftDerivedZeroIsoSelf_inv_hom_id :
    F.leftDerivedZeroIsoSelf.inv ≫ F.fromLeftDerivedZero =  𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp F.leftDerivedZeroIsoSelf.inv F.fromLeftDerivedZero =
  CategoryTheory.CategoryStruct.id F

full_name: CategoryTheory.Functor.leftDerivedZeroIsoSelf_hom_inv_id_app
code: @[reassoc (attr := simp)]
lemma leftDerivedZeroIsoSelf_hom_inv_id_app (X : C) :
    F.fromLeftDerivedZero.app X ≫ F.leftDerivedZeroIsoSelf.inv.app X = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (F.fromLeftDerivedZero.app X) (F.leftDerivedZeroIsoSelf.inv.app X) =
  CategoryTheory.CategoryStruct.id ((F.leftDerived 0).obj X)

full_name: CategoryTheory.Functor.leftDerivedZeroIsoSelf_inv_hom_id_app
code: @[reassoc (attr := simp)]
lemma leftDerivedZeroIsoSelf_inv_hom_id_app (X : C) :
    F.leftDerivedZeroIsoSelf.inv.app X ≫ F.fromLeftDerivedZero.app X = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp (F.leftDerivedZeroIsoSelf.inv.app X) (F.fromLeftDerivedZero.app X) =
  CategoryTheory.CategoryStruct.id (F.obj X)