ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Abelian.Pseudoelement.pseudoApply_aux
theorem pseudoApply_aux {P Q : C} (f : P ⟶ Q) (a b : Over P) : a ≈ b → app f a ≈ app f b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q) (a b : CategoryTheory.Over P)
Goal: a ≈ b → CategoryTheory.Abelian.app f a ≈ CategoryTheory.Abelian.app f b
-- CategoryTheory.Abelian.Pseudoelement.pseudoApply_mk'
theorem pseudoApply_mk' {P Q : C} (f : P ⟶ Q) (a : Over P) : f ⟦a⟧ = ⟦↑(a.hom ≫ f)⟧ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q) (a : CategoryTheory.Over P)
Goal: CategoryTheory.Abelian.Pseudoelement.pseudoApply f ⟦a⟧ = ⟦CategoryTheory.Over.mk (a.hom ≫ f)⟧
-- CategoryTheory.Abelian.Pseudoelement.comp_apply
theorem comp_apply {P Q R : C} (f : P ⟶ Q) (g : Q ⟶ R) (a : P) : (f ≫ g) a = g (f a) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q R : C} (f : P ⟶ Q) (g : Q ⟶ R) (a : CategoryTheory.Abelian.Pseudoelement P)
Goal: CategoryTheory.Abelian.Pseudoelement.pseudoApply (f ≫ g) a =
  CategoryTheory.Abelian.Pseudoelement.pseudoApply g (CategoryTheory.Abelian.Pseudoelement.pseudoApply f a)
-- CategoryTheory.Abelian.Pseudoelement.comp_comp
theorem comp_comp {P Q R : C} (f : P ⟶ Q) (g : Q ⟶ R) : g ∘ f = f ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q R : C} (f : P ⟶ Q) (g : Q ⟶ R)
Goal: CategoryTheory.Abelian.Pseudoelement.pseudoApply g ∘ CategoryTheory.Abelian.Pseudoelement.pseudoApply f =
  CategoryTheory.Abelian.Pseudoelement.pseudoApply (f ≫ g)
-- CategoryTheory.Abelian.Pseudoelement.pseudoZero_aux
theorem pseudoZero_aux {P : C} (Q : C) (f : Over P) : f ≈ (0 : Q ⟶ P) ↔ f.hom = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P : C} (Q : C) (f : CategoryTheory.Over P)
Goal: f ≈ CategoryTheory.Over.mk 0 ↔ f.hom = 0
-- CategoryTheory.Abelian.Pseudoelement.zero_eq_zero'
theorem zero_eq_zero' {P Q R : C} :
    (⟦((0 : Q ⟶ P) : Over P)⟧ : Pseudoelement P) = ⟦((0 : R ⟶ P) : Over P)⟧ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q R : C}
