ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.coconeOfConeLeftOp_ι_app
@[simp]
theorem coconeOfConeLeftOp_ι_app (c : Cone F.leftOp) (j) :
    (coconeOfConeLeftOp c).ι.app j = (c.π.app (op j)).op 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cone F.leftOp) (j : J)
Goal: (CategoryTheory.Limits.coconeOfConeLeftOp c).ι.app j = (c.π.app (Opposite.op j)).op
-- CategoryTheory.Limits.coneLeftOpOfCocone_pt
@[simps!]
def coneLeftOpOfCocone (c : Cocone F) : Cone F.leftOp 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.coneLeftOpOfCocone c).pt = Opposite.unop c.pt
-- CategoryTheory.Limits.coneLeftOpOfCocone_π_app
@[simps!]
def coneLeftOpOfCocone (c : Cocone F) : Cone F.leftOp 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cocone F) (X : Jᵒᵖ)
Goal: (CategoryTheory.Limits.coneLeftOpOfCocone c).π.app X = (c.ι.app (Opposite.unop X)).unop
-- CategoryTheory.Limits.coneOfCoconeRightOp_pt
@[simps]
def coneOfCoconeRightOp (c : Cocone F.rightOp) : Cone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ C} (c : CategoryTheory.Limits.Cocone F.rightOp)
Goal: (CategoryTheory.Limits.coneOfCoconeRightOp c).pt = Opposite.unop c.pt
-- CategoryTheory.Limits.coneOfCoconeRightOp_π
@[simps]
def coneOfCoconeRightOp (c : Cocone F.rightOp) : Cone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ C} (c : CategoryTheory.Limits.Cocone F.rightOp)
Goal: (CategoryTheory.Limits.coneOfCoconeRightOp c).π = CategoryTheory.NatTrans.removeRightOp c.ι
-- CategoryTheory.Limits.coconeRightOpOfCone_pt
@[simps]
def coconeRightOpOfCone (c : Cone F) : Cocone F.rightOp 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ C} (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.coconeRightOpOfCone c).pt = Opposite.op c.pt
-- CategoryTheory.Limits.coconeRightOpOfCone_ι
@[simps]
def coconeRightOpOfCone (c : Cone F) : Cocone F.rightOp 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ C} (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.coconeRightOpOfCone c).ι = CategoryTheory.NatTrans.rightOp c.π
-- CategoryTheory.Limits.coconeOfConeRightOp_ι
@[simps]
def coconeOfConeRightOp (c : Cone F.rightOp) : Cocone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ C} (c : CategoryTheory.Limits.Cone F.rightOp)
Goal: (CategoryTheory.Limits.coconeOfConeRightOp c).ι = CategoryTheory.NatTrans.removeRightOp c.π
-- CategoryTheory.Limits.coconeOfConeRightOp_pt
@[simps]
def coconeOfConeRightOp (c : Cone F.rightOp) : Cocone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ C} (c : CategoryTheory.Limits.Cone F.rightOp)
Goal: (CategoryTheory.Limits.coconeOfConeRightOp c).pt = Opposite.unop c.pt
-- CategoryTheory.Limits.coneRightOpOfCocone_π
@[simps]
def coneRightOpOfCocone (c : Cocone F) : Cone F.rightOp 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ C} (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.coneRightOpOfCocone c).π = CategoryTheory.NatTrans.rightOp c.ι
-- CategoryTheory.Limits.coneRightOpOfCocone_pt
@[simps]
def coneRightOpOfCocone (c : Cocone F) : Cone F.rightOp 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ C} (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.coneRightOpOfCocone c).pt = Opposite.op c.pt
-- CategoryTheory.Limits.coneOfCoconeUnop_pt
@[simps]
def coneOfCoconeUnop (c : Cocone F.unop) : Cone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cocone F.unop)
Goal: (CategoryTheory.Limits.coneOfCoconeUnop c).pt = Opposite.op c.pt
-- CategoryTheory.Limits.coneOfCoconeUnop_π
@[simps]
def coneOfCoconeUnop (c : Cocone F.unop) : Cone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cocone F.unop)
Goal: (CategoryTheory.Limits.coneOfCoconeUnop c).π = CategoryTheory.NatTrans.removeUnop c.ι
-- CategoryTheory.Limits.coconeUnopOfCone_ι
@[simps]
def coconeUnopOfCone (c : Cone F) : Cocone F.unop 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.coconeUnopOfCone c).ι = CategoryTheory.NatTrans.unop c.π
-- CategoryTheory.Limits.coconeUnopOfCone_pt
@[simps]
def coconeUnopOfCone (c : Cone F) : Cocone F.unop 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.coconeUnopOfCone c).pt = Opposite.unop c.pt
-- CategoryTheory.Limits.coconeOfConeUnop_ι
@[simps]
def coconeOfConeUnop (c : Cone F.unop) : Cocone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cone F.unop)
Goal: (CategoryTheory.Limits.coconeOfConeUnop c).ι = CategoryTheory.NatTrans.removeUnop c.π
-- CategoryTheory.Limits.coconeOfConeUnop_pt
@[simps]
def coconeOfConeUnop (c : Cone F.unop) : Cocone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cone F.unop)
Goal: (CategoryTheory.Limits.coconeOfConeUnop c).pt = Opposite.op c.pt
-- CategoryTheory.Limits.coneUnopOfCocone_pt
@[simps]
def coneUnopOfCocone (c : Cocone F) : Cone F.unop 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.coneUnopOfCocone c).pt = Opposite.unop c.pt
-- CategoryTheory.Limits.coneUnopOfCocone_π
@[simps]
def coneUnopOfCocone (c : Cocone F) : Cone F.unop 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : Jᵒᵖ ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.coneUnopOfCocone c).π = CategoryTheory.NatTrans.unop c.ι
-- CategoryTheory.Functor.mapConeOp_hom_hom
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapConeOp (t : Cone F) : (mapCone G t).op ≅ mapCocone G.op t.op 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {F : J ⥤ C} (G : C ⥤ D) (t : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Functor.mapConeOp G t).hom.hom = 𝟙 (Opposite.op (G.obj t.pt))
-- CategoryTheory.Functor.mapConeOp_inv_hom
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapConeOp (t : Cone F) : (mapCone G t).op ≅ mapCocone G.op t.op 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {F : J ⥤ C} (G : C ⥤ D) (t : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Functor.mapConeOp G t).inv.hom = 𝟙 (Opposite.op (G.obj t.pt))
-- CategoryTheory.Functor.mapCoconeOp_hom_hom
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapCoconeOp {t : Cocone F} : (mapCocone G t).op ≅ mapCone G.op t.op 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {F : J ⥤ C} (G : C ⥤ D) {t : CategoryTheory.Limits.Cocone F}
Goal: (CategoryTheory.Functor.mapCoconeOp G).hom.hom = 𝟙 (Opposite.op (G.obj t.pt))
-- CategoryTheory.Functor.mapCoconeOp_inv_hom
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapCoconeOp {t : Cocone F} : (mapCocone G t).op ≅ mapCone G.op t.op 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {F : J ⥤ C} (G : C ⥤ D) {t : CategoryTheory.Limits.Cocone F}
Goal: (CategoryTheory.Functor.mapCoconeOp G).inv.hom = 𝟙 (Opposite.op (G.obj t.pt))
-- CategoryTheory.effectiveEpiFamilyStructOfEquivalence_aux
theorem effectiveEpiFamilyStructOfEquivalence_aux {W : D} (ε : (a : α) → e.functor.obj (X a) ⟶ W)
    (h : ∀ {Z : D} (a₁ a₂ : α) (g₁ : Z ⟶ e.functor.obj (X a₁)) (g₂ : Z ⟶ e.functor.obj (X a₂)),
      g₁ ≫ e.functor.map (π a₁) = g₂ ≫ e.functor.map (π a₂) → g₁ ≫ ε a₁ = g₂ ≫ ε a₂)
    {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂) (hg : g₁ ≫ π a₁ = g₂ ≫ π a₂) :
    g₁ ≫ (fun a ↦ e.unit.app (X a) ≫ e.inverse.map (ε a)) a₁ =
    g₂ ≫ (fun a ↦ e.unit.app (X a) ≫ e.inverse.map (ε a)) a₂ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_5, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (e : C ≌ D) {B : C} {α : Type u_3} (X : α → C) (π : (a : α) → X a ⟶ B) {W : D} (ε : (a : α) → e.functor.obj (X a) ⟶ W) (h :
  ∀ {Z : D} (a₁ a₂ : α) (g₁ : Z ⟶ e.functor.obj (X a₁)) (g₂ : Z ⟶ e.functor.obj (X a₂)),
    CategoryTheory.CategoryStruct.comp g₁ (e.functor.map (π a₁)) =
        CategoryTheory.CategoryStruct.comp g₂ (e.functor.map (π a₂)) →
      CategoryTheory.CategoryStruct.comp g₁ (ε a₁) = CategoryTheory.CategoryStruct.comp g₂ (ε a₂)) {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂) (hg : CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂))
