ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- HomologicalComplex.opInverse_obj
@[simps]
def opInverse : HomologicalComplex Vᵒᵖ c.symm ⥤ (HomologicalComplex V c)ᵒᵖ 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V] (X : HomologicalComplex Vᵒᵖ c.symm)
Goal: (HomologicalComplex.opInverse V c).obj X = Opposite.op X.unopSymm
-- HomologicalComplex.opEquivalence_functor
@[simps]
def opEquivalence : (HomologicalComplex V c)ᵒᵖ ≌ HomologicalComplex Vᵒᵖ c.symm 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V]
Goal: (HomologicalComplex.opEquivalence V c).functor = HomologicalComplex.opFunctor V c
-- HomologicalComplex.opEquivalence_unitIso
@[simps]
def opEquivalence : (HomologicalComplex V c)ᵒᵖ ≌ HomologicalComplex Vᵒᵖ c.symm 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V]
Goal: (HomologicalComplex.opEquivalence V c).unitIso = HomologicalComplex.opUnitIso V c
-- HomologicalComplex.opEquivalence_inverse
@[simps]
def opEquivalence : (HomologicalComplex V c)ᵒᵖ ≌ HomologicalComplex Vᵒᵖ c.symm 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V]
Goal: (HomologicalComplex.opEquivalence V c).inverse = HomologicalComplex.opInverse V c
-- HomologicalComplex.opEquivalence_counitIso
@[simps]
def opEquivalence : (HomologicalComplex V c)ᵒᵖ ≌ HomologicalComplex Vᵒᵖ c.symm 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V]
Goal: (HomologicalComplex.opEquivalence V c).counitIso = HomologicalComplex.opCounitIso V c
-- HomologicalComplex.unopFunctor_obj
@[simps]
def unopFunctor : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ⥤ HomologicalComplex V c.symm 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V] (X : (HomologicalComplex Vᵒᵖ c)ᵒᵖ)
Goal: (HomologicalComplex.unopFunctor V c).obj X = (Opposite.unop X).unop
-- HomologicalComplex.unopFunctor_map_f
@[simps]
def unopFunctor : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ⥤ HomologicalComplex V c.symm 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V]
Goal: ∀ {X Y : (HomologicalComplex Vᵒᵖ c)ᵒᵖ} (f : X ⟶ Y) (i : ι),
  ((HomologicalComplex.unopFunctor V c).map f).f i = (f.unop.f i).unop
