File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean

full_name: CategoryTheory.Limits.WalkingCospan
code: /-- The type of objects for the diagram indexing a pullback, defined as a special case of
`WidePullbackShape`. -/
abbrev WalkingCospan : Type 
goal: Type

full_name: CategoryTheory.Limits.WalkingCospan.left
code: /-- The left point of the walking cospan. -/
@[match_pattern]
abbrev WalkingCospan.left : WalkingCospan 
goal: CategoryTheory.Limits.WalkingCospan

full_name: CategoryTheory.Limits.WalkingCospan.right
code: /-- The right point of the walking cospan. -/
@[match_pattern]
abbrev WalkingCospan.right : WalkingCospan 
goal: CategoryTheory.Limits.WalkingCospan

full_name: CategoryTheory.Limits.WalkingCospan.one
code: /-- The central point of the walking cospan. -/
@[match_pattern]
abbrev WalkingCospan.one : WalkingCospan 
goal: CategoryTheory.Limits.WalkingCospan

full_name: CategoryTheory.Limits.WalkingSpan
code: /-- The type of objects for the diagram indexing a pushout, defined as a special case of
`WidePushoutShape`.
-/
abbrev WalkingSpan : Type 
goal: Type

full_name: CategoryTheory.Limits.WalkingSpan.left
code: /-- The left point of the walking span. -/
@[match_pattern]
abbrev WalkingSpan.left : WalkingSpan 
goal: CategoryTheory.Limits.WalkingSpan

full_name: CategoryTheory.Limits.WalkingSpan.right
code: /-- The right point of the walking span. -/
@[match_pattern]
abbrev WalkingSpan.right : WalkingSpan 
goal: CategoryTheory.Limits.WalkingSpan

full_name: CategoryTheory.Limits.WalkingSpan.zero
code: /-- The central point of the walking span. -/
@[match_pattern]
abbrev WalkingSpan.zero : WalkingSpan 
goal: CategoryTheory.Limits.WalkingSpan

full_name: CategoryTheory.Limits.WalkingCospan.Hom
code: /-- The type of arrows for the diagram indexing a pullback. -/
abbrev Hom : WalkingCospan → WalkingCospan → Type 
goal: CategoryTheory.Limits.WalkingCospan → CategoryTheory.Limits.WalkingCospan → Type

full_name: CategoryTheory.Limits.WalkingCospan.Hom.inl
code: /-- The left arrow of the walking cospan. -/
@[match_pattern]
abbrev Hom.inl : left ⟶ one 
goal: CategoryTheory.Limits.WalkingCospan.left ⟶ CategoryTheory.Limits.WalkingCospan.one

full_name: CategoryTheory.Limits.WalkingCospan.Hom.inr
code: /-- The right arrow of the walking cospan. -/
@[match_pattern]
abbrev Hom.inr : right ⟶ one 
goal: CategoryTheory.Limits.WalkingCospan.right ⟶ CategoryTheory.Limits.WalkingCospan.one

full_name: CategoryTheory.Limits.WalkingCospan.Hom.id
code: /-- The identity arrows of the walking cospan. -/
@[match_pattern]
abbrev Hom.id (X : WalkingCospan) : X ⟶ X 
goal: X ⟶ X

full_name: CategoryTheory.Limits.WalkingCospan.instSubsingletonHom
code: instance (X Y : WalkingCospan) : Subsingleton (X ⟶ Y) 
goal: Subsingleton (X ⟶ Y)

full_name: CategoryTheory.Limits.WalkingSpan.Hom
code: /-- The type of arrows for the diagram indexing a pushout. -/
abbrev Hom : WalkingSpan → WalkingSpan → Type 
goal: CategoryTheory.Limits.WalkingSpan → CategoryTheory.Limits.WalkingSpan → Type

full_name: CategoryTheory.Limits.WalkingSpan.Hom.fst
code: /-- The left arrow of the walking span. -/
@[match_pattern]
abbrev Hom.fst : zero ⟶ left 
goal: CategoryTheory.Limits.WalkingSpan.zero ⟶ CategoryTheory.Limits.WalkingSpan.left