Goal: CategoryTheory.CategoryStruct.comp g₁
    ((fun a => CategoryTheory.CategoryStruct.comp (e.unit.app (X a)) (e.inverse.map (ε a))) a₁) =
  CategoryTheory.CategoryStruct.comp g₂
    ((fun a => CategoryTheory.CategoryStruct.comp (e.unit.app (X a)) (e.inverse.map (ε a))) a₂)
-- CategoryTheory.Functor.PreservesEffectiveEpis.preserves
class PreservesEffectiveEpis (F : C ⥤ D) : Prop where
    preserves : ∀ {X Y : C} (f : X ⟶ Y) [EffectiveEpi f], EffectiveEpi (F.map f)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] {F : CategoryTheory.Functor C D} [self : F.PreservesEffectiveEpis] {X Y : C} (f : X ⟶ Y) [CategoryTheory.EffectiveEpi f]
Goal: CategoryTheory.EffectiveEpi (F.map f)
-- CategoryTheory.Functor.PreservesEffectiveEpiFamilies.preserves
class PreservesEffectiveEpiFamilies (F : C ⥤ D) : Prop where
    preserves : ∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)) [EffectiveEpiFamily X π],
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] {F : CategoryTheory.Functor C D} [self : F.PreservesEffectiveEpiFamilies] {α : Type u} {B : C} (X : α → C) (π : (a : α) → X a ⟶ B) [CategoryTheory.EffectiveEpiFamily X π]
Goal: CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)
-- CategoryTheory.Functor.PreservesFiniteEffectiveEpiFamilies.preserves
class PreservesFiniteEffectiveEpiFamilies (F : C ⥤ D) : Prop where
    preserves : ∀ {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B))
    [EffectiveEpiFamily X π],
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] {F : CategoryTheory.Functor C D} [self : F.PreservesFiniteEffectiveEpiFamilies] {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → X a ⟶ B) [CategoryTheory.EffectiveEpiFamily X π]
Goal: CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)
-- CategoryTheory.Functor.ReflectsEffectiveEpis.reflects
class ReflectsEffectiveEpis (F : C ⥤ D) : Prop where
    reflects : ∀ {X Y : C} (f : X ⟶ Y), EffectiveEpi (F.map f) → EffectiveEpi f
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] {F : CategoryTheory.Functor C D} [self : F.ReflectsEffectiveEpis] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.EffectiveEpi (F.map f) → CategoryTheory.EffectiveEpi f
-- CategoryTheory.Functor.effectiveEpi_of_map
lemma effectiveEpi_of_map (F : C ⥤ D) [F.ReflectsEffectiveEpis] {X Y : C} (f : X ⟶ Y)
    (h : EffectiveEpi (F.map f)) : EffectiveEpi f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (F : CategoryTheory.Functor C D) [F.ReflectsEffectiveEpis] {X Y : C} (f : X ⟶ Y) (h : CategoryTheory.EffectiveEpi (F.map f))