Goal: ⟦CategoryTheory.Over.mk 0⟧ = ⟦CategoryTheory.Over.mk 0⟧
-- CategoryTheory.Abelian.Pseudoelement.pseudoZero_def
theorem pseudoZero_def {P : C} : (0 : Pseudoelement P) = ⟦↑(0 : P ⟶ P)⟧ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P : C}
Goal: 0 = ⟦CategoryTheory.Over.mk 0⟧
-- CategoryTheory.Abelian.Pseudoelement.zero_eq_zero
@[simp]
theorem zero_eq_zero {P Q : C} : ⟦((0 : Q ⟶ P) : Over P)⟧ = (0 : Pseudoelement P) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C}
Goal: ⟦CategoryTheory.Over.mk 0⟧ = 0
-- CategoryTheory.Abelian.Pseudoelement.pseudoZero_iff
theorem pseudoZero_iff {P : C} (a : Over P) : a = (0 : P) ↔ a.hom = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P : C} (a : CategoryTheory.Over P)
Goal: Quot.mk (CategoryTheory.Abelian.PseudoEqual P) a = 0 ↔ a.hom = 0
-- CategoryTheory.Abelian.Pseudoelement.apply_zero
@[simp]
theorem apply_zero {P Q : C} (f : P ⟶ Q) : f 0 = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: CategoryTheory.Abelian.Pseudoelement.pseudoApply f 0 = 0
-- CategoryTheory.Abelian.Pseudoelement.zero_apply
@[simp]
theorem zero_apply {P : C} (Q : C) (a : P) : (0 : P ⟶ Q) a = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P : C} (Q : C) (a : CategoryTheory.Abelian.Pseudoelement P)
Goal: CategoryTheory.Abelian.Pseudoelement.pseudoApply 0 a = 0
-- CategoryTheory.Abelian.Pseudoelement.zero_morphism_ext
theorem zero_morphism_ext {P Q : C} (f : P ⟶ Q) : (∀ a, f a = 0) → f = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: (∀ (a : CategoryTheory.Abelian.Pseudoelement P), CategoryTheory.Abelian.Pseudoelement.pseudoApply f a = 0) → f = 0
-- CategoryTheory.Abelian.Pseudoelement.zero_morphism_ext'
theorem zero_morphism_ext' {P Q : C} (f : P ⟶ Q) : (∀ a, f a = 0) → 0 = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: (∀ (a : CategoryTheory.Abelian.Pseudoelement P), CategoryTheory.Abelian.Pseudoelement.pseudoApply f a = 0) → 0 = f
-- CategoryTheory.Abelian.Pseudoelement.eq_zero_iff
theorem eq_zero_iff {P Q : C} (f : P ⟶ Q) : f = 0 ↔ ∀ a, f a = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: f = 0 ↔ ∀ (a : CategoryTheory.Abelian.Pseudoelement P), CategoryTheory.Abelian.Pseudoelement.pseudoApply f a = 0
-- CategoryTheory.Abelian.Pseudoelement.pseudo_injective_of_mono
theorem pseudo_injective_of_mono {P Q : C} (f : P ⟶ Q) [Mono f] : Function.Injective f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q) [CategoryTheory.Mono f]
Goal: Function.Injective (CategoryTheory.Abelian.Pseudoelement.pseudoApply f)
-- CategoryTheory.Abelian.Pseudoelement.zero_of_map_zero
theorem zero_of_map_zero {P Q : C} (f : P ⟶ Q) : Function.Injective f → ∀ a, f a = 0 → a = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: Function.Injective (CategoryTheory.Abelian.Pseudoelement.pseudoApply f) →
  ∀ (a : CategoryTheory.Abelian.Pseudoelement P), CategoryTheory.Abelian.Pseudoelement.pseudoApply f a = 0 → a = 0
-- CategoryTheory.Abelian.Pseudoelement.mono_of_zero_of_map_zero
theorem mono_of_zero_of_map_zero {P Q : C} (f : P ⟶ Q) : (∀ a, f a = 0 → a = 0) → Mono f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: (∀ (a : CategoryTheory.Abelian.Pseudoelement P), CategoryTheory.Abelian.Pseudoelement.pseudoApply f a = 0 → a = 0) →
  CategoryTheory.Mono f
-- CategoryTheory.Abelian.Pseudoelement.pseudo_surjective_of_epi
theorem pseudo_surjective_of_epi {P Q : C} (f : P ⟶ Q) [Epi f] : Function.Surjective f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q) [CategoryTheory.Epi f]
Goal: Function.Surjective (CategoryTheory.Abelian.Pseudoelement.pseudoApply f)
-- CategoryTheory.Abelian.Pseudoelement.epi_of_pseudo_surjective
theorem epi_of_pseudo_surjective {P Q : C} (f : P ⟶ Q) : Function.Surjective f → Epi f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q)
Goal: Function.Surjective (CategoryTheory.Abelian.Pseudoelement.pseudoApply f) → CategoryTheory.Epi f
-- CategoryTheory.Abelian.Pseudoelement.pseudo_exact_of_exact
theorem pseudo_exact_of_exact {S : ShortComplex C} (hS : S.Exact) :
    ∀ b, S.g b = 0 → ∃ a, S.f a = b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {S : CategoryTheory.ShortComplex C} (hS : S.Exact) (b : CategoryTheory.Abelian.Pseudoelement S.X₂)