full_name: CategoryTheory.Limits.WalkingSpan.Hom.snd
code: /-- The right arrow of the walking span. -/
@[match_pattern]
abbrev Hom.snd : zero ⟶ right 
goal: CategoryTheory.Limits.WalkingSpan.zero ⟶ CategoryTheory.Limits.WalkingSpan.right

full_name: CategoryTheory.Limits.WalkingSpan.Hom.id
code: /-- The identity arrows of the walking span. -/
@[match_pattern]
abbrev Hom.id (X : WalkingSpan) : X ⟶ X 
goal: X ⟶ X

full_name: CategoryTheory.Limits.WalkingSpan.instSubsingletonHom
code: instance (X Y : WalkingSpan) : Subsingleton (X ⟶ Y) 
goal: Subsingleton (X ⟶ Y)

full_name: CategoryTheory.Limits.WalkingCospan.ext
code: /-- To construct an isomorphism of cones over the walking cospan,
it suffices to construct an isomorphism
of the cone points and check it commutes with the legs to `left` and `right`. -/
def WalkingCospan.ext {F : WalkingCospan ⥤ C} {s t : Cone F} (i : s.pt ≅ t.pt)
    (w₁ : s.π.app WalkingCospan.left = i.hom ≫ t.π.app WalkingCospan.left)
    (w₂ : s.π.app WalkingCospan.right = i.hom ≫ t.π.app WalkingCospan.right) : s ≅ t 
goal: s ≅ t

full_name: CategoryTheory.Limits.WalkingSpan.ext
code: /-- To construct an isomorphism of cocones over the walking span,
it suffices to construct an isomorphism
of the cocone points and check it commutes with the legs from `left` and `right`. -/
def WalkingSpan.ext {F : WalkingSpan ⥤ C} {s t : Cocone F} (i : s.pt ≅ t.pt)
    (w₁ : s.ι.app WalkingCospan.left ≫ i.hom = t.ι.app WalkingCospan.left)
    (w₂ : s.ι.app WalkingCospan.right ≫ i.hom = t.ι.app WalkingCospan.right) : s ≅ t 
goal: s ≅ t

full_name: CategoryTheory.Limits.cospan
code: /-- `cospan f g` is the functor from the walking cospan hitting `f` and `g`. -/
def cospan {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) : WalkingCospan ⥤ C 
goal: CategoryTheory.Limits.WalkingCospan ⥤ C