Goal: CategoryTheory.EffectiveEpi f
-- CategoryTheory.Functor.ReflectsEffectiveEpiFamilies.reflects
class ReflectsEffectiveEpiFamilies (F : C ⥤ D) : Prop where
    reflects : ∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)),
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) →
    EffectiveEpiFamily X π
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] {F : CategoryTheory.Functor C D} [self : F.ReflectsEffectiveEpiFamilies] {α : Type u} {B : C} (X : α → C) (π : (a : α) → X a ⟶ B)
Goal: (CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)) → CategoryTheory.EffectiveEpiFamily X π
-- CategoryTheory.Functor.effectiveEpiFamily_of_map
lemma effectiveEpiFamily_of_map (F : C ⥤ D) [ReflectsEffectiveEpiFamilies.{u} F]
    {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B))
    (h : EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))) :
    EffectiveEpiFamily X π 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (F : CategoryTheory.Functor C D) [F.ReflectsEffectiveEpiFamilies] {α : Type u} {B : C} (X : α → C) (π : (a : α) → X a ⟶ B) (h : CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a))
Goal: CategoryTheory.EffectiveEpiFamily X π
-- CategoryTheory.Functor.ReflectsFiniteEffectiveEpiFamilies.reflects
class ReflectsFiniteEffectiveEpiFamilies (F : C ⥤ D) : Prop where
    reflects : ∀ {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B)),
    EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a)) →
    EffectiveEpiFamily X π
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] {F : CategoryTheory.Functor C D} [self : F.ReflectsFiniteEffectiveEpiFamilies] {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → X a ⟶ B)
Goal: (CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a)) → CategoryTheory.EffectiveEpiFamily X π
-- CategoryTheory.Functor.finite_effectiveEpiFamily_of_map
lemma finite_effectiveEpiFamily_of_map (F : C ⥤ D) [ReflectsFiniteEffectiveEpiFamilies F]
    {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B))
    (h : EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))) :
    EffectiveEpiFamily X π 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (F : CategoryTheory.Functor C D) [F.ReflectsFiniteEffectiveEpiFamilies] {α : Type} [Finite α] {B : C} (X : α → C) (π : (a : α) → X a ⟶ B) (h : CategoryTheory.EffectiveEpiFamily (fun a => F.obj (X a)) fun a => F.map (π a))
