ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.opProductIsoCoproduct'_comp_self
theorem opProductIsoCoproduct'_comp_self {f f' : Fan Z} {c : Cofan (op <| Z ·)}
    (hf : IsLimit f) (hf' : IsLimit f') (hc : IsColimit c) :
    (opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv =
    (hf.conePointUniqueUpToIso hf').op.inv 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {α : Type u_1} {Z : α → C} {f f' : CategoryTheory.Limits.Fan Z} {c : CategoryTheory.Limits.Cofan fun x => Opposite.op (Z x)} (hf : CategoryTheory.Limits.IsLimit f) (hf' : CategoryTheory.Limits.IsLimit f') (hc : CategoryTheory.Limits.IsColimit c)
Goal: (CategoryTheory.Limits.opProductIsoCoproduct' hf hc).hom ≫ (CategoryTheory.Limits.opProductIsoCoproduct' hf' hc).inv =
  (hf.conePointUniqueUpToIso hf').op.inv
-- CategoryTheory.Limits.π_comp_opProductIsoCoproduct_hom
theorem π_comp_opProductIsoCoproduct_hom [HasProduct Z] (b : α) :
    (Pi.π Z b).op ≫ (opProductIsoCoproduct Z).hom = Sigma.ι (op <| Z ·) b 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {α : Type u_1} (Z : α → C) [CategoryTheory.Limits.HasProduct Z] (b : α)
Goal: (CategoryTheory.Limits.Pi.π Z b).op ≫ (CategoryTheory.Limits.opProductIsoCoproduct Z).hom =
  CategoryTheory.Limits.Sigma.ι (fun x => Opposite.op (Z x)) b
-- CategoryTheory.Limits.opProductIsoCoproduct'_inv_comp_lift
theorem opProductIsoCoproduct'_inv_comp_lift {f : Fan Z} {c : Cofan (op <| Z ·)}
    (hf : IsLimit f) (hc : IsColimit c) (f' : Fan Z) :
    (opProductIsoCoproduct' hf hc).inv ≫ (hf.lift f').op = hc.desc f'.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {α : Type u_1} {Z : α → C} {f : CategoryTheory.Limits.Fan Z} {c : CategoryTheory.Limits.Cofan fun x => Opposite.op (Z x)} (hf : CategoryTheory.Limits.IsLimit f) (hc : CategoryTheory.Limits.IsColimit c) (f' : CategoryTheory.Limits.Fan Z)
Goal: (CategoryTheory.Limits.opProductIsoCoproduct' hf hc).inv ≫ (hf.lift f').op = hc.desc f'.op
-- CategoryTheory.Limits.opProductIsoCoproduct_inv_comp_lift
theorem opProductIsoCoproduct_inv_comp_lift [HasProduct Z] {X : C} (π : (a : α) → X ⟶ Z a) :
    (opProductIsoCoproduct Z).inv ≫ (Pi.lift π).op  = Sigma.desc (fun a ↦ (π a).op) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {α : Type u_1} {Z : α → C} [CategoryTheory.Limits.HasProduct Z] {X : C} (π : (a : α) → X ⟶ Z a)
Goal: (CategoryTheory.Limits.opProductIsoCoproduct Z).inv ≫ (CategoryTheory.Limits.Pi.lift π).op =
  CategoryTheory.Limits.Sigma.desc fun a => (π a).op
-- CategoryTheory.Limits.spanOp_inv_app
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpan),
  (CategoryTheory.Limits.spanOp f g).inv.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op Z))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op X))
            (CategoryTheory.Iso.refl (Opposite.op Y)) val)
        X_1).inv
-- CategoryTheory.Limits.spanOp_hom_app
@[simps!]
def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpan),
  (CategoryTheory.Limits.spanOp f g).hom.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op Z))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op X))
            (CategoryTheory.Iso.refl (Opposite.op Y)) val)
        X_1).hom
