ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.ProjectiveResolution.iso_inv_naturality
@[reassoc]
lemma ProjectiveResolution.iso_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) :
    P.iso.inv ≫ (projectiveResolutions C).map f =
      (HomotopyCategory.quotient _ _).map φ ≫ Q.iso.inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] {X Y : C} (f : X ⟶ Y) (P : CategoryTheory.ProjectiveResolution X) (Q : CategoryTheory.ProjectiveResolution Y) (φ : P.complex ⟶ Q.complex) (comm : CategoryTheory.CategoryStruct.comp (φ.f 0) (Q.π.f 0) = CategoryTheory.CategoryStruct.comp (P.π.f 0) f)
Goal: CategoryTheory.CategoryStruct.comp P.iso.inv ((CategoryTheory.projectiveResolutions C).map f) =
  CategoryTheory.CategoryStruct.comp ((HomotopyCategory.quotient C (ComplexShape.down ℕ)).map φ) Q.iso.inv
-- CategoryTheory.ProjectiveResolution.iso_hom_naturality
@[reassoc]
lemma ProjectiveResolution.iso_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) :
    (projectiveResolutions C).map f ≫ Q.iso.hom =
      P.iso.hom ≫ (HomotopyCategory.quotient _ _).map φ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.HasProjectiveResolutions C] {X Y : C} (f : X ⟶ Y) (P : CategoryTheory.ProjectiveResolution X) (Q : CategoryTheory.ProjectiveResolution Y) (φ : P.complex ⟶ Q.complex) (comm : CategoryTheory.CategoryStruct.comp (φ.f 0) (Q.π.f 0) = CategoryTheory.CategoryStruct.comp (P.π.f 0) f)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.projectiveResolutions C).map f) Q.iso.hom =
  CategoryTheory.CategoryStruct.comp P.iso.hom ((HomotopyCategory.quotient C (ComplexShape.down ℕ)).map φ)
-- CategoryTheory.exact_d_f
theorem exact_d_f {X Y : C} (f : X ⟶ Y) :
    (ShortComplex.mk (d f) f (by simp)).Exact 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.EnoughProjectives C] {X Y : C} (f : X ⟶ Y)
Goal: (CategoryTheory.ShortComplex.mk (CategoryTheory.Projective.d f) f ⋯).Exact
-- CategoryTheory.ProjectiveResolution.ofComplex_d_1_0
lemma ofComplex_d_1_0 :
    (ofComplex Z).d 1 0 = d (Projective.π Z) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.EnoughProjectives C] (Z : C)
Goal: (CategoryTheory.ProjectiveResolution.ofComplex Z).d 1 0 = CategoryTheory.Projective.d (CategoryTheory.Projective.π Z)
-- CategoryTheory.ProjectiveResolution.ofComplex_exactAt_succ
lemma ofComplex_exactAt_succ (n : ℕ) :
    (ofComplex Z).ExactAt (n + 1) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] [CategoryTheory.EnoughProjectives C] (Z : C) (n : ℕ)
Goal: HomologicalComplex.ExactAt (CategoryTheory.ProjectiveResolution.ofComplex Z) (n + 1)
-- CategoryTheory.ProjectiveResolution.of_def
irreducible_def of : ProjectiveResolution Z 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Abelian C] [CategoryTheory.EnoughProjectives C] (Z : C)
Goal: CategoryTheory.ProjectiveResolution.of Z =
  CategoryTheory.ProjectiveResolution.mk (CategoryTheory.ProjectiveResolution.ofComplex Z) ⋯
    (((CategoryTheory.ProjectiveResolution.ofComplex Z).toSingle₀Equiv Z).symm ⟨CategoryTheory.Projective.π Z, ⋯⟩) ⋯
-- CategoryTheory.Limits.limit.lift_π_app
@[reassoc (attr := simp)]
theorem limit.lift_π_app (H : J ⥤ K ⥤ C) [HasLimit H] (c : Cone H) (j : J) (k : K) :
    (limit.lift H c).app k ≫ (limit.π H j).app k = (c.π.app j).app k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] (H : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasLimit H] (c : CategoryTheory.Limits.Cone H) (j : J) (k : K)
Goal: (CategoryTheory.Limits.limit.lift H c).app k ≫ (CategoryTheory.Limits.limit.π H j).app k = (c.π.app j).app k
-- CategoryTheory.Limits.colimit.ι_desc_app
@[reassoc (attr := simp)]
theorem colimit.ι_desc_app (H : J ⥤ K ⥤ C) [HasColimit H] (c : Cocone H) (j : J) (k : K) :
    (colimit.ι H j).app k ≫ (colimit.desc H c).app k = (c.ι.app j).app k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] (H : J ⥤ K ⥤ C) [CategoryTheory.Limits.HasColimit H] (c : CategoryTheory.Limits.Cocone H) (j : J) (k : K)