-- HomologicalComplex.unopInverse_obj
@[simps]
def unopInverse : HomologicalComplex V c.symm ⥤ (HomologicalComplex Vᵒᵖ c)ᵒᵖ 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V] (X : HomologicalComplex V c.symm)
Goal: (HomologicalComplex.unopInverse V c).obj X = Opposite.op X.opSymm
-- HomologicalComplex.unopInverse_map
@[simps]
def unopInverse : HomologicalComplex V c.symm ⥤ (HomologicalComplex Vᵒᵖ c)ᵒᵖ 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V]
Goal: ∀ {X Y : HomologicalComplex V c.symm} (f : X ⟶ Y),
  (HomologicalComplex.unopInverse V c).map f = Quiver.Hom.op { f := fun i => (f.f i).op, comm' := ⋯ }
-- HomologicalComplex.unopEquivalence_functor
@[simps]
def unopEquivalence : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≌ HomologicalComplex V c.symm 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V]
Goal: (HomologicalComplex.unopEquivalence V c).functor = HomologicalComplex.unopFunctor V c
-- HomologicalComplex.unopEquivalence_counitIso
@[simps]
def unopEquivalence : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≌ HomologicalComplex V c.symm 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V]
Goal: (HomologicalComplex.unopEquivalence V c).counitIso = HomologicalComplex.unopCounitIso V c
-- HomologicalComplex.unopEquivalence_unitIso
@[simps]
def unopEquivalence : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≌ HomologicalComplex V c.symm 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V]
Goal: (HomologicalComplex.unopEquivalence V c).unitIso = HomologicalComplex.unopUnitIso V c
-- HomologicalComplex.unopEquivalence_inverse
@[simps]
def unopEquivalence : (HomologicalComplex Vᵒᵖ c)ᵒᵖ ≌ HomologicalComplex V c.symm 
Arguments: {ι : Type u_1} (V : Type u_2) [CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι) [CategoryTheory.Limits.HasZeroMorphisms V]
Goal: (HomologicalComplex.unopEquivalence V c).inverse = HomologicalComplex.unopInverse V c
-- CategoryTheory.hasExt_iff
lemma hasExt_iff [HasDerivedCategory.{w'} C] :
    HasExt.{w} C ↔ ∀ (X Y : C) (n : ℤ), Small.{w}
      ((DerivedCategory.singleFunctor C 0).obj X ⟶
        (((DerivedCategory.singleFunctor C 0).obj Y)⟦n⟧)) 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [HasDerivedCategory C]
Goal: CategoryTheory.HasExt C ↔
  ∀ (X Y : C) (n : ℤ),
    Small.{w, w'}
      ((DerivedCategory.singleFunctor C 0).obj X ⟶
        (CategoryTheory.shiftFunctor (DerivedCategory C) n).obj ((DerivedCategory.singleFunctor C 0).obj Y))
-- CategoryTheory.hasExt_of_hasDerivedCategory
lemma hasExt_of_hasDerivedCategory [HasDerivedCategory.{w} C] : HasExt.{w} C 
Arguments: (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [HasDerivedCategory C]
Goal: CategoryTheory.HasExt C
-- CategoryTheory.Abelian.Ext.comp_assoc
lemma comp_assoc {a₁ a₂ a₃ a₁₂ a₂₃ a : ℕ} (α : Ext X Y a₁) (β : Ext Y Z a₂) (γ : Ext Z T a₃)
    (h₁₂ : a₁ + a₂ = a₁₂) (h₂₃ : a₂ + a₃ = a₂₃) (h : a₁ + a₂ + a₃ = a) :
    (α.comp β h₁₂).comp γ (show a₁₂ + a₃ = a by omega) =
      α.comp (β.comp γ h₂₃) (by omega) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y Z T : C} {a₁ a₂ a₃ a₁₂ a₂₃ a : ℕ} (α : CategoryTheory.Abelian.Ext X Y a₁) (β : CategoryTheory.Abelian.Ext Y Z a₂) (γ : CategoryTheory.Abelian.Ext Z T a₃) (h₁₂ : a₁ + a₂ = a₁₂) (h₂₃ : a₂ + a₃ = a₂₃) (h : a₁ + a₂ + a₃ = a)
Goal: (α.comp β h₁₂).comp γ ⋯ = α.comp (β.comp γ h₂₃) ⋯
-- CategoryTheory.Abelian.Ext.comp_hom
@[simp]
lemma comp_hom {a b : ℕ} (α : Ext X Y a) (β : Ext Y Z b) {c : ℕ} (h : a + b = c) :
    (α.comp β h).hom = α.hom.comp β.hom (by omega) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y Z : C} [HasDerivedCategory C] {a b : ℕ} (α : CategoryTheory.Abelian.Ext X Y a) (β : CategoryTheory.Abelian.Ext Y Z b) {c : ℕ} (h : a + b = c)
Goal: (α.comp β h).hom = α.hom.comp β.hom ⋯
-- CategoryTheory.Abelian.Ext.ext
@[ext]
lemma ext {n : ℕ} {α β : Ext X Y n} (h : α.hom = β.hom) : α = β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} [HasDerivedCategory C] {n : ℕ} {α β : CategoryTheory.Abelian.Ext X Y n} (h : α.hom = β.hom)
Goal: α = β
-- CategoryTheory.Abelian.Ext.ext_iff
protected lemma ext_iff {n : ℕ} {α β : Ext X Y n} : α = β ↔ α.hom = β.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} [HasDerivedCategory C] {n : ℕ} {α β : CategoryTheory.Abelian.Ext X Y n}
Goal: α = β ↔ α.hom = β.hom
-- CategoryTheory.Abelian.Ext.mk₀_hom
@[simp]
lemma mk₀_hom [HasDerivedCategory.{w'} C] (f : X ⟶ Y) :
    (mk₀ f).hom = ShiftedHom.mk₀ _ (by simp) ((DerivedCategory.singleFunctor C 0).map f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} [HasDerivedCategory C] (f : X ⟶ Y)
Goal: (CategoryTheory.Abelian.Ext.mk₀ f).hom = CategoryTheory.ShiftedHom.mk₀ ↑0 ⋯ ((DerivedCategory.singleFunctor C 0).map f)
-- CategoryTheory.Abelian.Ext.mk₀_comp_mk₀
@[simp 1100]
lemma mk₀_comp_mk₀ (f : X ⟶ Y) (g : Y ⟶ Z) :
    (mk₀ f).comp (mk₀ g) (zero_add 0) = mk₀ (f ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: (CategoryTheory.Abelian.Ext.mk₀ f).comp (CategoryTheory.Abelian.Ext.mk₀ g) ⋯ =
  CategoryTheory.Abelian.Ext.mk₀ (CategoryTheory.CategoryStruct.comp f g)
-- CategoryTheory.Abelian.Ext.mk₀_comp_mk₀_assoc
@[simp 1100]
lemma mk₀_comp_mk₀_assoc (f : X ⟶ Y) (g : Y ⟶ Z) {n : ℕ} (α : Ext Z T n) :
    (mk₀ f).comp ((mk₀ g).comp α (zero_add n)) (zero_add n) =
      (mk₀ (f ≫ g)).comp α (zero_add n) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y Z T : C} (f : X ⟶ Y) (g : Y ⟶ Z) {n : ℕ} (α : CategoryTheory.Abelian.Ext Z T n)
Goal: (CategoryTheory.Abelian.Ext.mk₀ f).comp ((CategoryTheory.Abelian.Ext.mk₀ g).comp α ⋯) ⋯ =
  (CategoryTheory.Abelian.Ext.mk₀ (CategoryTheory.CategoryStruct.comp f g)).comp α ⋯
-- _private.Mathlib.Algebra.Homology.DerivedCategory.Ext.0.CategoryTheory.Abelian.Ext.add_hom'
private lemma add_hom' (α β : Ext X Y n) : (α + β).hom' = α.hom' + β.hom' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α β : CategoryTheory.Abelian.Ext X Y n)
Goal: (α + β).hom' = α.hom' + β.hom'
-- _private.Mathlib.Algebra.Homology.DerivedCategory.Ext.0.CategoryTheory.Abelian.Ext.neg_hom'
private lemma neg_hom' (α : Ext X Y n) : (-α).hom' = -α.hom' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n)
Goal: (-α).hom' = -α.hom'
-- _private.Mathlib.Algebra.Homology.DerivedCategory.Ext.0.CategoryTheory.Abelian.Ext.zero_hom'
private lemma zero_hom' : (0 : Ext X Y n).hom' = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] (X Y : C) (n : ℕ)
Goal: CategoryTheory.Abelian.Ext.hom' 0 = 0
-- CategoryTheory.Abelian.Ext.add_comp
@[simp]
lemma add_comp (α₁ α₂ : Ext X Y n) {m : ℕ} (β : Ext Y Z m) {p : ℕ} (h : n + m = p) :
    (α₁ + α₂).comp β h = α₁.comp β h + α₂.comp β h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y Z : C} {n : ℕ} (α₁ α₂ : CategoryTheory.Abelian.Ext X Y n) {m : ℕ} (β : CategoryTheory.Abelian.Ext Y Z m) {p : ℕ} (h : n + m = p)