-- CategoryTheory.Limits.opCospan_hom_app
@[simps!]
def opCospan {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (cospan f g).op ≅ walkingCospanOpEquiv.functor ⋙ span f.op g.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospanᵒᵖ),
  (CategoryTheory.Limits.opCospan f g).hom.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op Z))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op X))
            (CategoryTheory.Iso.refl (Opposite.op Y)) val)
        (Opposite.unop X_1)).inv
-- CategoryTheory.Limits.opCospan_inv_app
@[simps!]
def opCospan {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (cospan f g).op ≅ walkingCospanOpEquiv.functor ⋙ span f.op g.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospanᵒᵖ),
  (CategoryTheory.Limits.opCospan f g).inv.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op Z))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op X))
            (CategoryTheory.Iso.refl (Opposite.op Y)) val)
        (Opposite.unop X_1)).hom
-- CategoryTheory.Limits.cospanOp_hom_app
@[simps!]
def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospan),
  (CategoryTheory.Limits.cospanOp f g).hom.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op X))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op Y))
            (CategoryTheory.Iso.refl (Opposite.op Z)) val)
        X_1).hom
-- CategoryTheory.Limits.cospanOp_inv_app
@[simps!]
def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospan),
  (CategoryTheory.Limits.cospanOp f g).inv.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op X))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op Y))
            (CategoryTheory.Iso.refl (Opposite.op Z)) val)
        X_1).inv
-- CategoryTheory.Limits.opSpan_hom_app
@[simps!]
def opSpan {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    (span f g).op ≅ walkingSpanOpEquiv.functor ⋙ cospan f.op g.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpanᵒᵖ),
  (CategoryTheory.Limits.opSpan f g).hom.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op X))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op Y))
            (CategoryTheory.Iso.refl (Opposite.op Z)) val)
        (Opposite.unop X_1)).inv
-- CategoryTheory.Limits.opSpan_inv_app
@[simps!]
def opSpan {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    (span f g).op ≅ walkingSpanOpEquiv.functor ⋙ cospan f.op g.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpanᵒᵖ),
  (CategoryTheory.Limits.opSpan f g).inv.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op X))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op Y))
            (CategoryTheory.Iso.refl (Opposite.op Z)) val)
        (Opposite.unop X_1)).hom
-- CategoryTheory.Limits.PushoutCocone.unop_π_app
@[simps!]
def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    PullbackCone f.unop g.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : CategoryTheory.Limits.PushoutCocone f g)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospan),
  c.unop.π.app X_1 =
    (c.ι.app X_1).unop ≫
      (Option.rec (CategoryTheory.Iso.refl X)
            (fun val =>
              CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl Y) (CategoryTheory.Iso.refl Z) val)
            X_1).inv.unop
-- CategoryTheory.Limits.PushoutCocone.unop_pt
@[simps!]
def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    PullbackCone f.unop g.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : CategoryTheory.Limits.PushoutCocone f g)
Goal: c.unop.pt = Opposite.unop c.pt
-- CategoryTheory.Limits.PushoutCocone.unop_fst
theorem unop_fst {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    c.unop.fst = c.inl.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : CategoryTheory.Limits.PushoutCocone f g)
Goal: c.unop.fst = c.inl.unop
-- CategoryTheory.Limits.PushoutCocone.unop_snd
theorem unop_snd {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    c.unop.snd = c.inr.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : CategoryTheory.Limits.PushoutCocone f g)
Goal: c.unop.snd = c.inr.unop
-- CategoryTheory.Limits.PushoutCocone.op_π_app
@[simps!]
def op {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : PullbackCone f.op g.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : CategoryTheory.Limits.PushoutCocone f g)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospan),
  c.op.π.app X_1 =
    (c.ι.app X_1).op ≫
      (Option.rec (CategoryTheory.Iso.refl (Opposite.op X))
          (fun val =>
            CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op Y))
              (CategoryTheory.Iso.refl (Opposite.op Z)) val)
          X_1).inv