Goal: CategoryTheory.Abelian.Pseudoelement.pseudoApply S.g b = 0 →
  ∃ a, CategoryTheory.Abelian.Pseudoelement.pseudoApply S.f a = b
-- CategoryTheory.Abelian.Pseudoelement.apply_eq_zero_of_comp_eq_zero
theorem apply_eq_zero_of_comp_eq_zero {P Q R : C} (f : Q ⟶ R) (a : P ⟶ Q) : a ≫ f = 0 → f a = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q R : C} (f : Q ⟶ R) (a : P ⟶ Q)
Goal: a ≫ f = 0 →
  CategoryTheory.Abelian.Pseudoelement.pseudoApply f
      (Quot.mk (CategoryTheory.Abelian.PseudoEqual Q) (CategoryTheory.Over.mk a)) =
    0
-- CategoryTheory.Abelian.Pseudoelement.exact_of_pseudo_exact
theorem exact_of_pseudo_exact (S : ShortComplex C)
    (hS : ∀ b, S.g b = 0 → ∃ a, S.f a = b) : S.Exact 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] (S : CategoryTheory.ShortComplex C) (hS :
  ∀ (b : CategoryTheory.Abelian.Pseudoelement S.X₂),
    CategoryTheory.Abelian.Pseudoelement.pseudoApply S.g b = 0 →
      ∃ a, CategoryTheory.Abelian.Pseudoelement.pseudoApply S.f a = b)
Goal: S.Exact
-- CategoryTheory.Abelian.Pseudoelement.sub_of_eq_image
theorem sub_of_eq_image {P Q : C} (f : P ⟶ Q) (x y : P) :
    f x = f y → ∃ z, f z = 0 ∧ ∀ (R : C) (g : P ⟶ R), (g : P ⟶ R) y = 0 → g z = g x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q) (x y : CategoryTheory.Abelian.Pseudoelement P)
Goal: CategoryTheory.Abelian.Pseudoelement.pseudoApply f x = CategoryTheory.Abelian.Pseudoelement.pseudoApply f y →
  ∃ z,
    CategoryTheory.Abelian.Pseudoelement.pseudoApply f z = 0 ∧
      ∀ (R : C) (g : P ⟶ R),
        CategoryTheory.Abelian.Pseudoelement.pseudoApply g y = 0 →
          CategoryTheory.Abelian.Pseudoelement.pseudoApply g z = CategoryTheory.Abelian.Pseudoelement.pseudoApply g x
-- CategoryTheory.Abelian.Pseudoelement.pseudo_pullback
theorem pseudo_pullback {P Q R : C} {f : P ⟶ R} {g : Q ⟶ R} {p : P} {q : Q} :
    f p = g q →
      ∃ s, pullback.fst f g s = p ∧ pullback.snd f g s = q 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.Limits.HasPullbacks C] {P Q R : C} {f : P ⟶ R} {g : Q ⟶ R} {p : CategoryTheory.Abelian.Pseudoelement P} {q : CategoryTheory.Abelian.Pseudoelement Q}
Goal: CategoryTheory.Abelian.Pseudoelement.pseudoApply f p = CategoryTheory.Abelian.Pseudoelement.pseudoApply g q →
  ∃ s,
    CategoryTheory.Abelian.Pseudoelement.pseudoApply (CategoryTheory.Limits.pullback.fst f g) s = p ∧
      CategoryTheory.Abelian.Pseudoelement.pseudoApply (CategoryTheory.Limits.pullback.snd f g) s = q
-- CategoryTheory.Abelian.Pseudoelement.ModuleCat.eq_range_of_pseudoequal
theorem ModuleCat.eq_range_of_pseudoequal {R : Type*} [CommRing R] {G : ModuleCat R} {x y : Over G}
    (h : PseudoEqual G x y) : LinearMap.range x.hom = LinearMap.range y.hom 