Goal: (α₁ + α₂).comp β h = α₁.comp β h + α₂.comp β h
-- CategoryTheory.Abelian.Ext.comp_add
@[simp]
lemma comp_add (α : Ext X Y n) {m : ℕ} (β₁ β₂ : Ext Y Z m) {p : ℕ} (h : n + m = p) :
    α.comp (β₁ + β₂) h = α.comp β₁ h + α.comp β₂ h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y Z : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n) {m : ℕ} (β₁ β₂ : CategoryTheory.Abelian.Ext Y Z m) {p : ℕ} (h : n + m = p)
Goal: α.comp (β₁ + β₂) h = α.comp β₁ h + α.comp β₂ h
-- CategoryTheory.Abelian.Ext.neg_comp
@[simp]
lemma neg_comp (α : Ext X Y n) {m : ℕ} (β : Ext Y Z m) {p : ℕ} (h : n + m = p) :
    (-α).comp β h = -α.comp β h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y Z : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n) {m : ℕ} (β : CategoryTheory.Abelian.Ext Y Z m) {p : ℕ} (h : n + m = p)
Goal: (-α).comp β h = -α.comp β h
-- CategoryTheory.Abelian.Ext.comp_neg
@[simp]
lemma comp_neg (α : Ext X Y n) {m : ℕ} (β : Ext Y Z m) {p : ℕ} (h : n + m = p) :
    α.comp (-β) h = -α.comp β h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y Z : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n) {m : ℕ} (β : CategoryTheory.Abelian.Ext Y Z m) {p : ℕ} (h : n + m = p)
