ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.colimitCoyonedaHomIsoLimit'_π_apply
@[simp]
lemma colimitCoyonedaHomIsoLimit'_π_apply (f : colimit (D.op ⋙ coyoneda) ⟶ F) (i : I) :
    limit.π (D ⋙ F ⋙ uliftFunctor.{u₁}) i ((colimitCoyonedaHomIsoLimit' D F).hom f)
      = ⟨f.app (D.obj i) ((colimit.ι (D.op ⋙ coyoneda) ⟨i⟩).app (D.obj i) (𝟙 (D.obj i)))⟩ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [CategoryTheory.Category.{v₂, v₁} I] (D : CategoryTheory.Functor I C) (F : CategoryTheory.Functor C (Type u₂)) [CategoryTheory.Limits.HasColimit (D.op.comp CategoryTheory.coyoneda)] [CategoryTheory.Limits.HasLimitsOfShape I (Type (max u₁ u₂))] (f : CategoryTheory.Limits.colimit (D.op.comp CategoryTheory.coyoneda) ⟶ F) (i : I)
Goal: CategoryTheory.Limits.limit.π (D.comp (F.comp CategoryTheory.uliftFunctor.{u₁, u₂})) i
    ((CategoryTheory.Limits.colimitCoyonedaHomIsoLimit' D F).hom f) =
  {
    down :=
      f.app (D.obj i)
        ((CategoryTheory.Limits.colimit.ι (D.op.comp CategoryTheory.coyoneda) (Opposite.op i)).app (D.obj i)
          (CategoryTheory.CategoryStruct.id (D.obj i))) }
-- CategoryTheory.Comma.limitAuxiliaryCone_π_app
@[simps!]
def limitAuxiliaryCone (c₁ : Cone (F ⋙ fst L R)) : Cone ((F ⋙ snd L R) ⋙ R) 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) (c₁ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.fst L R))) (X : J)
Goal: (CategoryTheory.Comma.limitAuxiliaryCone F c₁).π.app X =
  CategoryTheory.CategoryStruct.comp (L.map (c₁.π.app X)) (F.obj X).hom
-- CategoryTheory.Comma.limitAuxiliaryCone_pt
@[simps!]
def limitAuxiliaryCone (c₁ : Cone (F ⋙ fst L R)) : Cone ((F ⋙ snd L R) ⋙ R) 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) (c₁ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.fst L R)))
Goal: (CategoryTheory.Comma.limitAuxiliaryCone F c₁).pt = L.obj c₁.pt
-- CategoryTheory.Comma.coneOfPreserves_pt_right
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) [CategoryTheory.Limits.PreservesLimit (F.comp (CategoryTheory.Comma.snd L R)) R] (c₁ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.fst L R))) {c₂ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.snd L R))} (t₂ : CategoryTheory.Limits.IsLimit c₂)
Goal: (CategoryTheory.Comma.coneOfPreserves F c₁ t₂).pt.right = c₂.pt
-- CategoryTheory.Comma.coneOfPreserves_pt_left
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) [CategoryTheory.Limits.PreservesLimit (F.comp (CategoryTheory.Comma.snd L R)) R] (c₁ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.fst L R))) {c₂ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.snd L R))} (t₂ : CategoryTheory.Limits.IsLimit c₂)
Goal: (CategoryTheory.Comma.coneOfPreserves F c₁ t₂).pt.left = c₁.pt
-- CategoryTheory.Comma.coneOfPreserves_pt_hom
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) [CategoryTheory.Limits.PreservesLimit (F.comp (CategoryTheory.Comma.snd L R)) R] (c₁ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.fst L R))) {c₂ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.snd L R))} (t₂ : CategoryTheory.Limits.IsLimit c₂)
Goal: (CategoryTheory.Comma.coneOfPreserves F c₁ t₂).pt.hom =
  (CategoryTheory.Limits.isLimitOfPreserves R t₂).lift (CategoryTheory.Comma.limitAuxiliaryCone F c₁)