Arguments: {R : Type u_1} [CommRing R] {G : ModuleCat R} {x y : CategoryTheory.Over G} (h : CategoryTheory.Abelian.PseudoEqual G x y)
Goal: LinearMap.range x.hom = LinearMap.range y.hom
-- CategoryTheory.Adjunction.adjointOfOpAdjointOp_counit_app
-- Porting note: in mathlib3 we generated all the default `simps` lemmas.
-- However the `simpNF` linter correctly flags some of these as unsuitable simp lemmas.
-- `unit_app` and `counit_app` appear to suffice (tested in mathlib3).
-- See also the porting note on opAdjointOpOfAdjoint
@[simps! unit_app counit_app]
def adjointOfOpAdjointOp (F : C ⥤ D) (G : D ⥤ C) (h : G.op ⊣ F.op) : F ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) (G : D ⥤ C) (h : G.op ⊣ F.op) (Y : D)
Goal: (CategoryTheory.Adjunction.adjointOfOpAdjointOp F G h).counit.app Y =
  (CategoryTheory.opEquiv (Opposite.op Y) (Opposite.op (F.obj (G.obj Y))))
    ((h.homEquiv (Opposite.op Y) (Opposite.op (G.obj Y)))
      ((CategoryTheory.opEquiv (Opposite.op (G.obj Y)) (Opposite.op (G.obj Y))).symm (𝟙 (G.obj Y))))
-- CategoryTheory.Adjunction.adjointOfOpAdjointOp_unit_app
-- Porting note: in mathlib3 we generated all the default `simps` lemmas.
-- However the `simpNF` linter correctly flags some of these as unsuitable simp lemmas.
-- `unit_app` and `counit_app` appear to suffice (tested in mathlib3).
-- See also the porting note on opAdjointOpOfAdjoint
@[simps! unit_app counit_app]
def adjointOfOpAdjointOp (F : C ⥤ D) (G : D ⥤ C) (h : G.op ⊣ F.op) : F ⊣ G 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) (G : D ⥤ C) (h : G.op ⊣ F.op) (X : C)
Goal: (CategoryTheory.Adjunction.adjointOfOpAdjointOp F G h).unit.app X =
  (CategoryTheory.opEquiv (Opposite.op (G.obj (F.obj X))) (Opposite.op X))
    ((h.homEquiv (Opposite.op (F.obj X)) (Opposite.op X)).symm
      ((CategoryTheory.opEquiv (Opposite.op (F.obj X)) (Opposite.op (F.obj X))).symm (𝟙 (F.obj X))))
-- CategoryTheory.Adjunction.opAdjointOpOfAdjoint_counit_app
@[simps! unit_app counit_app]
-- Porting note: in mathlib3 we generated all the default `simps` lemmas.
-- However the `simpNF` linter correctly flags some of these as unsuitable simp lemmas.
-- `unit_app` and `counit_app` appear to suffice (tested in mathlib3).
-- See also the porting note on adjointOfOpAdjointOp
def opAdjointOpOfAdjoint (F : C ⥤ D) (G : D ⥤ C) (h : G ⊣ F) : F.op ⊣ G.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) (G : D ⥤ C) (h : G ⊣ F) (Y : Dᵒᵖ)
Goal: (CategoryTheory.Adjunction.opAdjointOpOfAdjoint F G h).counit.app Y =
  (CategoryTheory.opEquiv (Opposite.op (F.obj (G.obj (Opposite.unop Y)))) Y).symm
    (h.unit.app (Opposite.unop Y) ≫
      F.map
        ((CategoryTheory.opEquiv (Opposite.op (G.obj (Opposite.unop Y)))
            (Opposite.op (G.toPrefunctor.1 (Opposite.unop Y))))
          (𝟙 (Opposite.op (G.obj (Opposite.unop Y))))))