Goal: α.comp (-β) h = -α.comp β h
-- CategoryTheory.Abelian.Ext.zero_comp
@[simp]
lemma zero_comp {m : ℕ} (β : Ext Y Z m) (p : ℕ) (h : n + m = p) :
    (0 : Ext X Y n).comp β h = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] (X : C) {Y Z : C} (n : ℕ) {m : ℕ} (β : CategoryTheory.Abelian.Ext Y Z m) (p : ℕ) (h : n + m = p)
Goal: CategoryTheory.Abelian.Ext.comp 0 β h = 0
-- CategoryTheory.Abelian.Ext.comp_zero
@[simp]
lemma comp_zero (α : Ext X Y n) (Z : C) (m : ℕ) (p : ℕ) (h : n + m = p) :
    α.comp (0 : Ext Y Z m) h = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n) (Z : C) (m p : ℕ) (h : n + m = p)
Goal: α.comp 0 h = 0
-- CategoryTheory.Abelian.Ext.mk₀_id_comp
@[simp]
lemma mk₀_id_comp (α : Ext X Y n) :
    (mk₀ (𝟙 X)).comp α (zero_add n) = α 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n)
Goal: (CategoryTheory.Abelian.Ext.mk₀ (CategoryTheory.CategoryStruct.id X)).comp α ⋯ = α
-- CategoryTheory.Abelian.Ext.comp_mk₀_id
@[simp]
lemma comp_mk₀_id (α : Ext X Y n) :
    α.comp (mk₀ (𝟙 Y)) (add_zero n) = α 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n)
Goal: α.comp (CategoryTheory.Abelian.Ext.mk₀ (CategoryTheory.CategoryStruct.id Y)) ⋯ = α
-- CategoryTheory.Abelian.Ext.mk₀_zero
@[simp]
lemma mk₀_zero : mk₀ (0 : X ⟶ Y) = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] (X Y : C)
Goal: CategoryTheory.Abelian.Ext.mk₀ 0 = 0
-- CategoryTheory.Abelian.Ext.zero_hom
@[simp]
lemma zero_hom : (0 : Ext X Y n).hom = 0 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] (X Y : C) (n : ℕ) [HasDerivedCategory C]
Goal: CategoryTheory.Abelian.Ext.hom 0 = 0
-- CategoryTheory.Abelian.Ext.biprod_ext
lemma biprod_ext {X₁ X₂ : C} {α β : Ext (X₁ ⊞ X₂) Y n}
    (h₁ : (mk₀ biprod.inl).comp α (zero_add n) = (mk₀ biprod.inl).comp β (zero_add n))
    (h₂ : (mk₀ biprod.inr).comp α (zero_add n) = (mk₀ biprod.inr).comp β (zero_add n)) :
    α = β 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {Y : C} {n : ℕ} {X₁ X₂ : C} {α β : CategoryTheory.Abelian.Ext (X₁ ⊞ X₂) Y n} (h₁ :
  (CategoryTheory.Abelian.Ext.mk₀ CategoryTheory.Limits.biprod.inl).comp α ⋯ =
    (CategoryTheory.Abelian.Ext.mk₀ CategoryTheory.Limits.biprod.inl).comp β ⋯) (h₂ :
  (CategoryTheory.Abelian.Ext.mk₀ CategoryTheory.Limits.biprod.inr).comp α ⋯ =
    (CategoryTheory.Abelian.Ext.mk₀ CategoryTheory.Limits.biprod.inr).comp β ⋯)
Goal: α = β
-- CategoryTheory.Abelian.Ext.add_hom
@[simp]
lemma add_hom (α β : Ext X Y n) : (α + β).hom = α.hom + β.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} {n : ℕ} [HasDerivedCategory C] (α β : CategoryTheory.Abelian.Ext X Y n)
Goal: (α + β).hom = α.hom + β.hom
-- CategoryTheory.Abelian.Ext.neg_hom
lemma neg_hom (α : Ext X Y n) : (-α).hom = -α.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} {n : ℕ} [HasDerivedCategory C] (α : CategoryTheory.Abelian.Ext X Y n)
Goal: (-α).hom = -α.hom
-- CategoryTheory.Abelian.Ext.homAddEquiv_apply
@[simp]
lemma homAddEquiv_apply (α : Ext X Y n) : homAddEquiv α = α.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] {X Y : C} {n : ℕ} [HasDerivedCategory C] (α : CategoryTheory.Abelian.Ext X Y n)
Goal: CategoryTheory.Abelian.Ext.homAddEquiv α = α.hom
-- CategoryTheory.Abelian.Ext.bilinearComp_apply_apply
@[simps!]
noncomputable def bilinearComp (a b c : ℕ) (h : a + b = c) :
    Ext X Y a →+ Ext Y Z b →+ Ext X Z c 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] (X Y Z : C) (a b c : ℕ) (h : a + b = c) (α : CategoryTheory.Abelian.Ext X Y a) (β : CategoryTheory.Abelian.Ext Y Z b)