Goal: (CategoryTheory.Limits.colimit.ι H j).app k ≫ (CategoryTheory.Limits.colimit.desc H c).app k = (c.ι.app j).app k
-- CategoryTheory.Limits.combineCones_π_app_app
@[simps]
def combineCones (F : J ⥤ K ⥤ C) (c : ∀ k : K, LimitCone (F.flip.obj k)) : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] (F : J ⥤ K ⥤ C) (c : (k : K) → CategoryTheory.Limits.LimitCone (F.flip.obj k)) (j : J) (k : K)
Goal: ((CategoryTheory.Limits.combineCones F c).π.app j).app k = (c k).cone.π.app j
-- CategoryTheory.Limits.combineCones_pt_map
@[simps]
def combineCones (F : J ⥤ K ⥤ C) (c : ∀ k : K, LimitCone (F.flip.obj k)) : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] (F : J ⥤ K ⥤ C) (c : (k : K) → CategoryTheory.Limits.LimitCone (F.flip.obj k)) {k₁ k₂ : K} (f : k₁ ⟶ k₂)
Goal: (CategoryTheory.Limits.combineCones F c).pt.map f =
  (c k₂).isLimit.lift { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ F.flip.map f }
-- CategoryTheory.Limits.combineCones_pt_obj
@[simps]
def combineCones (F : J ⥤ K ⥤ C) (c : ∀ k : K, LimitCone (F.flip.obj k)) : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] (F : J ⥤ K ⥤ C) (c : (k : K) → CategoryTheory.Limits.LimitCone (F.flip.obj k)) (k : K)
Goal: (CategoryTheory.Limits.combineCones F c).pt.obj k = (c k).cone.pt
-- CategoryTheory.Limits.combineCocones_pt_obj
@[simps]
def combineCocones (F : J ⥤ K ⥤ C) (c : ∀ k : K, ColimitCocone (F.flip.obj k)) : Cocone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] (F : J ⥤ K ⥤ C) (c : (k : K) → CategoryTheory.Limits.ColimitCocone (F.flip.obj k)) (k : K)
Goal: (CategoryTheory.Limits.combineCocones F c).pt.obj k = (c k).cocone.pt
-- CategoryTheory.Limits.combineCocones_ι_app_app
@[simps]
def combineCocones (F : J ⥤ K ⥤ C) (c : ∀ k : K, ColimitCocone (F.flip.obj k)) : Cocone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] (F : J ⥤ K ⥤ C) (c : (k : K) → CategoryTheory.Limits.ColimitCocone (F.flip.obj k)) (j : J) (k : K)
Goal: ((CategoryTheory.Limits.combineCocones F c).ι.app j).app k = (c k).cocone.ι.app j
-- CategoryTheory.Limits.combineCocones_pt_map
@[simps]
def combineCocones (F : J ⥤ K ⥤ C) (c : ∀ k : K, ColimitCocone (F.flip.obj k)) : Cocone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] (F : J ⥤ K ⥤ C) (c : (k : K) → CategoryTheory.Limits.ColimitCocone (F.flip.obj k)) {k₁ k₂ : K} (f : k₁ ⟶ k₂)
Goal: (CategoryTheory.Limits.combineCocones F c).pt.map f =
  (c k₁).isColimit.desc { pt := (c k₂).cocone.pt, ι := F.flip.map f ≫ (c k₂).cocone.ι }
-- CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_hom_π
@[reassoc (attr := simp)]
theorem limitObjIsoLimitCompEvaluation_hom_π [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J)
    (k : K) :
    (limitObjIsoLimitCompEvaluation F k).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j =
      (limit.π F j).app k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J) (k : K)
Goal: (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F k).hom ≫
    CategoryTheory.Limits.limit.π (F ⋙ (CategoryTheory.evaluation K C).obj k) j =
  (CategoryTheory.Limits.limit.π F j).app k
-- CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_inv_π_app
@[reassoc (attr := simp)]
theorem limitObjIsoLimitCompEvaluation_inv_π_app [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J)
    (k : K) :
    (limitObjIsoLimitCompEvaluation F k).inv ≫ (limit.π F j).app k =
      limit.π (F ⋙ (evaluation K C).obj k) j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J) (k : K)
