File: Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean

full_name: CategoryTheory.InjectiveResolution.descFZero
code: /-- Auxiliary construction for `desc`. -/
def descFZero {Y Z : C} (f : Z ⟶ Y) (I : InjectiveResolution Y) (J : InjectiveResolution Z) :
    J.cocomplex.X 0 ⟶ I.cocomplex.X 0 
goal: J.cocomplex.X 0 ⟶ I.cocomplex.X 0

full_name: CategoryTheory.InjectiveResolution.exact₀
code: lemma exact₀ {Z : C} (I : InjectiveResolution Z) :
    (ShortComplex.mk _ _ I.ι_f_zero_comp_complex_d).Exact 
goal: (CategoryTheory.ShortComplex.mk (I.ι.f 0) (I.cocomplex.d 0 1) ⋯).Exact

full_name: CategoryTheory.InjectiveResolution.descFOne
code: /-- Auxiliary construction for `desc`. -/
def descFOne {Y Z : C} (f : Z ⟶ Y) (I : InjectiveResolution Y) (J : InjectiveResolution Z) :
    J.cocomplex.X 1 ⟶ I.cocomplex.X 1 
goal: J.cocomplex.X 1 ⟶ I.cocomplex.X 1

full_name: CategoryTheory.InjectiveResolution.descFOne_zero_comm
code: @[simp]
theorem descFOne_zero_comm {Y Z : C} (f : Z ⟶ Y) (I : InjectiveResolution Y)
    (J : InjectiveResolution Z) :
    J.cocomplex.d 0 1 ≫ descFOne f I J = descFZero f I J ≫ I.cocomplex.d 0 1 
goal: J.cocomplex.d 0 1 ≫ CategoryTheory.InjectiveResolution.descFOne f I J =
  CategoryTheory.InjectiveResolution.descFZero f I J ≫ I.cocomplex.d 0 1