Goal: ((CategoryTheory.Abelian.Ext.bilinearComp X Y Z a b c h) α) β = α.comp β h
-- CategoryTheory.Abelian.extFunctorObj_map
@[simps]
noncomputable def extFunctorObj (X : C) (n : ℕ) : C ⥤ AddCommGrp.{w} 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] (X : C) (n : ℕ)
Goal: ∀ {X_1 Y : C} (f : X_1 ⟶ Y),
  (CategoryTheory.Abelian.extFunctorObj X n).map f = AddCommGrp.ofHom ((CategoryTheory.Abelian.Ext.mk₀ f).postcomp X ⋯)
-- CategoryTheory.Abelian.extFunctorObj_obj
@[simps]
noncomputable def extFunctorObj (X : C) (n : ℕ) : C ⥤ AddCommGrp.{w} 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] (X : C) (n : ℕ) (Y : C)
Goal: (CategoryTheory.Abelian.extFunctorObj X n).obj Y = AddCommGrp.of (CategoryTheory.Abelian.Ext X Y n)
-- CategoryTheory.Abelian.extFunctor_obj
@[simps]
noncomputable def extFunctor (n : ℕ) : Cᵒᵖ ⥤ C ⥤ AddCommGrp.{w} 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] (n : ℕ) (X : Cᵒᵖ)
Goal: (CategoryTheory.Abelian.extFunctor n).obj X = CategoryTheory.Abelian.extFunctorObj (Opposite.unop X) n
-- CategoryTheory.Abelian.extFunctor_map_app
@[simps]
noncomputable def extFunctor (n : ℕ) : Cᵒᵖ ⥤ C ⥤ AddCommGrp.{w} 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasExt C] (n : ℕ) {X₁ X₂ : Cᵒᵖ} (f : X₁ ⟶ X₂) (Y : C)
Goal: ((CategoryTheory.Abelian.extFunctor n).map f).app Y =
  AddCommGrp.ofHom (AddMonoidHom.mk' (fun α => (CategoryTheory.Abelian.Ext.mk₀ f.unop).comp α ⋯) ⋯)
-- CategoryTheory.ShortComplex.ShortExact.mono_f
structure ShortExact : Prop where
  exact : S.Exact
  [mono_f : Mono S.f]
  [epi_g : Epi S.g]
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] {S : CategoryTheory.ShortComplex C} (self : S.ShortExact)
Goal: CategoryTheory.Mono S.f
-- CategoryTheory.ShortComplex.ShortExact.exact
structure ShortExact : Prop where
  exact : S.Exact
  [mono_f : Mono S.f]
  [epi_g : Epi S.g]
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] {S : CategoryTheory.ShortComplex C} (self : S.ShortExact)
Goal: S.Exact
-- CategoryTheory.ShortComplex.ShortExact.epi_g
structure ShortExact : Prop where
  exact : S.Exact
  [mono_f : Mono S.f]
  [epi_g : Epi S.g]
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] {S : CategoryTheory.ShortComplex C} (self : S.ShortExact)
Goal: CategoryTheory.Epi S.g
-- CategoryTheory.ShortComplex.ShortExact.mk'
lemma ShortExact.mk' (h : S.Exact) (_ : Mono S.f) (_ : Epi S.g) : S.ShortExact 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] {S : CategoryTheory.ShortComplex C} (h : S.Exact)
Goal: CategoryTheory.Mono S.f → CategoryTheory.Epi S.g → S.ShortExact
-- CategoryTheory.ShortComplex.shortExact_of_iso
lemma shortExact_of_iso (e : S₁ ≅ S₂) (h : S₁.ShortExact) : S₂.ShortExact 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] {S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) (h : S₁.ShortExact)
Goal: S₂.ShortExact
-- CategoryTheory.ShortComplex.shortExact_iff_of_iso
lemma shortExact_iff_of_iso (e : S₁ ≅ S₂) : S₁.ShortExact ↔ S₂.ShortExact 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] {S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂)
Goal: S₁.ShortExact ↔ S₂.ShortExact
-- CategoryTheory.ShortComplex.ShortExact.op
lemma ShortExact.op (h : S.ShortExact) : S.op.ShortExact 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] {S : CategoryTheory.ShortComplex C} (h : S.ShortExact)
Goal: S.op.ShortExact
-- CategoryTheory.ShortComplex.ShortExact.unop
lemma ShortExact.unop {S : ShortComplex Cᵒᵖ} (h : S.ShortExact) : S.unop.ShortExact 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] {S : CategoryTheory.ShortComplex Cᵒᵖ} (h : S.ShortExact)
Goal: S.unop.ShortExact
-- CategoryTheory.ShortComplex.shortExact_iff_op
lemma shortExact_iff_op : S.ShortExact ↔ S.op.ShortExact 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] (S : CategoryTheory.ShortComplex C)
Goal: S.ShortExact ↔ S.op.ShortExact
-- CategoryTheory.ShortComplex.shortExact_iff_unop
lemma shortExact_iff_unop (S : ShortComplex Cᵒᵖ) : S.ShortExact ↔ S.unop.ShortExact 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] (S : CategoryTheory.ShortComplex Cᵒᵖ)
Goal: S.ShortExact ↔ S.unop.ShortExact
-- CategoryTheory.ShortComplex.ShortExact.map
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 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroMorphisms D] {S : CategoryTheory.ShortComplex C} (h : S.ShortExact) (F : CategoryTheory.Functor C D) [F.PreservesZeroMorphisms] [F.PreservesLeftHomologyOf S] [F.PreservesRightHomologyOf S] [CategoryTheory.Mono (F.map S.f)] [CategoryTheory.Epi (F.map S.g)]
Goal: (S.map F).ShortExact
-- CategoryTheory.ShortComplex.ShortExact.map_of_exact
lemma ShortExact.map_of_exact (hS : S.ShortExact)
    (F : C ⥤ D) [F.PreservesZeroMorphisms] [PreservesFiniteLimits F]
    [PreservesFiniteColimits F] : (S.map F).ShortExact 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroMorphisms D] {S : CategoryTheory.ShortComplex C} (hS : S.ShortExact) (F : CategoryTheory.Functor C D) [F.PreservesZeroMorphisms] [CategoryTheory.Limits.PreservesFiniteLimits F] [CategoryTheory.Limits.PreservesFiniteColimits F]