Goal: (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F k).inv ≫ (CategoryTheory.Limits.limit.π F j).app k =
  CategoryTheory.Limits.limit.π (F ⋙ (CategoryTheory.evaluation K C).obj k) j
-- CategoryTheory.Limits.limit_map_limitObjIsoLimitCompEvaluation_hom
@[reassoc (attr := simp)]
theorem limit_map_limitObjIsoLimitCompEvaluation_hom [HasLimitsOfShape J C] {i j : K}
    (F : J ⥤ K ⥤ C) (f : i ⟶ j) : (limit F).map f ≫ (limitObjIsoLimitCompEvaluation _ _).hom =
    (limitObjIsoLimitCompEvaluation _ _).hom ≫ limMap (whiskerLeft _ ((evaluation _ _).map f)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C] {i j : K} (F : J ⥤ K ⥤ C) (f : i ⟶ j)
Goal: (CategoryTheory.Limits.limit F).map f ≫ (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F j).hom =
  (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F i).hom ≫
    CategoryTheory.Limits.limMap (CategoryTheory.whiskerLeft F ((CategoryTheory.evaluation K C).map f))
-- CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_inv_limit_map
@[reassoc (attr := simp)]
theorem limitObjIsoLimitCompEvaluation_inv_limit_map [HasLimitsOfShape J C] {i j : K}
    (F : J ⥤ K ⥤ C) (f : i ⟶ j) : (limitObjIsoLimitCompEvaluation _ _).inv ≫ (limit F).map f =
    limMap (whiskerLeft _ ((evaluation _ _).map f)) ≫ (limitObjIsoLimitCompEvaluation _ _).inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C] {i j : K} (F : J ⥤ K ⥤ C) (f : i ⟶ j)
Goal: (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F i).inv ≫ (CategoryTheory.Limits.limit F).map f =
  CategoryTheory.Limits.limMap (CategoryTheory.whiskerLeft F ((CategoryTheory.evaluation K C).map f)) ≫
    (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F j).inv
-- CategoryTheory.Limits.limit_obj_ext
@[ext]
theorem limit_obj_ext {H : J ⥤ K ⥤ C} [HasLimitsOfShape J C] {k : K} {W : C}
    {f g : W ⟶ (limit H).obj k}
    (w : ∀ j, f ≫ (Limits.limit.π H j).app k = g ≫ (Limits.limit.π H j).app k) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {H : J ⥤ K ⥤ C} [CategoryTheory.Limits.HasLimitsOfShape J C] {k : K} {W : C} {f g : W ⟶ (CategoryTheory.Limits.limit H).obj k} (w : ∀ (j : J), f ≫ (CategoryTheory.Limits.limit.π H j).app k = g ≫ (CategoryTheory.Limits.limit.π H j).app k)
Goal: f = g
-- CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_ι_inv
@[reassoc (attr := simp)]
theorem colimitObjIsoColimitCompEvaluation_ι_inv [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J)
    (k : K) :
    colimit.ι (F ⋙ (evaluation K C).obj k) j ≫ (colimitObjIsoColimitCompEvaluation F k).inv =
      (colimit.ι F j).app k 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J) (k : K)
Goal: CategoryTheory.Limits.colimit.ι (F ⋙ (CategoryTheory.evaluation K C).obj k) j ≫
    (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F k).inv =
  (CategoryTheory.Limits.colimit.ι F j).app k
-- CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_ι_app_hom
@[reassoc (attr := simp)]
theorem colimitObjIsoColimitCompEvaluation_ι_app_hom [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C)
    (j : J) (k : K) :
    (colimit.ι F j).app k ≫ (colimitObjIsoColimitCompEvaluation F k).hom =
      colimit.ι (F ⋙ (evaluation K C).obj k) j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J) (k : K)
Goal: (CategoryTheory.Limits.colimit.ι F j).app k ≫ (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F k).hom =
  CategoryTheory.Limits.colimit.ι (F ⋙ (CategoryTheory.evaluation K C).obj k) j
-- CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_inv_colimit_map
@[reassoc (attr := simp)]
theorem colimitObjIsoColimitCompEvaluation_inv_colimit_map [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C)
    {i j : K} (f : i ⟶ j) :
    (colimitObjIsoColimitCompEvaluation _ _).inv ≫ (colimit F).map f =
      colimMap (whiskerLeft _ ((evaluation _ _).map f)) ≫
        (colimitObjIsoColimitCompEvaluation _ _).inv 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) {i j : K} (f : i ⟶ j)