-- CategoryTheory.Comma.coneOfPreserves_π_app_left
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) [CategoryTheory.Limits.PreservesLimit (F.comp (CategoryTheory.Comma.snd L R)) R] (c₁ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.fst L R))) {c₂ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.snd L R))} (t₂ : CategoryTheory.Limits.IsLimit c₂) (j : J)
Goal: ((CategoryTheory.Comma.coneOfPreserves F c₁ t₂).π.app j).left = c₁.π.app j
-- CategoryTheory.Comma.coneOfPreserves_π_app_right
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) [CategoryTheory.Limits.PreservesLimit (F.comp (CategoryTheory.Comma.snd L R)) R] (c₁ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.fst L R))) {c₂ : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Comma.snd L R))} (t₂ : CategoryTheory.Limits.IsLimit c₂) (j : J)
Goal: ((CategoryTheory.Comma.coneOfPreserves F c₁ t₂).π.app j).right = c₂.π.app j
-- CategoryTheory.Comma.colimitAuxiliaryCocone_ι_app
@[simps!]
def colimitAuxiliaryCocone (c₂ : Cocone (F ⋙ snd L R)) : Cocone ((F ⋙ fst L R) ⋙ L) 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) (c₂ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R))) (X : J)
Goal: (CategoryTheory.Comma.colimitAuxiliaryCocone F c₂).ι.app X =
  CategoryTheory.CategoryStruct.comp (F.obj X).hom (R.map (c₂.ι.app X))
-- CategoryTheory.Comma.colimitAuxiliaryCocone_pt
@[simps!]
def colimitAuxiliaryCocone (c₂ : Cocone (F ⋙ snd L R)) : Cocone ((F ⋙ fst L R) ⋙ L) 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) (c₂ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R)))
Goal: (CategoryTheory.Comma.colimitAuxiliaryCocone F c₂).pt = R.obj c₂.pt
-- CategoryTheory.Comma.coconeOfPreserves_pt_right
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) [CategoryTheory.Limits.PreservesColimit (F.comp (CategoryTheory.Comma.fst L R)) L] {c₁ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.fst L R))} (t₁ : CategoryTheory.Limits.IsColimit c₁) (c₂ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R)))
Goal: (CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).pt.right = c₂.pt
-- CategoryTheory.Comma.coconeOfPreserves_pt_left
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) [CategoryTheory.Limits.PreservesColimit (F.comp (CategoryTheory.Comma.fst L R)) L] {c₁ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.fst L R))} (t₁ : CategoryTheory.Limits.IsColimit c₁) (c₂ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R)))
Goal: (CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).pt.left = c₁.pt
-- CategoryTheory.Comma.coconeOfPreserves_ι_app_left
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) [CategoryTheory.Limits.PreservesColimit (F.comp (CategoryTheory.Comma.fst L R)) L] {c₁ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.fst L R))} (t₁ : CategoryTheory.Limits.IsColimit c₁) (c₂ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R))) (j : J)
Goal: ((CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).ι.app j).left = c₁.ι.app j
-- CategoryTheory.Comma.coconeOfPreserves_pt_hom
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) [CategoryTheory.Limits.PreservesColimit (F.comp (CategoryTheory.Comma.fst L R)) L] {c₁ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.fst L R))} (t₁ : CategoryTheory.Limits.IsColimit c₁) (c₂ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R)))
Goal: (CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).pt.hom =
  (CategoryTheory.Limits.isColimitOfPreserves L t₁).desc (CategoryTheory.Comma.colimitAuxiliaryCocone F c₂)