full_name: CategoryTheory.InjectiveResolution.descFSucc
code: /-- Auxiliary construction for `desc`. -/
def descFSucc {Y Z : C} (I : InjectiveResolution Y) (J : InjectiveResolution Z) (n : ℕ)
    (g : J.cocomplex.X n ⟶ I.cocomplex.X n) (g' : J.cocomplex.X (n + 1) ⟶ I.cocomplex.X (n + 1))
    (w : J.cocomplex.d n (n + 1) ≫ g' = g ≫ I.cocomplex.d n (n + 1)) :
    Σ'g'' : J.cocomplex.X (n + 2) ⟶ I.cocomplex.X (n + 2),
      J.cocomplex.d (n + 1) (n + 2) ≫ g'' = g' ≫ I.cocomplex.d (n + 1) (n + 2) 
goal: (g'' : J.cocomplex.X (n + 2) ⟶ I.cocomplex.X (n + 2)) ×'
  J.cocomplex.d (n + 1) (n + 2) ≫ g'' = g' ≫ I.cocomplex.d (n + 1) (n + 2)

full_name: CategoryTheory.InjectiveResolution.desc
code: /-- A morphism in `C` descends to a chain map between injective resolutions. -/
def desc {Y Z : C} (f : Z ⟶ Y) (I : InjectiveResolution Y) (J : InjectiveResolution Z) :
    J.cocomplex ⟶ I.cocomplex 
goal: J.cocomplex ⟶ I.cocomplex

full_name: CategoryTheory.InjectiveResolution.desc_commutes
code: /-- The resolution maps intertwine the descent of a morphism and that morphism. -/
@[reassoc (attr := simp)]
theorem desc_commutes {Y Z : C} (f : Z ⟶ Y) (I : InjectiveResolution Y)
    (J : InjectiveResolution Z) : J.ι ≫ desc f I J = (CochainComplex.single₀ C).map f ≫ I.ι 
goal: J.ι ≫ CategoryTheory.InjectiveResolution.desc f I J = (CochainComplex.single₀ C).map f ≫ I.ι

full_name: CategoryTheory.InjectiveResolution.desc_commutes_zero
code: @[reassoc (attr := simp)]
lemma desc_commutes_zero {Y Z : C} (f : Z ⟶ Y)
    (I : InjectiveResolution Y) (J : InjectiveResolution Z) :
    J.ι.f 0 ≫ (desc f I J).f 0 = f ≫ I.ι.f 0 
goal: J.ι.f 0 ≫ (CategoryTheory.InjectiveResolution.desc f I J).f 0 = f ≫ I.ι.f 0

full_name: CategoryTheory.InjectiveResolution.descHomotopyZeroZero
code: /-- An auxiliary definition for `descHomotopyZero`. -/
def descHomotopyZeroZero {Y Z : C} {I : InjectiveResolution Y} {J : InjectiveResolution Z}
    (f : I.cocomplex ⟶ J.cocomplex) (comm : I.ι ≫ f = 0) : I.cocomplex.X 1 ⟶ J.cocomplex.X 0 
goal: I.cocomplex.X 1 ⟶ J.cocomplex.X 0

full_name: CategoryTheory.InjectiveResolution.comp_descHomotopyZeroZero
code: @[reassoc (attr := simp)]
lemma comp_descHomotopyZeroZero {Y Z : C} {I : InjectiveResolution Y} {J : InjectiveResolution Z}
    (f : I.cocomplex ⟶ J.cocomplex) (comm : I.ι ≫ f = 0) :
    I.cocomplex.d 0 1 ≫ descHomotopyZeroZero f comm = f.f 0 
goal: I.cocomplex.d 0 1 ≫ CategoryTheory.InjectiveResolution.descHomotopyZeroZero f comm = f.f 0

full_name: CategoryTheory.InjectiveResolution.descHomotopyZeroOne
code: /-- An auxiliary definition for `descHomotopyZero`. -/
def descHomotopyZeroOne {Y Z : C} {I : InjectiveResolution Y} {J : InjectiveResolution Z}
    (f : I.cocomplex ⟶ J.cocomplex) (comm : I.ι ≫ f = (0 : _ ⟶ J.cocomplex)) :
    I.cocomplex.X 2 ⟶ J.cocomplex.X 1 
goal: I.cocomplex.X 2 ⟶ J.cocomplex.X 1

full_name: CategoryTheory.InjectiveResolution.comp_descHomotopyZeroOne
code: @[reassoc (attr := simp)]
lemma comp_descHomotopyZeroOne {Y Z : C} {I : InjectiveResolution Y} {J : InjectiveResolution Z}
    (f : I.cocomplex ⟶ J.cocomplex) (comm : I.ι ≫ f = (0 : _ ⟶ J.cocomplex)) :
    I.cocomplex.d 1 2 ≫ descHomotopyZeroOne f comm =
      f.f 1 - descHomotopyZeroZero f comm ≫ J.cocomplex.d 0 1 
goal: I.cocomplex.d 1 2 ≫ CategoryTheory.InjectiveResolution.descHomotopyZeroOne f comm =
  f.f 1 - CategoryTheory.InjectiveResolution.descHomotopyZeroZero f comm ≫ J.cocomplex.d 0 1

full_name: CategoryTheory.InjectiveResolution.descHomotopyZeroSucc
code: /-- An auxiliary definition for `descHomotopyZero`. -/
def descHomotopyZeroSucc {Y Z : C} {I : InjectiveResolution Y} {J : InjectiveResolution Z}
    (f : I.cocomplex ⟶ J.cocomplex) (n : ℕ) (g : I.cocomplex.X (n + 1) ⟶ J.cocomplex.X n)
    (g' : I.cocomplex.X (n + 2) ⟶ J.cocomplex.X (n + 1))
    (w : f.f (n + 1) = I.cocomplex.d (n + 1) (n + 2) ≫ g' + g ≫ J.cocomplex.d n (n + 1)) :
    I.cocomplex.X (n + 3) ⟶ J.cocomplex.X (n + 2) 
goal: I.cocomplex.X (n + 3) ⟶ J.cocomplex.X (n + 2)

full_name: CategoryTheory.InjectiveResolution.comp_descHomotopyZeroSucc
code: @[reassoc (attr := simp)]
lemma comp_descHomotopyZeroSucc {Y Z : C} {I : InjectiveResolution Y} {J : InjectiveResolution Z}
    (f : I.cocomplex ⟶ J.cocomplex) (n : ℕ) (g : I.cocomplex.X (n + 1) ⟶ J.cocomplex.X n)
    (g' : I.cocomplex.X (n + 2) ⟶ J.cocomplex.X (n + 1))
    (w : f.f (n + 1) = I.cocomplex.d (n + 1) (n + 2) ≫ g' + g ≫ J.cocomplex.d n (n + 1)) :
    I.cocomplex.d (n+2) (n+3) ≫ descHomotopyZeroSucc f n g g' w =
      f.f (n + 2) - g' ≫ J.cocomplex.d _ _ 
goal: I.cocomplex.d (n + 2) (n + 3) ≫ CategoryTheory.InjectiveResolution.descHomotopyZeroSucc f n g g' w =
  f.f (n + 2) - g' ≫ J.cocomplex.d (n + 1) (n + 2)

full_name: CategoryTheory.InjectiveResolution.descHomotopyZero
code: /-- Any descent of the zero morphism is homotopic to zero. -/
def descHomotopyZero {Y Z : C} {I : InjectiveResolution Y} {J : InjectiveResolution Z}
    (f : I.cocomplex ⟶ J.cocomplex) (comm : I.ι ≫ f = 0) : Homotopy f 0 
goal: Homotopy f 0

full_name: CategoryTheory.InjectiveResolution.descHomotopy
code: /-- Two descents of the same morphism are homotopic. -/
def descHomotopy {Y Z : C} (f : Y ⟶ Z) {I : InjectiveResolution Y} {J : InjectiveResolution Z}
    (g h : I.cocomplex ⟶ J.cocomplex) (g_comm : I.ι ≫ g = (CochainComplex.single₀ C).map f ≫ J.ι)
    (h_comm : I.ι ≫ h = (CochainComplex.single₀ C).map f ≫ J.ι) : Homotopy g h 
goal: Homotopy g h

full_name: CategoryTheory.InjectiveResolution.descIdHomotopy
code: /-- The descent of the identity morphism is homotopic to the identity cochain map. -/
def descIdHomotopy (X : C) (I : InjectiveResolution X) :
    Homotopy (desc (𝟙 X) I I) (𝟙 I.cocomplex) 
goal: Homotopy (CategoryTheory.InjectiveResolution.desc (𝟙 X) I I) (𝟙 I.cocomplex)

full_name: CategoryTheory.InjectiveResolution.descCompHomotopy
code: /-- The descent of a composition is homotopic to the composition of the descents. -/
def descCompHomotopy {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (I : InjectiveResolution X)
    (J : InjectiveResolution Y) (K : InjectiveResolution Z) :
    Homotopy (desc (f ≫ g) K I) (desc f J I ≫ desc g K J) 
goal: Homotopy (CategoryTheory.InjectiveResolution.desc (f ≫ g) K I)
  (CategoryTheory.InjectiveResolution.desc f J I ≫ CategoryTheory.InjectiveResolution.desc g K J)

full_name: CategoryTheory.InjectiveResolution.homotopyEquiv
code: /-- Any two injective resolutions are homotopy equivalent. -/
def homotopyEquiv {X : C} (I J : InjectiveResolution X) :
    HomotopyEquiv I.cocomplex J.cocomplex 
goal: HomotopyEquiv I.cocomplex J.cocomplex

full_name: CategoryTheory.InjectiveResolution.homotopyEquiv_hom_ι
code: @[reassoc (attr := simp)]
theorem homotopyEquiv_hom_ι {X : C} (I J : InjectiveResolution X) :
    I.ι ≫ (homotopyEquiv I J).hom = J.ι 
goal: I.ι ≫ (I.homotopyEquiv J).hom = J.ι

full_name: CategoryTheory.InjectiveResolution.homotopyEquiv_inv_ι
code: @[reassoc (attr := simp)]
theorem homotopyEquiv_inv_ι {X : C} (I J : InjectiveResolution X) :
    J.ι ≫ (homotopyEquiv I J).inv = I.ι 
goal: J.ι ≫ (I.homotopyEquiv J).inv = I.ι

full_name: CategoryTheory.injectiveResolution
code: /-- An arbitrarily chosen injective resolution of an object. -/
abbrev injectiveResolution (Z : C) [HasInjectiveResolution Z] : InjectiveResolution Z 
goal: CategoryTheory.InjectiveResolution Z

full_name: CategoryTheory.injectiveResolutions
code: /-- Taking injective resolutions is functorial,
if considered with target the homotopy category
(`ℕ`-indexed cochain complexes and chain maps up to homotopy).
-/
def injectiveResolutions : C ⥤ HomotopyCategory C (ComplexShape.up ℕ) 
goal: C ⥤ HomotopyCategory C (ComplexShape.up ℕ)

full_name: CategoryTheory.InjectiveResolution.iso
code: /-- If `I : InjectiveResolution X`, then the chosen `(injectiveResolutions C).obj X`
is isomorphic (in the homotopy category) to `I.cocomplex`. -/
def InjectiveResolution.iso {X : C} (I : InjectiveResolution X) :
    (injectiveResolutions C).obj X ≅
      (HomotopyCategory.quotient _ _).obj I.cocomplex 
goal: (CategoryTheory.injectiveResolutions C).obj X ≅ (HomotopyCategory.quotient C (ComplexShape.up ℕ)).obj I.cocomplex

full_name: CategoryTheory.InjectiveResolution.iso_hom_naturality
code: @[reassoc]
lemma InjectiveResolution.iso_hom_naturality {X Y : C} (f : X ⟶ Y)
    (I : InjectiveResolution X) (J : InjectiveResolution Y)
    (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0) :
    (injectiveResolutions C).map f ≫ J.iso.hom =
      I.iso.hom ≫ (HomotopyCategory.quotient _ _).map φ 
goal: (CategoryTheory.injectiveResolutions C).map f ≫ J.iso.hom =
  I.iso.hom ≫ (HomotopyCategory.quotient C (ComplexShape.up ℕ)).map φ

full_name: CategoryTheory.InjectiveResolution.iso_inv_naturality
code: @[reassoc]
lemma InjectiveResolution.iso_inv_naturality {X Y : C} (f : X ⟶ Y)
    (I : InjectiveResolution X) (J : InjectiveResolution Y)
    (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0) :
    I.iso.inv ≫ (injectiveResolutions C).map f =
      (HomotopyCategory.quotient _ _).map φ ≫ J.iso.inv 
goal: I.iso.inv ≫ (CategoryTheory.injectiveResolutions C).map f =
  (HomotopyCategory.quotient C (ComplexShape.up ℕ)).map φ ≫ J.iso.inv

full_name: CategoryTheory.exact_f_d
code: theorem exact_f_d {X Y : C} (f : X ⟶ Y) :
    (ShortComplex.mk f (d f) (by simp)).Exact 
goal: (CategoryTheory.ShortComplex.mk f (CategoryTheory.Injective.d f) ⋯).Exact

full_name: CategoryTheory.InjectiveResolution.ofCocomplex
code: /-- Auxiliary definition for `InjectiveResolution.of`. -/
def ofCocomplex : CochainComplex C ℕ 
goal: CochainComplex C ℕ

full_name: CategoryTheory.InjectiveResolution.ofCocomplex_d_0_1
code: lemma ofCocomplex_d_0_1 :
    (ofCocomplex Z).d 0 1 = d (Injective.ι Z) 
goal: (CategoryTheory.InjectiveResolution.ofCocomplex Z).d 0 1 = CategoryTheory.Injective.d (CategoryTheory.Injective.ι Z)

full_name: CategoryTheory.InjectiveResolution.ofCocomplex_exactAt_succ
code: lemma ofCocomplex_exactAt_succ (n : ℕ) :
    (ofCocomplex Z).ExactAt (n + 1) 
goal: HomologicalComplex.ExactAt (CategoryTheory.InjectiveResolution.ofCocomplex Z) (n + 1)

full_name: CategoryTheory.InjectiveResolution.instInjectiveXNatOfCocomplex
code: instance (n : ℕ) : Injective ((ofCocomplex Z).X n) 
goal: CategoryTheory.Injective ((CategoryTheory.InjectiveResolution.ofCocomplex Z).X n)

full_name: CategoryTheory.InjectiveResolution.wrapped._@.Mathlib.CategoryTheory.Abelian.InjectiveResolution._hyg.2787
code: /-- In any abelian category with enough injectives,
`InjectiveResolution.of Z` constructs an injective resolution of the object `Z`.
-/
irreducible_def of : InjectiveResolution Z 
goal: Subtype (Eq @CategoryTheory.InjectiveResolution.definition✝)

full_name: CategoryTheory.InjectiveResolution.of_def
code: /-- In any abelian category with enough injectives,
`InjectiveResolution.of Z` constructs an injective resolution of the object `Z`.
-/
irreducible_def of : InjectiveResolution Z 
goal: CategoryTheory.InjectiveResolution.of Z =
  CategoryTheory.InjectiveResolution.mk (CategoryTheory.InjectiveResolution.ofCocomplex Z) ⋯
    (((CategoryTheory.InjectiveResolution.ofCocomplex Z).fromSingle₀Equiv Z).symm ⟨CategoryTheory.Injective.ι Z, ⋯⟩) ⋯

full_name: CategoryTheory.InjectiveResolution.of
code: /-- In any abelian category with enough injectives,
`InjectiveResolution.of Z` constructs an injective resolution of the object `Z`.
-/
irreducible_def of : InjectiveResolution Z 
goal: CategoryTheory.InjectiveResolution Z

full_name: CategoryTheory.InjectiveResolution.definition._@.Mathlib.CategoryTheory.Abelian.InjectiveResolution._hyg.2787
code: /-- In any abelian category with enough injectives,
`InjectiveResolution.of Z` constructs an injective resolution of the object `Z`.
-/
irreducible_def of : InjectiveResolution Z 
goal: CategoryTheory.InjectiveResolution Z

full_name: CategoryTheory.InjectiveResolution.instHasInjectiveResolution
code: instance (priority := 100) (Z : C) : HasInjectiveResolution Z 
goal: CategoryTheory.HasInjectiveResolution Z

full_name: CategoryTheory.InjectiveResolution.instHasInjectiveResolutions
code: instance (priority := 100) : HasInjectiveResolutions C 
goal: CategoryTheory.HasInjectiveResolutions C