-- CategoryTheory.Adjunction.opAdjointOpOfAdjoint_unit_app
@[simps! unit_app counit_app]
-- Porting note: in mathlib3 we generated all the default `simps` lemmas.
-- However the `simpNF` linter correctly flags some of these as unsuitable simp lemmas.
-- `unit_app` and `counit_app` appear to suffice (tested in mathlib3).
-- See also the porting note on adjointOfOpAdjointOp
def opAdjointOpOfAdjoint (F : C ⥤ D) (G : D ⥤ C) (h : G ⊣ F) : F.op ⊣ G.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : C ⥤ D) (G : D ⥤ C) (h : G ⊣ F) (X : Cᵒᵖ)
Goal: (CategoryTheory.Adjunction.opAdjointOpOfAdjoint F G h).unit.app X =
  (CategoryTheory.opEquiv X (Opposite.op (G.toPrefunctor.1 (F.obj (Opposite.unop X))))).symm
    (G.map
        ((CategoryTheory.opEquiv (Opposite.op (F.obj (Opposite.unop X))) (Opposite.op (F.obj (Opposite.unop X))))
          (𝟙 (Opposite.op (F.obj (Opposite.unop X))))) ≫
      h.counit.app (Opposite.unop X))
-- CategoryTheory.InjectiveResolution.exact₀
lemma exact₀ {Z : C} (I : InjectiveResolution Z) :
    (ShortComplex.mk _ _ I.ι_f_zero_comp_complex_d).Exact 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Z : C} (I : CategoryTheory.InjectiveResolution Z)
Goal: (CategoryTheory.ShortComplex.mk (I.ι.f 0) (I.cocomplex.d 0 1) ⋯).Exact
-- CategoryTheory.InjectiveResolution.descFOne_zero_comm
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} (f : Z ⟶ Y) (I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z)
Goal: J.cocomplex.d 0 1 ≫ CategoryTheory.InjectiveResolution.descFOne f I J =
  CategoryTheory.InjectiveResolution.descFZero f I J ≫ I.cocomplex.d 0 1
-- CategoryTheory.InjectiveResolution.desc_commutes
@[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.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} (f : Z ⟶ Y) (I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z)
Goal: J.ι ≫ CategoryTheory.InjectiveResolution.desc f I J = (CochainComplex.single₀ C).map f ≫ I.ι
-- CategoryTheory.InjectiveResolution.desc_commutes_zero
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} (f : Z ⟶ Y) (I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z)
Goal: J.ι.f 0 ≫ (CategoryTheory.InjectiveResolution.desc f I J).f 0 = f ≫ I.ι.f 0
-- CategoryTheory.InjectiveResolution.comp_descHomotopyZeroZero
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} {I : CategoryTheory.InjectiveResolution Y} {J : CategoryTheory.InjectiveResolution Z} (f : I.cocomplex ⟶ J.cocomplex) (comm : I.ι ≫ f = 0)
Goal: I.cocomplex.d 0 1 ≫ CategoryTheory.InjectiveResolution.descHomotopyZeroZero f comm = f.f 0
-- CategoryTheory.InjectiveResolution.comp_descHomotopyZeroOne
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} {I : CategoryTheory.InjectiveResolution Y} {J : CategoryTheory.InjectiveResolution Z} (f : I.cocomplex ⟶ J.cocomplex) (comm : I.ι ≫ f = 0)
Goal: I.cocomplex.d 1 2 ≫ CategoryTheory.InjectiveResolution.descHomotopyZeroOne f comm =
  f.f 1 - CategoryTheory.InjectiveResolution.descHomotopyZeroZero f comm ≫ J.cocomplex.d 0 1
-- CategoryTheory.InjectiveResolution.comp_descHomotopyZeroSucc
@[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 _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {Y Z : C} {I : CategoryTheory.InjectiveResolution Y} {J : CategoryTheory.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))
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)
-- CategoryTheory.InjectiveResolution.homotopyEquiv_hom_ι
@[reassoc (attr := simp)]
theorem homotopyEquiv_hom_ι {X : C} (I J : InjectiveResolution X) :
    I.ι ≫ (homotopyEquiv I J).hom = J.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {X : C} (I J : CategoryTheory.InjectiveResolution X)
Goal: I.ι ≫ (I.homotopyEquiv J).hom = J.ι
-- CategoryTheory.InjectiveResolution.homotopyEquiv_inv_ι
@[reassoc (attr := simp)]
theorem homotopyEquiv_inv_ι {X : C} (I J : InjectiveResolution X) :
    J.ι ≫ (homotopyEquiv I J).inv = I.ι 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {X : C} (I J : CategoryTheory.InjectiveResolution X)