Goal: (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F i).inv ≫ (CategoryTheory.Limits.colimit F).map f =
  CategoryTheory.Limits.colimMap (CategoryTheory.whiskerLeft F ((CategoryTheory.evaluation K C).map f)) ≫
    (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F j).inv
-- CategoryTheory.Limits.colimit_map_colimitObjIsoColimitCompEvaluation_hom
@[reassoc (attr := simp)]
theorem colimit_map_colimitObjIsoColimitCompEvaluation_hom [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C)
    {i j : K} (f : i ⟶ j) :
    (colimit F).map f ≫ (colimitObjIsoColimitCompEvaluation _ _).hom =
      (colimitObjIsoColimitCompEvaluation _ _).hom ≫
        colimMap (whiskerLeft _ ((evaluation _ _).map f)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) {i j : K} (f : i ⟶ j)
Goal: (CategoryTheory.Limits.colimit F).map f ≫ (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F j).hom =
  (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F i).hom ≫
    CategoryTheory.Limits.colimMap (CategoryTheory.whiskerLeft F ((CategoryTheory.evaluation K C).map f))
-- CategoryTheory.Limits.colimit_obj_ext
@[ext]
theorem colimit_obj_ext {H : J ⥤ K ⥤ C} [HasColimitsOfShape J C] {k : K} {W : C}
    {f g : (colimit H).obj k ⟶ W} (w : ∀ j, (colimit.ι H j).app k ≫ f = (colimit.ι H j).app k ≫ g) :
    f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {H : J ⥤ K ⥤ C} [CategoryTheory.Limits.HasColimitsOfShape J C] {k : K} {W : C} {f g : (CategoryTheory.Limits.colimit H).obj k ⟶ W} (w : ∀ (j : J), (CategoryTheory.Limits.colimit.ι H j).app k ≫ f = (CategoryTheory.Limits.colimit.ι H j).app k ≫ g)
Goal: f = g
-- CategoryTheory.Limits.limitIsoFlipCompLim_hom_app
@[simps!]
def limitIsoFlipCompLim [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) : limit F ≅ F.flip ⋙ lim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.limitIsoFlipCompLim F).hom.app X = (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F X).hom
-- CategoryTheory.Limits.limitIsoFlipCompLim_inv_app
@[simps!]
def limitIsoFlipCompLim [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) : limit F ≅ F.flip ⋙ lim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.limitIsoFlipCompLim F).inv.app X = (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F X).inv
-- CategoryTheory.Limits.limitFlipIsoCompLim_hom_app
@[simps!]
def limitFlipIsoCompLim [HasLimitsOfShape J C] (F : K ⥤ J ⥤ C) : limit F.flip ≅ F ⋙ lim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C] (F : K ⥤ J ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.limitFlipIsoCompLim F).hom.app X =
  (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F.flip X).hom ≫
    (CategoryTheory.Limits.HasLimit.isoOfNatIso (CategoryTheory.flipCompEvaluation F X)).hom
-- CategoryTheory.Limits.limitFlipIsoCompLim_inv_app
@[simps!]
def limitFlipIsoCompLim [HasLimitsOfShape J C] (F : K ⥤ J ⥤ C) : limit F.flip ≅ F ⋙ lim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C] (F : K ⥤ J ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.limitFlipIsoCompLim F).inv.app X =
  (CategoryTheory.Limits.HasLimit.isoOfNatIso (CategoryTheory.flipCompEvaluation F X)).inv ≫
    (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F.flip X).inv
-- CategoryTheory.Limits.limitIsoSwapCompLim_hom_app
@[simps!]
def limitIsoSwapCompLim [HasLimitsOfShape J C] (G : J ⥤ K ⥤ C) :
    limit G ≅ curry.obj (Prod.swap K J ⋙ uncurry.obj G) ⋙ lim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C] (G : J ⥤ K ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.limitIsoSwapCompLim G).hom.app X =
  (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation G X).hom ≫
    CategoryTheory.Limits.limMap ((CategoryTheory.flipIsoCurrySwapUncurry G).hom.app X)
-- CategoryTheory.Limits.limitIsoSwapCompLim_inv_app
@[simps!]
def limitIsoSwapCompLim [HasLimitsOfShape J C] (G : J ⥤ K ⥤ C) :
    limit G ≅ curry.obj (Prod.swap K J ⋙ uncurry.obj G) ⋙ lim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C] (G : J ⥤ K ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.limitIsoSwapCompLim G).inv.app X =
  CategoryTheory.Limits.limMap ((CategoryTheory.flipIsoCurrySwapUncurry G).inv.app X) ≫
    (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation G X).inv