-- CategoryTheory.Limits.PushoutCocone.op_pt
@[simps!]
def op {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : PullbackCone f.op g.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : CategoryTheory.Limits.PushoutCocone f g)
Goal: c.op.pt = Opposite.op c.pt
-- CategoryTheory.Limits.PushoutCocone.op_fst
theorem op_fst {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    c.op.fst = c.inl.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : CategoryTheory.Limits.PushoutCocone f g)
Goal: c.op.fst = c.inl.op
-- CategoryTheory.Limits.PushoutCocone.op_snd
theorem op_snd {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    c.op.snd = c.inr.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : CategoryTheory.Limits.PushoutCocone f g)
Goal: c.op.snd = c.inr.op
-- CategoryTheory.Limits.PullbackCone.unop_ι_app
@[simps!]
def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    PushoutCocone f.unop g.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : CategoryTheory.Limits.PullbackCone f g)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpan),
  c.unop.ι.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl Z)
            (fun val =>
              CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl X) (CategoryTheory.Iso.refl Y) val)
            X_1).hom.unop ≫
      (c.π.app X_1).unop
-- CategoryTheory.Limits.PullbackCone.unop_pt
@[simps!]
def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    PushoutCocone f.unop g.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : CategoryTheory.Limits.PullbackCone f g)
Goal: c.unop.pt = Opposite.unop c.pt
-- CategoryTheory.Limits.PullbackCone.unop_inl
theorem unop_inl {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    c.unop.inl = c.fst.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : CategoryTheory.Limits.PullbackCone f g)
Goal: c.unop.inl = c.fst.unop
-- CategoryTheory.Limits.PullbackCone.unop_inr
theorem unop_inr {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    c.unop.inr = c.snd.unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : CategoryTheory.Limits.PullbackCone f g)
Goal: c.unop.inr = c.snd.unop
-- CategoryTheory.Limits.PullbackCone.op_pt
@[simps!]
def op {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : PushoutCocone f.op g.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : CategoryTheory.Limits.PullbackCone f g)
Goal: c.op.pt = Opposite.op c.pt
-- CategoryTheory.Limits.PullbackCone.op_ι_app
@[simps!]
def op {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : PushoutCocone f.op g.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : CategoryTheory.Limits.PullbackCone f g)
Goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpan),
  c.op.ι.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op Z))
          (fun val =>
            CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op X))
              (CategoryTheory.Iso.refl (Opposite.op Y)) val)
          X_1).hom ≫
      (c.π.app X_1).op
-- CategoryTheory.Limits.PullbackCone.op_inl
theorem op_inl {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    c.op.inl = c.fst.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : CategoryTheory.Limits.PullbackCone f g)
Goal: c.op.inl = c.fst.op
-- CategoryTheory.Limits.PullbackCone.op_inr
theorem op_inr {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    c.op.inr = c.snd.op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : CategoryTheory.Limits.PullbackCone f g)
Goal: c.op.inr = c.snd.op
-- CategoryTheory.Limits.pullbackIsoUnopPushout_inv_fst
@[reassoc (attr := simp)]
theorem pullbackIsoUnopPushout_inv_fst {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
    [HasPushout f.op g.op] :
    (pullbackIsoUnopPushout f g).inv ≫ pullback.fst f g =
      (pushout.inl _ _ : _ ⟶ pushout f.op g.op).unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPushout f.op g.op]
Goal: (CategoryTheory.Limits.pullbackIsoUnopPushout f g).inv ≫ CategoryTheory.Limits.pullback.fst f g =
  (CategoryTheory.Limits.pushout.inl f.op g.op).unop
-- CategoryTheory.Limits.pullbackIsoUnopPushout_inv_snd
@[reassoc (attr := simp)]
theorem pullbackIsoUnopPushout_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
    [HasPushout f.op g.op] :
    (pullbackIsoUnopPushout f g).inv ≫ pullback.snd f g =
      (pushout.inr _ _ : _ ⟶ pushout f.op g.op).unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPushout f.op g.op]
