ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.WidePullback.lift_base
@[reassoc]
theorem lift_base : lift f fs w ≫ base arrows = f 
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)
Goal: CategoryTheory.Limits.WidePullback.lift f fs w ≫ CategoryTheory.Limits.WidePullback.base arrows = f
-- CategoryTheory.Limits.WidePullback.eq_lift_of_comp_eq
theorem eq_lift_of_comp_eq (g : X ⟶ widePullback _ _ arrows) :
    (∀ j : J, g ≫ π arrows j = fs j) → g ≫ base arrows = f → g = lift f fs w 
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) (g : X ⟶ CategoryTheory.Limits.widePullback B objs arrows)
Goal: (∀ (j : J), g ≫ CategoryTheory.Limits.WidePullback.π arrows j = fs j) →
  g ≫ CategoryTheory.Limits.WidePullback.base arrows = f → g = CategoryTheory.Limits.WidePullback.lift f fs w
-- CategoryTheory.Limits.WidePullback.hom_eq_lift
theorem hom_eq_lift (g : X ⟶ widePullback _ _ arrows) :
    g = lift (g ≫ base arrows) (fun j => g ≫ π arrows j) (by aesop_cat) 
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} (g : X ⟶ CategoryTheory.Limits.widePullback B objs arrows)
Goal: g =
  CategoryTheory.Limits.WidePullback.lift (g ≫ CategoryTheory.Limits.WidePullback.base arrows)
    (fun j => g ≫ CategoryTheory.Limits.WidePullback.π arrows j) ⋯
-- CategoryTheory.Limits.WidePullback.hom_ext
@[ext 1100]
theorem hom_ext (g1 g2 : X ⟶ widePullback _ _ arrows) : (∀ j : J,
    g1 ≫ π arrows j = g2 ≫ π arrows j) → g1 ≫ base arrows = g2 ≫ base arrows → g1 = g2 
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} (g1 g2 : X ⟶ CategoryTheory.Limits.widePullback B objs arrows)
Goal: (∀ (j : J), g1 ≫ CategoryTheory.Limits.WidePullback.π arrows j = g2 ≫ CategoryTheory.Limits.WidePullback.π arrows j) →
  g1 ≫ CategoryTheory.Limits.WidePullback.base arrows = g2 ≫ CategoryTheory.Limits.WidePullback.base arrows → g1 = g2
-- CategoryTheory.Limits.WidePushout.arrow_ι
@[reassoc (attr := simp)]
theorem arrow_ι (j : J) : arrows j ≫ ι arrows j = head arrows 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {B : C} {objs : J → C} (arrows : (j : J) → B ⟶ objs j) [CategoryTheory.Limits.HasWidePushout B objs arrows] (j : J)
Goal: arrows j ≫ CategoryTheory.Limits.WidePushout.ι arrows j = CategoryTheory.Limits.WidePushout.head arrows
-- CategoryTheory.Limits.WidePushout.ι_desc
@[reassoc]
theorem ι_desc (j : J) : ι arrows j ≫ desc f fs w = fs _ 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {B : C} {objs : J → C} (arrows : (j : J) → B ⟶ objs j) [CategoryTheory.Limits.HasWidePushout B objs arrows] {X : C} (f : B ⟶ X) (fs : (j : J) → objs j ⟶ X) (w : ∀ (j : J), arrows j ≫ fs j = f) (j : J)
Goal: CategoryTheory.Limits.WidePushout.ι arrows j ≫ CategoryTheory.Limits.WidePushout.desc f fs w = fs j
-- CategoryTheory.Limits.WidePushout.head_desc
@[reassoc]
theorem head_desc : head arrows ≫ desc f fs w = f 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {B : C} {objs : J → C} (arrows : (j : J) → B ⟶ objs j) [CategoryTheory.Limits.HasWidePushout B objs arrows] {X : C} (f : B ⟶ X) (fs : (j : J) → objs j ⟶ X) (w : ∀ (j : J), arrows j ≫ fs j = f)
Goal: CategoryTheory.Limits.WidePushout.head arrows ≫ CategoryTheory.Limits.WidePushout.desc f fs w = f
-- CategoryTheory.Limits.WidePushout.eq_desc_of_comp_eq
theorem eq_desc_of_comp_eq (g : widePushout _ _ arrows ⟶ X) :
    (∀ j : J, ι arrows j ≫ g = fs j) → head arrows ≫ g = f → g = desc f fs w 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {B : C} {objs : J → C} (arrows : (j : J) → B ⟶ objs j) [CategoryTheory.Limits.HasWidePushout B objs arrows] {X : C} (f : B ⟶ X) (fs : (j : J) → objs j ⟶ X) (w : ∀ (j : J), arrows j ≫ fs j = f) (g : CategoryTheory.Limits.widePushout B objs arrows ⟶ X)