Goal: J.ι ≫ (I.homotopyEquiv J).inv = I.ι
-- CategoryTheory.InjectiveResolution.iso_hom_naturality
@[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 φ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasInjectiveResolutions C] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X) (J : CategoryTheory.InjectiveResolution Y) (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0)
Goal: (CategoryTheory.injectiveResolutions C).map f ≫ J.iso.hom =
  I.iso.hom ≫ (HomotopyCategory.quotient C (ComplexShape.up ℕ)).map φ
-- CategoryTheory.InjectiveResolution.iso_inv_naturality
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasInjectiveResolutions C] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X) (J : CategoryTheory.InjectiveResolution Y) (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0)
Goal: I.iso.inv ≫ (CategoryTheory.injectiveResolutions C).map f =
  (HomotopyCategory.quotient C (ComplexShape.up ℕ)).map φ ≫ J.iso.inv
-- CategoryTheory.exact_f_d
theorem exact_f_d {X Y : C} (f : X ⟶ Y) :
    (ShortComplex.mk f (d f) (by simp)).Exact 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.EnoughInjectives C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.ShortComplex.mk f (CategoryTheory.Injective.d f) ⋯).Exact
-- CategoryTheory.InjectiveResolution.ofCocomplex_d_0_1
lemma ofCocomplex_d_0_1 :
    (ofCocomplex Z).d 0 1 = d (Injective.ι Z) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.EnoughInjectives C] (Z : C)
Goal: (CategoryTheory.InjectiveResolution.ofCocomplex Z).d 0 1 = CategoryTheory.Injective.d (CategoryTheory.Injective.ι Z)
-- CategoryTheory.InjectiveResolution.ofCocomplex_exactAt_succ
lemma ofCocomplex_exactAt_succ (n : ℕ) :
    (ofCocomplex Z).ExactAt (n + 1) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.EnoughInjectives C] (Z : C) (n : ℕ)
Goal: HomologicalComplex.ExactAt (CategoryTheory.InjectiveResolution.ofCocomplex Z) (n + 1)
-- CategoryTheory.InjectiveResolution.of_def
irreducible_def of : InjectiveResolution Z 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] [CategoryTheory.EnoughInjectives C] (Z : C)
Goal: CategoryTheory.InjectiveResolution.of Z =
  CategoryTheory.InjectiveResolution.mk (CategoryTheory.InjectiveResolution.ofCocomplex Z) ⋯
    (((CategoryTheory.InjectiveResolution.ofCocomplex Z).fromSingle₀Equiv Z).symm ⟨CategoryTheory.Injective.ι Z, ⋯⟩) ⋯
-- CategoryTheory.AbelianOfAdjunction.hasKernels
theorem hasKernels [PreservesFiniteLimits G] : HasKernels C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D C) [G.PreservesZeroMorphisms] (i : F.comp G ≅ CategoryTheory.Functor.id C) [CategoryTheory.Limits.PreservesFiniteLimits G]
Goal: CategoryTheory.Limits.HasKernels C
-- CategoryTheory.AbelianOfAdjunction.hasCokernels
theorem hasCokernels : HasCokernels C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D C) [G.PreservesZeroMorphisms] (i : F.comp G ≅ CategoryTheory.Functor.id C) (adj : G ⊣ F)
Goal: CategoryTheory.Limits.HasCokernels C
-- CategoryTheory.AbelianOfAdjunction.coimageIsoImage_hom
theorem coimageIsoImage_hom {X Y : C} (f : X ⟶ Y) :
    (coimageIsoImage F G i adj f).hom = Abelian.coimageImageComparison f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] [CategoryTheory.Preadditive C] {D : Type u₂} [CategoryTheory.Category.{v, u₂} D] [CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D C) [G.PreservesZeroMorphisms] (i : F.comp G ≅ CategoryTheory.Functor.id C) (adj : G ⊣ F) [CategoryTheory.Limits.HasCokernels C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.PreservesFiniteLimits G] [F.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.AbelianOfAdjunction.coimageIsoImage F G i adj f).hom = CategoryTheory.Abelian.coimageImageComparison f