Goal: CategoryTheory.EffectiveEpiFamily X π
-- CategoryTheory.Limits.pullback.diagonal_fst
@[reassoc (attr := simp)]
theorem diagonal_fst : diagonal f ≫ pullback.fst _ _ = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasPullback f f]
Goal: CategoryTheory.Limits.pullback.diagonal f ≫ CategoryTheory.Limits.pullback.fst f f = 𝟙 X
-- CategoryTheory.Limits.pullback.diagonal_snd
@[reassoc (attr := simp)]
theorem diagonal_snd : diagonal f ≫ pullback.snd _ _ = 𝟙 _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasPullback f f]
Goal: CategoryTheory.Limits.pullback.diagonal f ≫ CategoryTheory.Limits.pullback.snd f f = 𝟙 X
-- CategoryTheory.Limits.pullback.diagonal_isKernelPair
theorem diagonal_isKernelPair : IsKernelPair f (pullback.fst f f) (pullback.snd f f) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasPullback f f]
Goal: CategoryTheory.IsKernelPair f (CategoryTheory.Limits.pullback.fst f f) (CategoryTheory.Limits.pullback.snd f f)
-- CategoryTheory.Limits.pullback_diagonal_map_snd_fst_fst
@[reassoc (attr := simp)]
theorem pullback_diagonal_map_snd_fst_fst :
    (pullback.snd (diagonal f)
      (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i
        (by simp [condition]) (by simp [condition]))) ≫
      fst _ _ ≫ i₁ ≫ fst _ _ =
      pullback.fst _ _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C] {U V₁ V₂ : C} (f : X ⟶ Y) (i : U ⟶ Y) (i₁ : V₁ ⟶ CategoryTheory.Limits.pullback f i) (i₂ : V₂ ⟶ CategoryTheory.Limits.pullback f i)
Goal: CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.diagonal f)
      (CategoryTheory.Limits.pullback.map (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.snd f i) f f (i₁ ≫ CategoryTheory.Limits.pullback.fst f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.fst f i) i ⋯ ⋯) ≫
    CategoryTheory.Limits.pullback.fst (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.snd f i) ≫
      i₁ ≫ CategoryTheory.Limits.pullback.fst f i =
  CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.diagonal f)
    (CategoryTheory.Limits.pullback.map (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
      (i₂ ≫ CategoryTheory.Limits.pullback.snd f i) f f (i₁ ≫ CategoryTheory.Limits.pullback.fst f i)
      (i₂ ≫ CategoryTheory.Limits.pullback.fst f i) i ⋯ ⋯)
-- CategoryTheory.Limits.pullback_diagonal_map_snd_snd_fst
@[reassoc (attr := simp)]
theorem pullback_diagonal_map_snd_snd_fst :
    (pullback.snd (diagonal f)
      (map (i₁ ≫ snd f i) (i₂ ≫ snd f i) f f (i₁ ≫ fst f i) (i₂ ≫ fst f i) i
        (by simp [condition]) (by simp [condition]))) ≫
      snd _ _ ≫ i₂ ≫ fst _ _ =
      pullback.fst _ _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C] {U V₁ V₂ : C} (f : X ⟶ Y) (i : U ⟶ Y) (i₁ : V₁ ⟶ CategoryTheory.Limits.pullback f i) (i₂ : V₂ ⟶ CategoryTheory.Limits.pullback f i)