Goal: (CategoryTheory.Limits.pullbackIsoUnopPushout f g).inv ≫ CategoryTheory.Limits.pullback.snd f g =
  (CategoryTheory.Limits.pushout.inr f.op g.op).unop
-- CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inl
@[reassoc (attr := simp)]
theorem pullbackIsoUnopPushout_hom_inl {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
    [HasPushout f.op g.op] :
    pushout.inl _ _ ≫ (pullbackIsoUnopPushout f g).hom.op = (pullback.fst f g).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPushout f.op g.op]
Goal: CategoryTheory.Limits.pushout.inl f.op g.op ≫ (CategoryTheory.Limits.pullbackIsoUnopPushout f g).hom.op =
  (CategoryTheory.Limits.pullback.fst f g).op
-- CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inr
@[reassoc (attr := simp)]
theorem pullbackIsoUnopPushout_hom_inr {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
    [HasPushout f.op g.op] : pushout.inr _ _ ≫ (pullbackIsoUnopPushout f g).hom.op =
    (pullback.snd f g).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPushout f.op g.op]
Goal: CategoryTheory.Limits.pushout.inr f.op g.op ≫ (CategoryTheory.Limits.pullbackIsoUnopPushout f g).hom.op =
  (CategoryTheory.Limits.pullback.snd f g).op
-- CategoryTheory.Limits.pushoutIsoUnopPullback_inl_hom
@[reassoc (attr := simp)]
theorem pushoutIsoUnopPullback_inl_hom {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
    [HasPullback f.op g.op] :
    pushout.inl _ _ ≫ (pushoutIsoUnopPullback f g).hom = (pullback.fst f.op g.op).unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPullback f.op g.op]
Goal: CategoryTheory.Limits.pushout.inl f g ≫ (CategoryTheory.Limits.pushoutIsoUnopPullback f g).hom =
  (CategoryTheory.Limits.pullback.fst f.op g.op).unop
-- CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom
@[reassoc (attr := simp)]
theorem pushoutIsoUnopPullback_inr_hom {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
    [HasPullback f.op g.op] :
    pushout.inr _ _ ≫ (pushoutIsoUnopPullback f g).hom = (pullback.snd f.op g.op).unop 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPullback f.op g.op]
Goal: CategoryTheory.Limits.pushout.inr f g ≫ (CategoryTheory.Limits.pushoutIsoUnopPullback f g).hom =
  (CategoryTheory.Limits.pullback.snd f.op g.op).unop
-- CategoryTheory.Limits.pushoutIsoUnopPullback_inv_fst
@[simp]
theorem pushoutIsoUnopPullback_inv_fst {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
    [HasPullback f.op g.op] :
    (pushoutIsoUnopPullback f g).inv.op ≫ pullback.fst f.op g.op = (pushout.inl f g).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPullback f.op g.op]
Goal: (CategoryTheory.Limits.pushoutIsoUnopPullback f g).inv.op ≫ CategoryTheory.Limits.pullback.fst f.op g.op =
  (CategoryTheory.Limits.pushout.inl f g).op
-- CategoryTheory.Limits.pushoutIsoUnopPullback_inv_snd
@[simp]
theorem pushoutIsoUnopPullback_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
    [HasPullback f.op g.op] :
    (pushoutIsoUnopPullback f g).inv.op ≫ pullback.snd f.op g.op = (pushout.inr f g).op 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPullback f.op g.op]
Goal: (CategoryTheory.Limits.pushoutIsoUnopPullback f g).inv.op ≫ CategoryTheory.Limits.pullback.snd f.op g.op =
  (CategoryTheory.Limits.pushout.inr f g).op