Goal: (∀ (j : J), CategoryTheory.Limits.WidePushout.ι arrows j ≫ g = fs j) →
  CategoryTheory.Limits.WidePushout.head arrows ≫ g = f → g = CategoryTheory.Limits.WidePushout.desc f fs w
-- CategoryTheory.Limits.WidePushout.hom_eq_desc
theorem hom_eq_desc (g : widePushout _ _ arrows ⟶ X) :
    g =
      desc (head arrows ≫ g) (fun j => ι arrows j ≫ g) fun j => by
        rw [← Category.assoc]
        simp 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {B : C} {objs : J → C} (arrows : (j : J) → B ⟶ objs j) [CategoryTheory.Limits.HasWidePushout B objs arrows] {X : C} (g : CategoryTheory.Limits.widePushout B objs arrows ⟶ X)
Goal: g =
  CategoryTheory.Limits.WidePushout.desc (CategoryTheory.Limits.WidePushout.head arrows ≫ g)
    (fun j => CategoryTheory.Limits.WidePushout.ι arrows j ≫ g) ⋯
-- CategoryTheory.Limits.WidePushout.hom_ext
@[ext 1100]
theorem hom_ext (g1 g2 : widePushout _ _ arrows ⟶ X) : (∀ j : J,
    ι arrows j ≫ g1 = ι arrows j ≫ g2) → head arrows ≫ g1 = head arrows ≫ g2 → g1 = g2 
Arguments: {J : Type w} {C : Type u} [CategoryTheory.Category.{v, u} C] {B : C} {objs : J → C} (arrows : (j : J) → B ⟶ objs j) [CategoryTheory.Limits.HasWidePushout B objs arrows] {X : C} (g1 g2 : CategoryTheory.Limits.widePushout B objs arrows ⟶ X)
Goal: (∀ (j : J), CategoryTheory.Limits.WidePushout.ι arrows j ≫ g1 = CategoryTheory.Limits.WidePushout.ι arrows j ≫ g2) →
  CategoryTheory.Limits.WidePushout.head arrows ≫ g1 = CategoryTheory.Limits.WidePushout.head arrows ≫ g2 → g1 = g2
-- CategoryTheory.Limits.widePullbackShapeOp_map
@[simps]
def widePullbackShapeOp : WidePullbackShape J ⥤ (WidePushoutShape J)ᵒᵖ 
Arguments: (J : Type w) {X₁ X₂ : CategoryTheory.Limits.WidePullbackShape J}
Goal: ∀ (a : X₁ ⟶ X₂),
  (CategoryTheory.Limits.widePullbackShapeOp J).map a = CategoryTheory.Limits.widePullbackShapeOpMap J X₁ X₂ a