Goal: CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.diagonal f)
      (CategoryTheory.Limits.pullback.map (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.snd f i) f f (i₁ ≫ CategoryTheory.Limits.pullback.fst f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.fst f i) i ⋯ ⋯) ≫
    CategoryTheory.Limits.pullback.snd (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.snd f i) ≫
      i₂ ≫ CategoryTheory.Limits.pullback.fst f i =
  CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.diagonal f)
    (CategoryTheory.Limits.pullback.map (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
      (i₂ ≫ CategoryTheory.Limits.pullback.snd f i) f f (i₁ ≫ CategoryTheory.Limits.pullback.fst f i)
      (i₂ ≫ CategoryTheory.Limits.pullback.fst f i) i ⋯ ⋯)
-- CategoryTheory.Limits.pullbackDiagonalMapIso_hom_fst
@[reassoc (attr := simp)]
theorem pullbackDiagonalMapIso_hom_fst :
    (pullbackDiagonalMapIso f i i₁ i₂).hom ≫ pullback.fst _ _ =
      pullback.snd _ _ ≫ pullback.fst _ _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C] {U V₁ V₂ : C} (f : X ⟶ Y) (i : U ⟶ Y) (i₁ : V₁ ⟶ CategoryTheory.Limits.pullback f i) (i₂ : V₂ ⟶ CategoryTheory.Limits.pullback f i) [CategoryTheory.Limits.HasPullback i₁ i₂]
Goal: (CategoryTheory.Limits.pullbackDiagonalMapIso f i i₁ i₂).hom ≫ CategoryTheory.Limits.pullback.fst i₁ i₂ =
  CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.diagonal f)
      (CategoryTheory.Limits.pullback.map (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.snd f i) f f (i₁ ≫ CategoryTheory.Limits.pullback.fst f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.fst f i) i ⋯ ⋯) ≫
    CategoryTheory.Limits.pullback.fst (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
      (i₂ ≫ CategoryTheory.Limits.pullback.snd f i)
-- CategoryTheory.Limits.pullbackDiagonalMapIso_hom_snd
@[reassoc (attr := simp)]
theorem pullbackDiagonalMapIso_hom_snd :
    (pullbackDiagonalMapIso f i i₁ i₂).hom ≫ pullback.snd _ _ =
      pullback.snd _ _ ≫ pullback.snd _ _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C] {U V₁ V₂ : C} (f : X ⟶ Y) (i : U ⟶ Y) (i₁ : V₁ ⟶ CategoryTheory.Limits.pullback f i) (i₂ : V₂ ⟶ CategoryTheory.Limits.pullback f i) [CategoryTheory.Limits.HasPullback i₁ i₂]
Goal: (CategoryTheory.Limits.pullbackDiagonalMapIso f i i₁ i₂).hom ≫ CategoryTheory.Limits.pullback.snd i₁ i₂ =
  CategoryTheory.Limits.pullback.snd (CategoryTheory.Limits.pullback.diagonal f)
      (CategoryTheory.Limits.pullback.map (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.snd f i) f f (i₁ ≫ CategoryTheory.Limits.pullback.fst f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.fst f i) i ⋯ ⋯) ≫
    CategoryTheory.Limits.pullback.snd (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
      (i₂ ≫ CategoryTheory.Limits.pullback.snd f i)
-- CategoryTheory.Limits.pullbackDiagonalMapIso_inv_fst
@[reassoc (attr := simp)]
theorem pullbackDiagonalMapIso_inv_fst :
    (pullbackDiagonalMapIso f i i₁ i₂).inv ≫ pullback.fst _ _ =
      pullback.fst _ _ ≫ i₁ ≫ pullback.fst _ _ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {X Y : C} [CategoryTheory.Limits.HasPullbacks C] {U V₁ V₂ : C} (f : X ⟶ Y) (i : U ⟶ Y) (i₁ : V₁ ⟶ CategoryTheory.Limits.pullback f i) (i₂ : V₂ ⟶ CategoryTheory.Limits.pullback f i) [CategoryTheory.Limits.HasPullback i₁ i₂]
Goal: (CategoryTheory.Limits.pullbackDiagonalMapIso f i i₁ i₂).inv ≫
    CategoryTheory.Limits.pullback.fst (CategoryTheory.Limits.pullback.diagonal f)
      (CategoryTheory.Limits.pullback.map (i₁ ≫ CategoryTheory.Limits.pullback.snd f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.snd f i) f f (i₁ ≫ CategoryTheory.Limits.pullback.fst f i)
        (i₂ ≫ CategoryTheory.Limits.pullback.fst f i) i ⋯ ⋯) =
  CategoryTheory.Limits.pullback.fst i₁ i₂ ≫ i₁ ≫ CategoryTheory.Limits.pullback.fst f i