-- CategoryTheory.Limits.colimitIsoFlipCompColim_hom_app
@[simps!]
def colimitIsoFlipCompColim [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) : colimit F ≅ F.flip ⋙ colim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.colimitIsoFlipCompColim F).hom.app X =
  (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F X).hom
-- CategoryTheory.Limits.colimitIsoFlipCompColim_inv_app
@[simps!]
def colimitIsoFlipCompColim [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) : colimit F ≅ F.flip ⋙ colim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.colimitIsoFlipCompColim F).inv.app X =
  (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F X).inv
-- CategoryTheory.Limits.colimitFlipIsoCompColim_inv_app
@[simps!]
def colimitFlipIsoCompColim [HasColimitsOfShape J C] (F : K ⥤ J ⥤ C) : colimit F.flip ≅ F ⋙ colim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasColimitsOfShape J C] (F : K ⥤ J ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.colimitFlipIsoCompColim F).inv.app X =
  (CategoryTheory.Limits.HasColimit.isoOfNatIso (CategoryTheory.flipCompEvaluation F X)).inv ≫
    (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F.flip X).inv
-- CategoryTheory.Limits.colimitFlipIsoCompColim_hom_app
@[simps!]
def colimitFlipIsoCompColim [HasColimitsOfShape J C] (F : K ⥤ J ⥤ C) : colimit F.flip ≅ F ⋙ colim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasColimitsOfShape J C] (F : K ⥤ J ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.colimitFlipIsoCompColim F).hom.app X =
  (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F.flip X).hom ≫
    (CategoryTheory.Limits.HasColimit.isoOfNatIso (CategoryTheory.flipCompEvaluation F X)).hom
-- CategoryTheory.Limits.colimitIsoSwapCompColim_hom_app
@[simps!]
def colimitIsoSwapCompColim [HasColimitsOfShape J C] (G : J ⥤ K ⥤ C) :
    colimit G ≅ curry.obj (Prod.swap K J ⋙ uncurry.obj G) ⋙ colim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasColimitsOfShape J C] (G : J ⥤ K ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.colimitIsoSwapCompColim G).hom.app X =
  (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation G X).hom ≫
    CategoryTheory.Limits.colimMap ((CategoryTheory.flipIsoCurrySwapUncurry G).hom.app X)
-- CategoryTheory.Limits.colimitIsoSwapCompColim_inv_app
@[simps!]
def colimitIsoSwapCompColim [HasColimitsOfShape J C] (G : J ⥤ K ⥤ C) :
    colimit G ≅ curry.obj (Prod.swap K J ⋙ uncurry.obj G) ⋙ colim 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasColimitsOfShape J C] (G : J ⥤ K ⥤ C) (X : K)
Goal: (CategoryTheory.Limits.colimitIsoSwapCompColim G).inv.app X =
  CategoryTheory.Limits.colimMap ((CategoryTheory.flipIsoCurrySwapUncurry G).inv.app X) ≫
    (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation G X).inv
-- CategoryTheory.Abelian.app_hom
@[simp]
theorem app_hom {P Q : C} (f : P ⟶ Q) (a : Over P) : (app f a).hom = a.hom ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P Q : C} (f : P ⟶ Q) (a : CategoryTheory.Over P)
Goal: (CategoryTheory.Abelian.app f a).hom = a.hom ≫ f
-- CategoryTheory.Abelian.pseudoEqual_refl
theorem pseudoEqual_refl {P : C} : Reflexive (PseudoEqual P) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : C}
Goal: Reflexive (CategoryTheory.Abelian.PseudoEqual P)
-- CategoryTheory.Abelian.pseudoEqual_symm
theorem pseudoEqual_symm {P : C} : Symmetric (PseudoEqual P) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {P : C}
Goal: Symmetric (CategoryTheory.Abelian.PseudoEqual P)
-- CategoryTheory.Abelian.pseudoEqual_trans
theorem pseudoEqual_trans {P : C} : Transitive (PseudoEqual P) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P : C}
Goal: Transitive (CategoryTheory.Abelian.PseudoEqual P)
-- CategoryTheory.Abelian.Pseudoelement.over_coe_def
theorem over_coe_def {P Q : C} (a : Q ⟶ P) : (a : Pseudoelement P) = ⟦↑a⟧ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] {P Q : C} (a : Q ⟶ P)
Goal: Quot.mk (CategoryTheory.Abelian.PseudoEqual P) (CategoryTheory.Over.mk a) = ⟦CategoryTheory.Over.mk a⟧