-- CategoryTheory.Comma.coconeOfPreserves_ι_app_right
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
Arguments: {J : Type w} [CategoryTheory.Category.{w', w} J] {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [CategoryTheory.Category.{v₂, u₂} B] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} (F : CategoryTheory.Functor J (CategoryTheory.Comma L R)) [CategoryTheory.Limits.PreservesColimit (F.comp (CategoryTheory.Comma.fst L R)) L] {c₁ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.fst L R))} (t₁ : CategoryTheory.Limits.IsColimit c₁) (c₂ : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.Comma.snd L R))) (j : J)
Goal: ((CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).ι.app j).right = c₂.ι.app j
-- CategoryTheory.StructuredArrow.mono_iff_mono_right
theorem mono_iff_mono_right [HasPullbacks A] [PreservesLimitsOfShape WalkingCospan G]
    {Y Z : StructuredArrow X G} (f : Y ⟶ Z) : Mono f ↔ Mono f.right 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {X : T} {G : CategoryTheory.Functor A T} [CategoryTheory.Limits.HasPullbacks A] [CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingCospan G] {Y Z : CategoryTheory.StructuredArrow X G} (f : Y ⟶ Z)
Goal: CategoryTheory.Mono f ↔ CategoryTheory.Mono f.right
-- CategoryTheory.CostructuredArrow.epi_iff_epi_left
theorem epi_iff_epi_left [HasPushouts A] [PreservesColimitsOfShape WalkingSpan G]
    {Y Z : CostructuredArrow G X} (f : Y ⟶ Z) : Epi f ↔ Epi f.left 
Arguments: {A : Type u₁} [CategoryTheory.Category.{v₁, u₁} A] {T : Type u₃} [CategoryTheory.Category.{v₃, u₃} T] {G : CategoryTheory.Functor A T} {X : T} [CategoryTheory.Limits.HasPushouts A] [CategoryTheory.Limits.PreservesColimitsOfShape CategoryTheory.Limits.WalkingSpan G] {Y Z : CategoryTheory.CostructuredArrow G X} (f : Y ⟶ Z)
Goal: CategoryTheory.Epi f ↔ CategoryTheory.Epi f.left
-- ChainComplex.linearYonedaObj_d
@[simps! X d]
def ChainComplex.linearYonedaObj {α : Type*} [AddRightCancelSemigroup α] [One α]
    (X : ChainComplex C α) (A : Type*) [Ring A] [Linear A C] (Y : C) :
    CochainComplex (ModuleCat A) α 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_5, u_2} C] [CategoryTheory.Abelian C] {α : Type u_3} [AddRightCancelSemigroup α] [One α] (X : ChainComplex C α) (A : Type u_4) [Ring A] [CategoryTheory.Linear A C] (Y : C) (i j : α)
Goal: (X.linearYonedaObj A Y).d i j = ModuleCat.ofHom (CategoryTheory.Linear.leftComp A Y (X.d j i))
-- ChainComplex.linearYonedaObj_X
@[simps! X d]
def ChainComplex.linearYonedaObj {α : Type*} [AddRightCancelSemigroup α] [One α]
    (X : ChainComplex C α) (A : Type*) [Ring A] [Linear A C] (Y : C) :
    CochainComplex (ModuleCat A) α 
Arguments: {C : Type u_2} [CategoryTheory.Category.{u_5, u_2} C] [CategoryTheory.Abelian C] {α : Type u_3} [AddRightCancelSemigroup α] [One α] (X : ChainComplex C α) (A : Type u_4) [Ring A] [CategoryTheory.Linear A C] (Y : C) (i : α)
Goal: (X.linearYonedaObj A Y).X i = ModuleCat.of A (X.X i ⟶ Y)
-- isZero_Ext_succ_of_projective
lemma isZero_Ext_succ_of_projective (X Y : C) [Projective X] (n : ℕ) :
    IsZero (((Ext R C (n + 1)).obj (Opposite.op X)).obj Y) 