Goal: (S.map F).ShortExact
-- CategoryTheory.ShortComplex.ShortExact.isIso_f_iff
lemma ShortExact.isIso_f_iff {S : ShortComplex C} (hS : S.ShortExact) [Balanced C] :
    IsIso S.f ↔ IsZero S.X₃ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] {S : CategoryTheory.ShortComplex C} (hS : S.ShortExact) [CategoryTheory.Balanced C]
Goal: CategoryTheory.IsIso S.f ↔ CategoryTheory.Limits.IsZero S.X₃
-- CategoryTheory.ShortComplex.ShortExact.isIso_g_iff
lemma ShortExact.isIso_g_iff  {S : ShortComplex C} (hS : S.ShortExact) [Balanced C] :
    IsIso S.g ↔ IsZero S.X₁ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] {S : CategoryTheory.ShortComplex C} (hS : S.ShortExact) [CategoryTheory.Balanced C]
Goal: CategoryTheory.IsIso S.g ↔ CategoryTheory.Limits.IsZero S.X₁
-- CategoryTheory.ShortComplex.isIso₂_of_shortExact_of_isIso₁₃
lemma isIso₂_of_shortExact_of_isIso₁₃ [Balanced C] {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (h₁ : S₁.ShortExact) (h₂ : S₂.ShortExact) [IsIso φ.τ₁] [IsIso φ.τ₃] : IsIso φ.τ₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Preadditive C] [CategoryTheory.Balanced C] {S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h₁ : S₁.ShortExact) (h₂ : S₂.ShortExact) [CategoryTheory.IsIso φ.τ₁] [CategoryTheory.IsIso φ.τ₃]
Goal: CategoryTheory.IsIso φ.τ₂