-- CategoryTheory.Limits.widePullbackShapeOp_obj
@[simps]
def widePullbackShapeOp : WidePullbackShape J ⥤ (WidePushoutShape J)ᵒᵖ 
Arguments: (J : Type w) (X : CategoryTheory.Limits.WidePullbackShape J)
Goal: (CategoryTheory.Limits.widePullbackShapeOp J).obj X = Opposite.op X
-- CategoryTheory.Limits.widePushoutShapeOp_map
@[simps]
def widePushoutShapeOp : WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ 
Arguments: (J : Type w) {X Y : CategoryTheory.Limits.WidePushoutShape J}
Goal: ∀ (a : X ⟶ Y), (CategoryTheory.Limits.widePushoutShapeOp J).map a = CategoryTheory.Limits.widePushoutShapeOpMap J X Y a
-- CategoryTheory.Limits.widePushoutShapeOp_obj
@[simps]
def widePushoutShapeOp : WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ 
Arguments: (J : Type w) (X : CategoryTheory.Limits.WidePushoutShape J)
Goal: (CategoryTheory.Limits.widePushoutShapeOp J).obj X = Opposite.op X
-- CategoryTheory.Limits.widePullbackShapeUnop_obj
@[simps!]
def widePullbackShapeUnop : (WidePullbackShape J)ᵒᵖ ⥤ WidePushoutShape J 
Arguments: (J : Type w) (X : (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ)
Goal: (CategoryTheory.Limits.widePullbackShapeUnop J).obj X = Opposite.unop X
-- CategoryTheory.Limits.widePullbackShapeUnop_map
@[simps!]
def widePullbackShapeUnop : (WidePullbackShape J)ᵒᵖ ⥤ WidePushoutShape J 
Arguments: (J : Type w)
Goal: ∀ {X Y : (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.Limits.widePullbackShapeUnop J).map f =
    (CategoryTheory.Limits.widePullbackShapeOpMap J (Opposite.unop Y) (Opposite.unop X) f.unop).unop
-- CategoryTheory.Limits.widePushoutShapeUnop_map
@[simps!]
def widePushoutShapeUnop : (WidePushoutShape J)ᵒᵖ ⥤ WidePullbackShape J 
Arguments: (J : Type w)
Goal: ∀ {X Y : (CategoryTheory.Limits.WidePushoutShape J)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.Limits.widePushoutShapeUnop J).map f =
    (CategoryTheory.Limits.widePushoutShapeOpMap J (Opposite.unop Y) (Opposite.unop X) f.unop).unop
-- CategoryTheory.Limits.widePushoutShapeUnop_obj
@[simps!]
def widePushoutShapeUnop : (WidePushoutShape J)ᵒᵖ ⥤ WidePullbackShape J 
Arguments: (J : Type w) (X : (CategoryTheory.Limits.WidePushoutShape J)ᵒᵖ)
Goal: (CategoryTheory.Limits.widePushoutShapeUnop J).obj X = Opposite.unop X
-- CategoryTheory.Limits.widePushoutShapeOpEquiv_functor
@[simps]
def widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J 
Arguments: (J : Type w)
Goal: (CategoryTheory.Limits.widePushoutShapeOpEquiv J).functor = CategoryTheory.Limits.widePushoutShapeUnop J
-- CategoryTheory.Limits.widePushoutShapeOpEquiv_unitIso
@[simps]
def widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J 
Arguments: (J : Type w)
Goal: (CategoryTheory.Limits.widePushoutShapeOpEquiv J).unitIso = (CategoryTheory.Limits.widePushoutShapeOpUnop J).symm
-- CategoryTheory.Limits.widePushoutShapeOpEquiv_inverse
@[simps]
def widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J 
Arguments: (J : Type w)
Goal: (CategoryTheory.Limits.widePushoutShapeOpEquiv J).inverse = CategoryTheory.Limits.widePullbackShapeOp J
-- CategoryTheory.Limits.widePushoutShapeOpEquiv_counitIso
@[simps]
def widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J 
Arguments: (J : Type w)
Goal: (CategoryTheory.Limits.widePushoutShapeOpEquiv J).counitIso = CategoryTheory.Limits.widePullbackShapeUnopOp J
-- CategoryTheory.Limits.widePullbackShapeOpEquiv_unitIso
@[simps]
def widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J 
Arguments: (J : Type w)
Goal: (CategoryTheory.Limits.widePullbackShapeOpEquiv J).unitIso = (CategoryTheory.Limits.widePullbackShapeOpUnop J).symm
-- CategoryTheory.Limits.widePullbackShapeOpEquiv_functor
@[simps]
def widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J 
Arguments: (J : Type w)
Goal: (CategoryTheory.Limits.widePullbackShapeOpEquiv J).functor = CategoryTheory.Limits.widePullbackShapeUnop J
-- CategoryTheory.Limits.widePullbackShapeOpEquiv_inverse
@[simps]
def widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J 
Arguments: (J : Type w)
Goal: (CategoryTheory.Limits.widePullbackShapeOpEquiv J).inverse = CategoryTheory.Limits.widePushoutShapeOp J
-- CategoryTheory.Limits.widePullbackShapeOpEquiv_counitIso
@[simps]
def widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J 
Arguments: (J : Type w)
Goal: (CategoryTheory.Limits.widePullbackShapeOpEquiv J).counitIso = CategoryTheory.Limits.widePushoutShapeUnopOp J
-- CategoryTheory.Limits.hasWidePushouts_shrink
theorem hasWidePushouts_shrink [HasWidePushouts.{max w w'} C] : HasWidePushouts.{w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasWidePushouts C]
Goal: CategoryTheory.Limits.HasWidePushouts C
-- CategoryTheory.Limits.hasWidePullbacks_shrink
theorem hasWidePullbacks_shrink [HasWidePullbacks.{max w w'} C] : HasWidePullbacks.{w} C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasWidePullbacks C]
Goal: CategoryTheory.Limits.HasWidePullbacks C
-- CategoryTheory.injective_of_preservesFiniteColimits_preadditiveYonedaObj
theorem injective_of_preservesFiniteColimits_preadditiveYonedaObj (J : C)
    [hP : PreservesFiniteColimits (preadditiveYonedaObj J)] : Injective J 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Abelian C] (J : C) [hP : CategoryTheory.Limits.PreservesFiniteColimits (CategoryTheory.preadditiveYonedaObj J)]
Goal: CategoryTheory.Injective J
-- CategoryTheory.Limits.hasPullback_of_preservesPullback
theorem hasPullback_of_preservesPullback [HasPullback f g] : HasPullback (G.map f) (G.map g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G] [CategoryTheory.Limits.HasPullback f g]
Goal: CategoryTheory.Limits.HasPullback (G.map f) (G.map g)
-- CategoryTheory.Limits.PreservesPullback.iso_hom
@[simp]
theorem PreservesPullback.iso_hom : (PreservesPullback.iso G f g).hom = pullbackComparison G f g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G] [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback (G.map f) (G.map g)]
Goal: (CategoryTheory.Limits.PreservesPullback.iso G f g).hom = CategoryTheory.Limits.pullbackComparison G f g
-- CategoryTheory.Limits.PreservesPullback.iso_hom_fst
@[reassoc]
theorem PreservesPullback.iso_hom_fst :
    (PreservesPullback.iso G f g).hom ≫ pullback.fst _ _ = G.map (pullback.fst f g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G] [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback (G.map f) (G.map g)]
Goal: (CategoryTheory.Limits.PreservesPullback.iso G f g).hom ≫ CategoryTheory.Limits.pullback.fst (G.map f) (G.map g) =
  G.map (CategoryTheory.Limits.pullback.fst f g)
-- CategoryTheory.Limits.PreservesPullback.iso_hom_snd
@[reassoc]
theorem PreservesPullback.iso_hom_snd :
    (PreservesPullback.iso G f g).hom ≫ pullback.snd _ _ = G.map (pullback.snd f g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G] [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback (G.map f) (G.map g)]
Goal: (CategoryTheory.Limits.PreservesPullback.iso G f g).hom ≫ CategoryTheory.Limits.pullback.snd (G.map f) (G.map g) =
  G.map (CategoryTheory.Limits.pullback.snd f g)
-- CategoryTheory.Limits.PreservesPullback.iso_inv_fst
@[reassoc (attr := simp)]
theorem PreservesPullback.iso_inv_fst :
    (PreservesPullback.iso G f g).inv ≫ G.map (pullback.fst f g) = pullback.fst _ _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G] [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback (G.map f) (G.map g)]
Goal: (CategoryTheory.Limits.PreservesPullback.iso G f g).inv ≫ G.map (CategoryTheory.Limits.pullback.fst f g) =
  CategoryTheory.Limits.pullback.fst (G.map f) (G.map g)
-- CategoryTheory.Limits.PreservesPullback.iso_inv_snd
@[reassoc (attr := simp)]
theorem PreservesPullback.iso_inv_snd :
    (PreservesPullback.iso G f g).inv ≫ G.map (pullback.snd f g) = pullback.snd _ _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G] [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback (G.map f) (G.map g)]
Goal: (CategoryTheory.Limits.PreservesPullback.iso G f g).inv ≫ G.map (CategoryTheory.Limits.pullback.snd f g) =
  CategoryTheory.Limits.pullback.snd (G.map f) (G.map g)
-- CategoryTheory.Limits.hasPushout_of_preservesPushout
theorem hasPushout_of_preservesPushout [HasPushout f g] : HasPushout (G.map f) (G.map g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {W X Y : C} (f : W ⟶ X) (g : W ⟶ Y) [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) G] [CategoryTheory.Limits.HasPushout f g]
Goal: CategoryTheory.Limits.HasPushout (G.map f) (G.map g)
-- CategoryTheory.Limits.PreservesPushout.iso_hom
@[simp]
theorem PreservesPushout.iso_hom : (PreservesPushout.iso G f g).hom = pushoutComparison G f g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {W X Y : C} (f : W ⟶ X) (g : W ⟶ Y) [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) G] [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
Goal: (CategoryTheory.Limits.PreservesPushout.iso G f g).hom = CategoryTheory.Limits.pushoutComparison G f g
-- CategoryTheory.Limits.PreservesPushout.inl_iso_hom
@[reassoc]
theorem PreservesPushout.inl_iso_hom :
    pushout.inl _ _ ≫ (PreservesPushout.iso G f g).hom = G.map (pushout.inl _ _) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {W X Y : C} (f : W ⟶ X) (g : W ⟶ Y) [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) G] [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
Goal: CategoryTheory.Limits.pushout.inl (G.map f) (G.map g) ≫ (CategoryTheory.Limits.PreservesPushout.iso G f g).hom =
  G.map (CategoryTheory.Limits.pushout.inl f g)
-- CategoryTheory.Limits.PreservesPushout.inr_iso_hom
@[reassoc]
theorem PreservesPushout.inr_iso_hom :
    pushout.inr _ _ ≫ (PreservesPushout.iso G f g).hom = G.map (pushout.inr _ _) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {W X Y : C} (f : W ⟶ X) (g : W ⟶ Y) [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) G] [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
Goal: CategoryTheory.Limits.pushout.inr (G.map f) (G.map g) ≫ (CategoryTheory.Limits.PreservesPushout.iso G f g).hom =
  G.map (CategoryTheory.Limits.pushout.inr f g)
-- CategoryTheory.Limits.PreservesPushout.inl_iso_inv
@[reassoc (attr := simp)]
theorem PreservesPushout.inl_iso_inv :
    G.map (pushout.inl _ _) ≫ (PreservesPushout.iso G f g).inv = pushout.inl _ _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {W X Y : C} (f : W ⟶ X) (g : W ⟶ Y) [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) G] [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
Goal: G.map (CategoryTheory.Limits.pushout.inl f g) ≫ (CategoryTheory.Limits.PreservesPushout.iso G f g).inv =
  CategoryTheory.Limits.pushout.inl (G.map f) (G.map g)
-- CategoryTheory.Limits.PreservesPushout.inr_iso_inv
@[reassoc (attr := simp)]
theorem PreservesPushout.inr_iso_inv :
    G.map (pushout.inr _ _) ≫ (PreservesPushout.iso G f g).inv = pushout.inr _ _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {W X Y : C} (f : W ⟶ X) (g : W ⟶ Y) [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) G] [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
Goal: G.map (CategoryTheory.Limits.pushout.inr f g) ≫ (CategoryTheory.Limits.PreservesPushout.iso G f g).inv =
  CategoryTheory.Limits.pushout.inr (G.map f) (G.map g)
-- CategoryTheory.Limits.WalkingMulticospan.Hom.id_eq_id
@[simp]
lemma Hom.id_eq_id (X : WalkingMulticospan fst snd) :
    Hom.id X = 𝟙 X 
Arguments: {L R : Type w} {fst snd : R → L} (X : CategoryTheory.Limits.WalkingMulticospan fst snd)
Goal: CategoryTheory.Limits.WalkingMulticospan.Hom.id X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Limits.WalkingMulticospan.Hom.comp_eq_comp
@[simp]
lemma Hom.comp_eq_comp {X Y Z : WalkingMulticospan fst snd}
    (f : X ⟶ Y) (g : Y ⟶ Z) : Hom.comp f g = f ≫ g 
Arguments: {L R : Type w} {fst snd : R → L} {X Y Z : CategoryTheory.Limits.WalkingMulticospan fst snd} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.Limits.WalkingMulticospan.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g
-- CategoryTheory.Limits.WalkingMultispan.Hom.id_eq_id
@[simp]
lemma Hom.id_eq_id (X : WalkingMultispan fst snd) : Hom.id X = 𝟙 X 
Arguments: {L R : Type v} {fst snd : L → R} (X : CategoryTheory.Limits.WalkingMultispan fst snd)
Goal: CategoryTheory.Limits.WalkingMultispan.Hom.id X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Limits.WalkingMultispan.Hom.comp_eq_comp
@[simp]
lemma Hom.comp_eq_comp {X Y Z : WalkingMultispan fst snd}
    (f : X ⟶ Y) (g : Y ⟶ Z) : Hom.comp f g = f ≫ g 
Arguments: {L R : Type v} {fst snd : L → R} {X Y Z : CategoryTheory.Limits.WalkingMultispan fst snd} (f : X ⟶ Y) (g : Y ⟶ Z)
Goal: CategoryTheory.Limits.WalkingMultispan.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g
-- CategoryTheory.Limits.MulticospanIndex.multicospan_map
@[simps]
def multicospan : WalkingMulticospan I.fstTo I.sndTo ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) {x y : CategoryTheory.Limits.WalkingMulticospan I.fstTo I.sndTo} (f : x ⟶ y)
Goal: I.multicospan.map f =
  match x, y, f with
  | x, .(x), CategoryTheory.Limits.WalkingMulticospan.Hom.id .(x) =>
    CategoryTheory.CategoryStruct.id
      ((fun x =>
          match x with
          | CategoryTheory.Limits.WalkingMulticospan.left a => I.left a
          | CategoryTheory.Limits.WalkingMulticospan.right b => I.right b)
        x)
  | .(CategoryTheory.Limits.WalkingMulticospan.left (I.fstTo b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
    CategoryTheory.Limits.WalkingMulticospan.Hom.fst b => I.fst b
  | .(CategoryTheory.Limits.WalkingMulticospan.left (I.sndTo b)), .(CategoryTheory.Limits.WalkingMulticospan.right b),
    CategoryTheory.Limits.WalkingMulticospan.Hom.snd b => I.snd b
-- CategoryTheory.Limits.MulticospanIndex.multicospan_obj
@[simps]
def multicospan : WalkingMulticospan I.fstTo I.sndTo ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) (x : CategoryTheory.Limits.WalkingMulticospan I.fstTo I.sndTo)
Goal: I.multicospan.obj x =
  match x with
  | CategoryTheory.Limits.WalkingMulticospan.left a => I.left a
  | CategoryTheory.Limits.WalkingMulticospan.right b => I.right b
-- CategoryTheory.Limits.MulticospanIndex.fstPiMap_π
@[reassoc (attr := simp)]
theorem fstPiMap_π (b) : I.fstPiMap ≫ Pi.π I.right b = Pi.π I.left _ ≫ I.fst b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (b : I.R)
Goal: CategoryTheory.CategoryStruct.comp I.fstPiMap (CategoryTheory.Limits.Pi.π I.right b) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.left (I.fstTo b)) (I.fst b)
-- CategoryTheory.Limits.MulticospanIndex.sndPiMap_π
@[reassoc (attr := simp)]
theorem sndPiMap_π (b) : I.sndPiMap ≫ Pi.π I.right b = Pi.π I.left _ ≫ I.snd b 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (b : I.R)
Goal: CategoryTheory.CategoryStruct.comp I.sndPiMap (CategoryTheory.Limits.Pi.π I.right b) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.left (I.sndTo b)) (I.snd b)
-- CategoryTheory.Limits.MulticospanIndex.parallelPairDiagram_obj
@[simps!]
protected noncomputable def parallelPairDiagram 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (I : CategoryTheory.Limits.MulticospanIndex C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (x : CategoryTheory.Limits.WalkingParallelPair)
Goal: I.parallelPairDiagram.obj x =
  match x with
  | CategoryTheory.Limits.WalkingParallelPair.zero => ∏ᶜ I.left
  | CategoryTheory.Limits.WalkingParallelPair.one => ∏ᶜ I.right