full_name: CategoryTheory.Limits.span
code: /-- `span f g` is the functor from the walking span hitting `f` and `g`. -/
def span {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : WalkingSpan ⥤ C 
goal: CategoryTheory.Limits.WalkingSpan ⥤ C

full_name: CategoryTheory.Limits.cospan_left
code: @[simp]
theorem cospan_left {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) : (cospan f g).obj WalkingCospan.left = X 
goal: (CategoryTheory.Limits.cospan f g).obj CategoryTheory.Limits.WalkingCospan.left = X

full_name: CategoryTheory.Limits.span_left
code: @[simp]
theorem span_left {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : (span f g).obj WalkingSpan.left = Y 
goal: (CategoryTheory.Limits.span f g).obj CategoryTheory.Limits.WalkingSpan.left = Y

full_name: CategoryTheory.Limits.cospan_right
code: @[simp]
theorem cospan_right {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (cospan f g).obj WalkingCospan.right = Y 
goal: (CategoryTheory.Limits.cospan f g).obj CategoryTheory.Limits.WalkingCospan.right = Y

full_name: CategoryTheory.Limits.span_right
code: @[simp]
theorem span_right {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : (span f g).obj WalkingSpan.right = Z 
goal: (CategoryTheory.Limits.span f g).obj CategoryTheory.Limits.WalkingSpan.right = Z

full_name: CategoryTheory.Limits.cospan_one
code: @[simp]
theorem cospan_one {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) : (cospan f g).obj WalkingCospan.one = Z 
goal: (CategoryTheory.Limits.cospan f g).obj CategoryTheory.Limits.WalkingCospan.one = Z

full_name: CategoryTheory.Limits.span_zero
code: @[simp]
theorem span_zero {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : (span f g).obj WalkingSpan.zero = X 
goal: (CategoryTheory.Limits.span f g).obj CategoryTheory.Limits.WalkingSpan.zero = X

full_name: CategoryTheory.Limits.cospan_map_inl
code: @[simp]
theorem cospan_map_inl {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (cospan f g).map WalkingCospan.Hom.inl = f 
goal: (CategoryTheory.Limits.cospan f g).map CategoryTheory.Limits.WalkingCospan.Hom.inl = f

full_name: CategoryTheory.Limits.span_map_fst
code: @[simp]
theorem span_map_fst {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : (span f g).map WalkingSpan.Hom.fst = f 
goal: (CategoryTheory.Limits.span f g).map CategoryTheory.Limits.WalkingSpan.Hom.fst = f

full_name: CategoryTheory.Limits.cospan_map_inr
code: @[simp]
theorem cospan_map_inr {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    (cospan f g).map WalkingCospan.Hom.inr = g 
goal: (CategoryTheory.Limits.cospan f g).map CategoryTheory.Limits.WalkingCospan.Hom.inr = g

full_name: CategoryTheory.Limits.span_map_snd
code: @[simp]
theorem span_map_snd {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) : (span f g).map WalkingSpan.Hom.snd = g 
goal: (CategoryTheory.Limits.span f g).map CategoryTheory.Limits.WalkingSpan.Hom.snd = g

full_name: CategoryTheory.Limits.cospan_map_id
code: theorem cospan_map_id {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (w : WalkingCospan) :
    (cospan f g).map (WalkingCospan.Hom.id w) = 𝟙 _ 
goal: (CategoryTheory.Limits.cospan f g).map (CategoryTheory.Limits.WalkingCospan.Hom.id w) =
  𝟙 ((CategoryTheory.Limits.cospan f g).obj w)

full_name: CategoryTheory.Limits.span_map_id
code: theorem span_map_id {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) (w : WalkingSpan) :
    (span f g).map (WalkingSpan.Hom.id w) = 𝟙 _ 
goal: (CategoryTheory.Limits.span f g).map (CategoryTheory.Limits.WalkingSpan.Hom.id w) =
  𝟙 ((CategoryTheory.Limits.span f g).obj w)

full_name: CategoryTheory.Limits.diagramIsoCospan_inv_app
code: /-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) 
goal: (CategoryTheory.Limits.diagramIsoCospan F).inv.app X = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Limits.diagramIsoCospan
code: /-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) 
goal: F ≅
  CategoryTheory.Limits.cospan (F.map CategoryTheory.Limits.WalkingCospan.Hom.inl)
    (F.map CategoryTheory.Limits.WalkingCospan.Hom.inr)

full_name: CategoryTheory.Limits.diagramIsoCospan_hom_app
code: /-- Every diagram indexing a pullback is naturally isomorphic (actually, equal) to a `cospan` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoCospan (F : WalkingCospan ⥤ C) : F ≅ cospan (F.map inl) (F.map inr) 
goal: (CategoryTheory.Limits.diagramIsoCospan F).hom.app X = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Limits.diagramIsoSpan
code: /-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) 
goal: F ≅
  CategoryTheory.Limits.span (F.map CategoryTheory.Limits.WalkingSpan.Hom.fst)
    (F.map CategoryTheory.Limits.WalkingSpan.Hom.snd)

full_name: CategoryTheory.Limits.diagramIsoSpan_inv_app
code: /-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) 
goal: (CategoryTheory.Limits.diagramIsoSpan F).inv.app X = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Limits.diagramIsoSpan_hom_app
code: /-- Every diagram indexing a pushout is naturally isomorphic (actually, equal) to a `span` -/
-- @[simps (config := { rhsMd := semireducible })]  Porting note: no semireducible
@[simps!]
def diagramIsoSpan (F : WalkingSpan ⥤ C) : F ≅ span (F.map fst) (F.map snd) 
goal: (CategoryTheory.Limits.diagramIsoSpan F).hom.app X = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Limits.cospanCompIso
code: /-- A functor applied to a cospan is a cospan. -/
def cospanCompIso (F : C ⥤ D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
    cospan f g ⋙ F ≅ cospan (F.map f) (F.map g) 
goal: CategoryTheory.Limits.cospan f g ⋙ F ≅ CategoryTheory.Limits.cospan (F.map f) (F.map g)

full_name: CategoryTheory.Limits.cospanCompIso_app_left
code: @[simp]
theorem cospanCompIso_app_left : (cospanCompIso F f g).app WalkingCospan.left = Iso.refl _ 
goal: (CategoryTheory.Limits.cospanCompIso F f g).app CategoryTheory.Limits.WalkingCospan.left =
  CategoryTheory.Iso.refl ((CategoryTheory.Limits.cospan f g ⋙ F).obj CategoryTheory.Limits.WalkingCospan.left)

full_name: CategoryTheory.Limits.cospanCompIso_app_right
code: @[simp]
theorem cospanCompIso_app_right : (cospanCompIso F f g).app WalkingCospan.right = Iso.refl _ 
goal: (CategoryTheory.Limits.cospanCompIso F f g).app CategoryTheory.Limits.WalkingCospan.right =
  CategoryTheory.Iso.refl ((CategoryTheory.Limits.cospan f g ⋙ F).obj CategoryTheory.Limits.WalkingCospan.right)

full_name: CategoryTheory.Limits.cospanCompIso_app_one
code: @[simp]
theorem cospanCompIso_app_one : (cospanCompIso F f g).app WalkingCospan.one = Iso.refl _ 
goal: (CategoryTheory.Limits.cospanCompIso F f g).app CategoryTheory.Limits.WalkingCospan.one =
  CategoryTheory.Iso.refl ((CategoryTheory.Limits.cospan f g ⋙ F).obj CategoryTheory.Limits.WalkingCospan.one)

full_name: CategoryTheory.Limits.cospanCompIso_hom_app_left
code: @[simp]
theorem cospanCompIso_hom_app_left : (cospanCompIso F f g).hom.app WalkingCospan.left = 𝟙 _ 
goal: (CategoryTheory.Limits.cospanCompIso F f g).hom.app CategoryTheory.Limits.WalkingCospan.left =
  𝟙 ((CategoryTheory.Limits.cospan f g ⋙ F).obj CategoryTheory.Limits.WalkingCospan.left)

full_name: CategoryTheory.Limits.cospanCompIso_hom_app_right
code: @[simp]
theorem cospanCompIso_hom_app_right : (cospanCompIso F f g).hom.app WalkingCospan.right = 𝟙 _ 
goal: (CategoryTheory.Limits.cospanCompIso F f g).hom.app CategoryTheory.Limits.WalkingCospan.right =
  𝟙 ((CategoryTheory.Limits.cospan f g ⋙ F).obj CategoryTheory.Limits.WalkingCospan.right)

full_name: CategoryTheory.Limits.cospanCompIso_hom_app_one
code: @[simp]
theorem cospanCompIso_hom_app_one : (cospanCompIso F f g).hom.app WalkingCospan.one = 𝟙 _ 
goal: (CategoryTheory.Limits.cospanCompIso F f g).hom.app CategoryTheory.Limits.WalkingCospan.one =
  𝟙 ((CategoryTheory.Limits.cospan f g ⋙ F).obj CategoryTheory.Limits.WalkingCospan.one)

full_name: CategoryTheory.Limits.cospanCompIso_inv_app_left
code: @[simp]
theorem cospanCompIso_inv_app_left : (cospanCompIso F f g).inv.app WalkingCospan.left = 𝟙 _ 
goal: (CategoryTheory.Limits.cospanCompIso F f g).inv.app CategoryTheory.Limits.WalkingCospan.left =
  𝟙 ((CategoryTheory.Limits.cospan (F.map f) (F.map g)).obj CategoryTheory.Limits.WalkingCospan.left)

full_name: CategoryTheory.Limits.cospanCompIso_inv_app_right
code: @[simp]
theorem cospanCompIso_inv_app_right : (cospanCompIso F f g).inv.app WalkingCospan.right = 𝟙 _ 
goal: (CategoryTheory.Limits.cospanCompIso F f g).inv.app CategoryTheory.Limits.WalkingCospan.right =
  𝟙 ((CategoryTheory.Limits.cospan (F.map f) (F.map g)).obj CategoryTheory.Limits.WalkingCospan.right)

full_name: CategoryTheory.Limits.cospanCompIso_inv_app_one
code: @[simp]
theorem cospanCompIso_inv_app_one : (cospanCompIso F f g).inv.app WalkingCospan.one = 𝟙 _ 
goal: (CategoryTheory.Limits.cospanCompIso F f g).inv.app CategoryTheory.Limits.WalkingCospan.one =
  𝟙 ((CategoryTheory.Limits.cospan (F.map f) (F.map g)).obj CategoryTheory.Limits.WalkingCospan.one)

full_name: CategoryTheory.Limits.spanCompIso
code: /-- A functor applied to a span is a span. -/
def spanCompIso (F : C ⥤ D) {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    span f g ⋙ F ≅ span (F.map f) (F.map g) 
goal: CategoryTheory.Limits.span f g ⋙ F ≅ CategoryTheory.Limits.span (F.map f) (F.map g)

full_name: CategoryTheory.Limits.spanCompIso_app_left
code: @[simp]
theorem spanCompIso_app_left : (spanCompIso F f g).app WalkingSpan.left = Iso.refl _ 
goal: (CategoryTheory.Limits.spanCompIso F f g).app CategoryTheory.Limits.WalkingSpan.left =
  CategoryTheory.Iso.refl ((CategoryTheory.Limits.span f g ⋙ F).obj CategoryTheory.Limits.WalkingSpan.left)

full_name: CategoryTheory.Limits.spanCompIso_app_right
code: @[simp]
theorem spanCompIso_app_right : (spanCompIso F f g).app WalkingSpan.right = Iso.refl _ 
goal: (CategoryTheory.Limits.spanCompIso F f g).app CategoryTheory.Limits.WalkingSpan.right =
  CategoryTheory.Iso.refl ((CategoryTheory.Limits.span f g ⋙ F).obj CategoryTheory.Limits.WalkingSpan.right)

full_name: CategoryTheory.Limits.spanCompIso_app_zero
code: @[simp]
theorem spanCompIso_app_zero : (spanCompIso F f g).app WalkingSpan.zero = Iso.refl _ 
goal: (CategoryTheory.Limits.spanCompIso F f g).app CategoryTheory.Limits.WalkingSpan.zero =
  CategoryTheory.Iso.refl ((CategoryTheory.Limits.span f g ⋙ F).obj CategoryTheory.Limits.WalkingSpan.zero)

full_name: CategoryTheory.Limits.spanCompIso_hom_app_left
code: @[simp]
theorem spanCompIso_hom_app_left : (spanCompIso F f g).hom.app WalkingSpan.left = 𝟙 _ 
goal: (CategoryTheory.Limits.spanCompIso F f g).hom.app CategoryTheory.Limits.WalkingSpan.left =
  𝟙 ((CategoryTheory.Limits.span f g ⋙ F).obj CategoryTheory.Limits.WalkingSpan.left)

full_name: CategoryTheory.Limits.spanCompIso_hom_app_right
code: @[simp]
theorem spanCompIso_hom_app_right : (spanCompIso F f g).hom.app WalkingSpan.right = 𝟙 _ 
goal: (CategoryTheory.Limits.spanCompIso F f g).hom.app CategoryTheory.Limits.WalkingSpan.right =
  𝟙 ((CategoryTheory.Limits.span f g ⋙ F).obj CategoryTheory.Limits.WalkingSpan.right)

full_name: CategoryTheory.Limits.spanCompIso_hom_app_zero
code: @[simp]
theorem spanCompIso_hom_app_zero : (spanCompIso F f g).hom.app WalkingSpan.zero = 𝟙 _ 
goal: (CategoryTheory.Limits.spanCompIso F f g).hom.app CategoryTheory.Limits.WalkingSpan.zero =
  𝟙 ((CategoryTheory.Limits.span f g ⋙ F).obj CategoryTheory.Limits.WalkingSpan.zero)

full_name: CategoryTheory.Limits.spanCompIso_inv_app_left
code: @[simp]
theorem spanCompIso_inv_app_left : (spanCompIso F f g).inv.app WalkingSpan.left = 𝟙 _ 
goal: (CategoryTheory.Limits.spanCompIso F f g).inv.app CategoryTheory.Limits.WalkingSpan.left =
  𝟙 ((CategoryTheory.Limits.span (F.map f) (F.map g)).obj CategoryTheory.Limits.WalkingSpan.left)

full_name: CategoryTheory.Limits.spanCompIso_inv_app_right
code: @[simp]
theorem spanCompIso_inv_app_right : (spanCompIso F f g).inv.app WalkingSpan.right = 𝟙 _ 
goal: (CategoryTheory.Limits.spanCompIso F f g).inv.app CategoryTheory.Limits.WalkingSpan.right =
  𝟙 ((CategoryTheory.Limits.span (F.map f) (F.map g)).obj CategoryTheory.Limits.WalkingSpan.right)

full_name: CategoryTheory.Limits.spanCompIso_inv_app_zero
code: @[simp]
theorem spanCompIso_inv_app_zero : (spanCompIso F f g).inv.app WalkingSpan.zero = 𝟙 _ 
goal: (CategoryTheory.Limits.spanCompIso F f g).inv.app CategoryTheory.Limits.WalkingSpan.zero =
  𝟙 ((CategoryTheory.Limits.span (F.map f) (F.map g)).obj CategoryTheory.Limits.WalkingSpan.zero)

full_name: CategoryTheory.Limits.cospanExt
code: /-- Construct an isomorphism of cospans from components. -/
def cospanExt (wf : iX.hom ≫ f' = f ≫ iZ.hom) (wg : iY.hom ≫ g' = g ≫ iZ.hom) :
    cospan f g ≅ cospan f' g' 
goal: CategoryTheory.Limits.cospan f g ≅ CategoryTheory.Limits.cospan f' g'

full_name: CategoryTheory.Limits.cospanExt_app_left
code: @[simp]
theorem cospanExt_app_left : (cospanExt iX iY iZ wf wg).app WalkingCospan.left = iX 
goal: (CategoryTheory.Limits.cospanExt iX iY iZ wf wg).app CategoryTheory.Limits.WalkingCospan.left = iX

full_name: CategoryTheory.Limits.cospanExt_app_right
code: @[simp]
theorem cospanExt_app_right : (cospanExt iX iY iZ wf wg).app WalkingCospan.right = iY 
goal: (CategoryTheory.Limits.cospanExt iX iY iZ wf wg).app CategoryTheory.Limits.WalkingCospan.right = iY

full_name: CategoryTheory.Limits.cospanExt_app_one
code: @[simp]
theorem cospanExt_app_one : (cospanExt iX iY iZ wf wg).app WalkingCospan.one = iZ 
goal: (CategoryTheory.Limits.cospanExt iX iY iZ wf wg).app CategoryTheory.Limits.WalkingCospan.one = iZ

full_name: CategoryTheory.Limits.cospanExt_hom_app_left
code: @[simp]
theorem cospanExt_hom_app_left :
    (cospanExt iX iY iZ wf wg).hom.app WalkingCospan.left = iX.hom 
goal: (CategoryTheory.Limits.cospanExt iX iY iZ wf wg).hom.app CategoryTheory.Limits.WalkingCospan.left = iX.hom

full_name: CategoryTheory.Limits.cospanExt_hom_app_right
code: @[simp]
theorem cospanExt_hom_app_right :
    (cospanExt iX iY iZ wf wg).hom.app WalkingCospan.right = iY.hom 
goal: (CategoryTheory.Limits.cospanExt iX iY iZ wf wg).hom.app CategoryTheory.Limits.WalkingCospan.right = iY.hom

full_name: CategoryTheory.Limits.cospanExt_hom_app_one
code: @[simp]
theorem cospanExt_hom_app_one : (cospanExt iX iY iZ wf wg).hom.app WalkingCospan.one = iZ.hom 
goal: (CategoryTheory.Limits.cospanExt iX iY iZ wf wg).hom.app CategoryTheory.Limits.WalkingCospan.one = iZ.hom

full_name: CategoryTheory.Limits.cospanExt_inv_app_left
code: @[simp]
theorem cospanExt_inv_app_left :
    (cospanExt iX iY iZ wf wg).inv.app WalkingCospan.left = iX.inv 
goal: (CategoryTheory.Limits.cospanExt iX iY iZ wf wg).inv.app CategoryTheory.Limits.WalkingCospan.left = iX.inv

full_name: CategoryTheory.Limits.cospanExt_inv_app_right
code: @[simp]
theorem cospanExt_inv_app_right :
    (cospanExt iX iY iZ wf wg).inv.app WalkingCospan.right = iY.inv 
goal: (CategoryTheory.Limits.cospanExt iX iY iZ wf wg).inv.app CategoryTheory.Limits.WalkingCospan.right = iY.inv

full_name: CategoryTheory.Limits.cospanExt_inv_app_one
code: @[simp]
theorem cospanExt_inv_app_one : (cospanExt iX iY iZ wf wg).inv.app WalkingCospan.one = iZ.inv 
goal: (CategoryTheory.Limits.cospanExt iX iY iZ wf wg).inv.app CategoryTheory.Limits.WalkingCospan.one = iZ.inv

full_name: CategoryTheory.Limits.spanExt
code: /-- Construct an isomorphism of spans from components. -/
def spanExt (wf : iX.hom ≫ f' = f ≫ iY.hom) (wg : iX.hom ≫ g' = g ≫ iZ.hom) :
    span f g ≅ span f' g' 
goal: CategoryTheory.Limits.span f g ≅ CategoryTheory.Limits.span f' g'

full_name: CategoryTheory.Limits.spanExt_app_left
code: @[simp]
theorem spanExt_app_left : (spanExt iX iY iZ wf wg).app WalkingSpan.left = iY 
goal: (CategoryTheory.Limits.spanExt iX iY iZ wf wg).app CategoryTheory.Limits.WalkingSpan.left = iY

full_name: CategoryTheory.Limits.spanExt_app_right
code: @[simp]
theorem spanExt_app_right : (spanExt iX iY iZ wf wg).app WalkingSpan.right = iZ 
goal: (CategoryTheory.Limits.spanExt iX iY iZ wf wg).app CategoryTheory.Limits.WalkingSpan.right = iZ

full_name: CategoryTheory.Limits.spanExt_app_one
code: @[simp]
theorem spanExt_app_one : (spanExt iX iY iZ wf wg).app WalkingSpan.zero = iX 
goal: (CategoryTheory.Limits.spanExt iX iY iZ wf wg).app CategoryTheory.Limits.WalkingSpan.zero = iX

full_name: CategoryTheory.Limits.spanExt_hom_app_left
code: @[simp]
theorem spanExt_hom_app_left : (spanExt iX iY iZ wf wg).hom.app WalkingSpan.left = iY.hom 
goal: (CategoryTheory.Limits.spanExt iX iY iZ wf wg).hom.app CategoryTheory.Limits.WalkingSpan.left = iY.hom

full_name: CategoryTheory.Limits.spanExt_hom_app_right
code: @[simp]
theorem spanExt_hom_app_right : (spanExt iX iY iZ wf wg).hom.app WalkingSpan.right = iZ.hom 
goal: (CategoryTheory.Limits.spanExt iX iY iZ wf wg).hom.app CategoryTheory.Limits.WalkingSpan.right = iZ.hom

full_name: CategoryTheory.Limits.spanExt_hom_app_zero
code: @[simp]
theorem spanExt_hom_app_zero : (spanExt iX iY iZ wf wg).hom.app WalkingSpan.zero = iX.hom 
goal: (CategoryTheory.Limits.spanExt iX iY iZ wf wg).hom.app CategoryTheory.Limits.WalkingSpan.zero = iX.hom

full_name: CategoryTheory.Limits.spanExt_inv_app_left
code: @[simp]
theorem spanExt_inv_app_left : (spanExt iX iY iZ wf wg).inv.app WalkingSpan.left = iY.inv 
goal: (CategoryTheory.Limits.spanExt iX iY iZ wf wg).inv.app CategoryTheory.Limits.WalkingSpan.left = iY.inv

full_name: CategoryTheory.Limits.spanExt_inv_app_right
code: @[simp]
theorem spanExt_inv_app_right : (spanExt iX iY iZ wf wg).inv.app WalkingSpan.right = iZ.inv 
goal: (CategoryTheory.Limits.spanExt iX iY iZ wf wg).inv.app CategoryTheory.Limits.WalkingSpan.right = iZ.inv

full_name: CategoryTheory.Limits.spanExt_inv_app_zero
code: @[simp]
theorem spanExt_inv_app_zero : (spanExt iX iY iZ wf wg).inv.app WalkingSpan.zero = iX.inv 
goal: (CategoryTheory.Limits.spanExt iX iY iZ wf wg).inv.app CategoryTheory.Limits.WalkingSpan.zero = iX.inv