-- CategoryTheory.Limits.cospan_left
@[simp]
theorem cospan_left {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) : (cospan f g).obj WalkingCospan.left = X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: (CategoryTheory.Limits.cospan f g).obj CategoryTheory.Limits.WalkingCospan.left = X
-- CategoryTheory.Limits.span_left
@[simp]
theorem span_left {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : (span f g).obj WalkingSpan.left = Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
Goal: (CategoryTheory.Limits.span f g).obj CategoryTheory.Limits.WalkingSpan.left = Y
-- CategoryTheory.Limits.cospan_right
@[simp]
theorem cospan_right {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (cospan f g).obj WalkingCospan.right = Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: (CategoryTheory.Limits.cospan f g).obj CategoryTheory.Limits.WalkingCospan.right = Y
-- CategoryTheory.Limits.span_right
@[simp]
theorem span_right {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : (span f g).obj WalkingSpan.right = Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
Goal: (CategoryTheory.Limits.span f g).obj CategoryTheory.Limits.WalkingSpan.right = Z
-- CategoryTheory.Limits.cospan_one
@[simp]
theorem cospan_one {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) : (cospan f g).obj WalkingCospan.one = Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: (CategoryTheory.Limits.cospan f g).obj CategoryTheory.Limits.WalkingCospan.one = Z
-- CategoryTheory.Limits.span_zero
@[simp]
theorem span_zero {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : (span f g).obj WalkingSpan.zero = X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
Goal: (CategoryTheory.Limits.span f g).obj CategoryTheory.Limits.WalkingSpan.zero = X
-- CategoryTheory.Limits.cospan_map_inl
@[simp]
theorem cospan_map_inl {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (cospan f g).map WalkingCospan.Hom.inl = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: (CategoryTheory.Limits.cospan f g).map CategoryTheory.Limits.WalkingCospan.Hom.inl = f
-- CategoryTheory.Limits.span_map_fst
@[simp]
theorem span_map_fst {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : (span f g).map WalkingSpan.Hom.fst = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
Goal: (CategoryTheory.Limits.span f g).map CategoryTheory.Limits.WalkingSpan.Hom.fst = f
-- CategoryTheory.Limits.cospan_map_inr
@[simp]
theorem cospan_map_inr {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (cospan f g).map WalkingCospan.Hom.inr = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
Goal: (CategoryTheory.Limits.cospan f g).map CategoryTheory.Limits.WalkingCospan.Hom.inr = g
-- CategoryTheory.Limits.span_map_snd
@[simp]
theorem span_map_snd {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : (span f g).map WalkingSpan.Hom.snd = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
Goal: (CategoryTheory.Limits.span f g).map CategoryTheory.Limits.WalkingSpan.Hom.snd = g
-- CategoryTheory.Limits.cospan_map_id
theorem cospan_map_id {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (w : WalkingCospan) :
    (cospan f g).map (WalkingCospan.Hom.id w) = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (w : CategoryTheory.Limits.WalkingCospan)
Goal: (CategoryTheory.Limits.cospan f g).map (CategoryTheory.Limits.WalkingCospan.Hom.id w) =
  𝟙 ((CategoryTheory.Limits.cospan f g).obj w)
-- CategoryTheory.Limits.span_map_id
theorem span_map_id {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) (w : WalkingSpan) :
    (span f g).map (WalkingSpan.Hom.id w) = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) (w : CategoryTheory.Limits.WalkingSpan)
Goal: (CategoryTheory.Limits.span f g).map (CategoryTheory.Limits.WalkingSpan.Hom.id w) =
  𝟙 ((CategoryTheory.Limits.span f g).obj w)
-- CategoryTheory.Limits.diagramIsoCospan_inv_app
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Limits.WalkingCospan ⥤ C) (X : CategoryTheory.Limits.WalkingCospan)
Goal: (CategoryTheory.Limits.diagramIsoCospan F).inv.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.diagramIsoCospan_hom_app
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Limits.WalkingCospan ⥤ C) (X : CategoryTheory.Limits.WalkingCospan)
Goal: (CategoryTheory.Limits.diagramIsoCospan F).hom.app X = CategoryTheory.eqToHom ⋯