Arguments: {R : Type u_1} [Ring R] {C : Type u_2} [CategoryTheory.Category.{u_3, u_2} C] [CategoryTheory.Abelian C] [CategoryTheory.Linear R C] [CategoryTheory.EnoughProjectives C] (X Y : C) [CategoryTheory.Projective X] (n : ℕ)
Goal: CategoryTheory.Limits.IsZero (((Ext R C (n + 1)).obj (Opposite.op X)).obj Y)
-- CategoryTheory.Limits.WidePullbackShape.hom_id
@[simp]
theorem hom_id (X : WidePullbackShape J) : Hom.id X = 𝟙 X 
Arguments: {J : Type w} (X : CategoryTheory.Limits.WidePullbackShape J)
Goal: CategoryTheory.Limits.WidePullbackShape.Hom.id X = 𝟙 X
-- CategoryTheory.Limits.WidePullbackShape.wideCospan_obj
@[simps]
def wideCospan (B : C) (objs : J → C) (arrows : ∀ j : J, objs j ⟶ B) : WidePullbackShape J ⥤ C 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) (objs : J → C) (arrows : (j : J) → objs j ⟶ B) (j : CategoryTheory.Limits.WidePullbackShape J)
Goal: (CategoryTheory.Limits.WidePullbackShape.wideCospan B objs arrows).obj j = Option.casesOn j B objs
-- CategoryTheory.Limits.WidePullbackShape.wideCospan_map
@[simps]
def wideCospan (B : C) (objs : J → C) (arrows : ∀ j : J, objs j ⟶ B) : WidePullbackShape J ⥤ C 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) (objs : J → C) (arrows : (j : J) → objs j ⟶ B)
Goal: ∀ {X Y : CategoryTheory.Limits.WidePullbackShape J} (f : X ⟶ Y),
  (CategoryTheory.Limits.WidePullbackShape.wideCospan B objs arrows).map f =
    CategoryTheory.Limits.WidePullbackShape.Hom.casesOn (motive := fun a a_1 t =>
      X = a → Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y)) f
      (fun X_1 h =>
        Eq.ndrec (motive := fun X_2 =>
          Y = X_2 →
            HEq f (CategoryTheory.Limits.WidePullbackShape.Hom.id X_2) →
              ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
          (fun h =>
            Eq.ndrec (motive := fun {Y} =>
              (f : X ⟶ Y) →
                HEq f (CategoryTheory.Limits.WidePullbackShape.Hom.id X) →
                  ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
              (fun f h => 𝟙 ((fun j => Option.casesOn j B objs) X)) ⋯ f)
          h)
      (fun j h =>
        Eq.ndrec (motive := fun {X} =>
          (f : X ⟶ Y) →
            Y = none →
              HEq f (CategoryTheory.Limits.WidePullbackShape.Hom.term j) →
                ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
          (fun f h =>
            Eq.ndrec (motive := fun {Y} =>
              (f : some j ⟶ Y) →
                HEq f (CategoryTheory.Limits.WidePullbackShape.Hom.term j) →
                  ((fun j => Option.casesOn j B objs) (some j) ⟶ (fun j => Option.casesOn j B objs) Y))
              (fun f h => arrows j) ⋯ f)
          ⋯ f)
      ⋯ ⋯ ⋯
-- CategoryTheory.Limits.WidePullbackShape.mkCone_π_app
@[simps]
def mkCone {F : WidePullbackShape J ⥤ C} {X : C} (f : X ⟶ F.obj none) (π : ∀ j, X ⟶ F.obj (some j))
    (w : ∀ j, π j ≫ F.map (Hom.term j) = f) : Cone F 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WidePullbackShape J ⥤ C} {X : C} (f : X ⟶ F.obj none) (π : (j : J) → X ⟶ F.obj (some j)) (w : ∀ (j : J), π j ≫ F.map (CategoryTheory.Limits.WidePullbackShape.Hom.term j) = f) (j : CategoryTheory.Limits.WidePullbackShape J)
Goal: (CategoryTheory.Limits.WidePullbackShape.mkCone f π w).π.app j =
  match j with
  | none => f
  | some j => π j
-- CategoryTheory.Limits.WidePullbackShape.mkCone_pt
@[simps]
def mkCone {F : WidePullbackShape J ⥤ C} {X : C} (f : X ⟶ F.obj none) (π : ∀ j, X ⟶ F.obj (some j))
    (w : ∀ j, π j ≫ F.map (Hom.term j) = f) : Cone F 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WidePullbackShape J ⥤ C} {X : C} (f : X ⟶ F.obj none) (π : (j : J) → X ⟶ F.obj (some j)) (w : ∀ (j : J), π j ≫ F.map (CategoryTheory.Limits.WidePullbackShape.Hom.term j) = f)
Goal: (CategoryTheory.Limits.WidePullbackShape.mkCone f π w).pt = X
-- CategoryTheory.Limits.WidePushoutShape.hom_id
@[simp]
theorem hom_id (X : WidePushoutShape J) : Hom.id X = 𝟙 X 
Arguments: {J : Type w} (X : CategoryTheory.Limits.WidePushoutShape J)
Goal: CategoryTheory.Limits.WidePushoutShape.Hom.id X = 𝟙 X
-- CategoryTheory.Limits.WidePushoutShape.wideSpan_map
@[simps]
def wideSpan (B : C) (objs : J → C) (arrows : ∀ j : J, B ⟶ objs j) : WidePushoutShape J ⥤ C 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) (objs : J → C) (arrows : (j : J) → B ⟶ objs j)
Goal: ∀ {X Y : CategoryTheory.Limits.WidePushoutShape J} (f : X ⟶ Y),
  (CategoryTheory.Limits.WidePushoutShape.wideSpan B objs arrows).map f =
    CategoryTheory.Limits.WidePushoutShape.Hom.casesOn (motive := fun a a_1 t =>
      X = a → Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y)) f
      (fun X_1 h =>
        Eq.ndrec (motive := fun X_2 =>
          Y = X_2 →
            HEq f (CategoryTheory.Limits.WidePushoutShape.Hom.id X_2) →
              ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
          (fun h =>
            Eq.ndrec (motive := fun {Y} =>
              (f : X ⟶ Y) →
                HEq f (CategoryTheory.Limits.WidePushoutShape.Hom.id X) →
                  ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
              (fun f h => 𝟙 ((fun j => Option.casesOn j B objs) X)) ⋯ f)
          h)
      (fun j h =>
        Eq.ndrec (motive := fun {X} =>
          (f : X ⟶ Y) →
            Y = some j →
              HEq f (CategoryTheory.Limits.WidePushoutShape.Hom.init j) →
                ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
          (fun f h =>
            Eq.ndrec (motive := fun {Y} =>
              (f : none ⟶ Y) →
                HEq f (CategoryTheory.Limits.WidePushoutShape.Hom.init j) →
                  ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
              (fun f h => arrows j) ⋯ f)
          ⋯ f)
      ⋯ ⋯ ⋯
-- CategoryTheory.Limits.WidePushoutShape.wideSpan_obj
@[simps]
def wideSpan (B : C) (objs : J → C) (arrows : ∀ j : J, B ⟶ objs j) : WidePushoutShape J ⥤ C 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) (objs : J → C) (arrows : (j : J) → B ⟶ objs j) (j : CategoryTheory.Limits.WidePushoutShape J)
Goal: (CategoryTheory.Limits.WidePushoutShape.wideSpan B objs arrows).obj j = Option.casesOn j B objs
-- CategoryTheory.Limits.WidePushoutShape.mkCocone_ι_app
@[simps]
def mkCocone {F : WidePushoutShape J ⥤ C} {X : C} (f : F.obj none ⟶ X) (ι : ∀ j, F.obj (some j) ⟶ X)
    (w : ∀ j, F.map (Hom.init j) ≫ ι j = f) : Cocone F 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WidePushoutShape J ⥤ C} {X : C} (f : F.obj none ⟶ X) (ι : (j : J) → F.obj (some j) ⟶ X) (w : ∀ (j : J), F.map (CategoryTheory.Limits.WidePushoutShape.Hom.init j) ≫ ι j = f) (j : CategoryTheory.Limits.WidePushoutShape J)
Goal: (CategoryTheory.Limits.WidePushoutShape.mkCocone f ι w).ι.app j =
  match j with
  | none => f
  | some j => ι j
-- CategoryTheory.Limits.WidePushoutShape.mkCocone_pt
@[simps]
def mkCocone {F : WidePushoutShape J ⥤ C} {X : C} (f : F.obj none ⟶ X) (ι : ∀ j, F.obj (some j) ⟶ X)
    (w : ∀ j, F.map (Hom.init j) ≫ ι j = f) : Cocone F 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Limits.WidePushoutShape J ⥤ C} {X : C} (f : F.obj none ⟶ X) (ι : (j : J) → F.obj (some j) ⟶ X) (w : ∀ (j : J), F.map (CategoryTheory.Limits.WidePushoutShape.Hom.init j) ≫ ι j = f)
Goal: (CategoryTheory.Limits.WidePushoutShape.mkCocone f ι w).pt = X
-- CategoryTheory.Limits.WidePullback.π_arrow
@[reassoc (attr := simp)]
theorem π_arrow (j : J) : π arrows j ≫ arrows _ = base arrows 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {B : C} {objs : J → C} (arrows : (j : J) → objs j ⟶ B) [CategoryTheory.Limits.HasWidePullback B objs arrows] (j : J)
Goal: CategoryTheory.Limits.WidePullback.π arrows j ≫ arrows j = CategoryTheory.Limits.WidePullback.base arrows
-- CategoryTheory.Limits.WidePullback.lift_π
@[reassoc]
theorem lift_π (j : J) : lift f fs w ≫ π arrows j = fs _ 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {B : C} {objs : J → C} (arrows : (j : J) → objs j ⟶ B) [CategoryTheory.Limits.HasWidePullback B objs arrows] {X : C} (f : X ⟶ B) (fs : (j : J) → X ⟶ objs j) (w : ∀ (j : J), fs j ≫ arrows j = f) (j : J)
Goal: CategoryTheory.Limits.WidePullback.lift f fs w ≫ CategoryTheory.Limits.WidePullback.π arrows j = fs j