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

full_name: CategoryTheory.Limits.HasPullback
code: /-- `HasPullback f g` represents a particular choice of limiting cone
for the pair of morphisms `f : X ⟶ Z` and `g : Y ⟶ Z`.
-/
abbrev HasPullback {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) 
goal: Prop

full_name: CategoryTheory.Limits.HasPushout
code: /-- `HasPushout f g` represents a particular choice of colimiting cocone
for the pair of morphisms `f : X ⟶ Y` and `g : X ⟶ Z`.
-/
abbrev HasPushout {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) 
goal: Prop

full_name: CategoryTheory.Limits.pullback
code: /-- `pullback f g` computes the pullback of a pair of morphisms with the same target. -/
abbrev pullback {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g] 
goal: C

full_name: CategoryTheory.Limits.pullback.cone
code: /-- The cone associated to the pullback of `f` and `g`-/
abbrev pullback.cone {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g] : PullbackCone f g 
goal: CategoryTheory.Limits.PullbackCone f g

full_name: CategoryTheory.Limits.pushout
code: /-- `pushout f g` computes the pushout of a pair of morphisms with the same source. -/
abbrev pushout {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g] 
goal: C

full_name: CategoryTheory.Limits.pushout.cocone
code: /-- The cocone associated to the pullback of `f` and `g` -/
abbrev pushout.cocone {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g] : PushoutCocone f g 
goal: CategoryTheory.Limits.PushoutCocone f g

full_name: CategoryTheory.Limits.pullback.fst
code: /-- The first projection of the pullback of `f` and `g`. -/
abbrev pullback.fst {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g] : pullback f g ⟶ X 
goal: CategoryTheory.Limits.pullback f g ⟶ X

full_name: CategoryTheory.Limits.pullback.snd
code: /-- The second projection of the pullback of `f` and `g`. -/
abbrev pullback.snd {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g] : pullback f g ⟶ Y 
goal: CategoryTheory.Limits.pullback f g ⟶ Y

full_name: CategoryTheory.Limits.pushout.inl
code: /-- The first inclusion into the pushout of `f` and `g`. -/
abbrev pushout.inl {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g] : Y ⟶ pushout f g 
goal: Y ⟶ CategoryTheory.Limits.pushout f g

full_name: CategoryTheory.Limits.pushout.inr
code: /-- The second inclusion into the pushout of `f` and `g`. -/
abbrev pushout.inr {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g] : Z ⟶ pushout f g 
goal: Z ⟶ CategoryTheory.Limits.pushout f g

full_name: CategoryTheory.Limits.pullback.lift
code: /-- A pair of morphisms `h : W ⟶ X` and `k : W ⟶ Y` satisfying `h ≫ f = k ≫ g` induces a morphism
    `pullback.lift : W ⟶ pullback f g`. -/
abbrev pullback.lift {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} [HasPullback f g] (h : W ⟶ X)
    (k : W ⟶ Y) (w : h ≫ f = k ≫ g) : W ⟶ pullback f g 
goal: W ⟶ CategoryTheory.Limits.pullback f g

full_name: CategoryTheory.Limits.pushout.desc
code: /-- A pair of morphisms `h : Y ⟶ W` and `k : Z ⟶ W` satisfying `f ≫ h = g ≫ k` induces a morphism
    `pushout.desc : pushout f g ⟶ W`. -/
abbrev pushout.desc {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [HasPushout f g] (h : Y ⟶ W) (k : Z ⟶ W)
    (w : f ≫ h = g ≫ k) : pushout f g ⟶ W 
goal: CategoryTheory.Limits.pushout f g ⟶ W

full_name: CategoryTheory.Limits.pullback.isLimit
code: /-- The cone associated to a pullback is a limit cone. -/
abbrev pullback.isLimit {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g] :
    IsLimit (pullback.cone f g) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.pullback.cone f g)

full_name: CategoryTheory.Limits.pushout.isColimit
code: /-- The cocone associated to a pushout is a colimit cone. -/
abbrev pushout.isColimit {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g] :
    IsColimit (pushout.cocone f g) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.pushout.cocone f g)

full_name: CategoryTheory.Limits.PullbackCone.fst_limit_cone
code: @[simp]
theorem PullbackCone.fst_limit_cone {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasLimit (cospan f g)] :
    PullbackCone.fst (limit.cone (cospan f g)) = pullback.fst f g 
goal: CategoryTheory.Limits.PullbackCone.fst (CategoryTheory.Limits.limit.cone (CategoryTheory.Limits.cospan f g)) =
  CategoryTheory.Limits.pullback.fst f g

full_name: CategoryTheory.Limits.PullbackCone.snd_limit_cone
code: @[simp]
theorem PullbackCone.snd_limit_cone {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasLimit (cospan f g)] :
    PullbackCone.snd (limit.cone (cospan f g)) = pullback.snd f g 
goal: CategoryTheory.Limits.PullbackCone.snd (CategoryTheory.Limits.limit.cone (CategoryTheory.Limits.cospan f g)) =
  CategoryTheory.Limits.pullback.snd f g

full_name: CategoryTheory.Limits.PushoutCocone.inl_colimit_cocone
code: theorem PushoutCocone.inl_colimit_cocone {X Y Z : C} (f : Z ⟶ X) (g : Z ⟶ Y)
    [HasColimit (span f g)] : PushoutCocone.inl (colimit.cocone (span f g)) = pushout.inl _ _ 
goal: CategoryTheory.Limits.PushoutCocone.inl (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Limits.span f g)) =
  CategoryTheory.Limits.pushout.inl f g

full_name: CategoryTheory.Limits.PushoutCocone.inr_colimit_cocone
code: theorem PushoutCocone.inr_colimit_cocone {X Y Z : C} (f : Z ⟶ X) (g : Z ⟶ Y)
    [HasColimit (span f g)] : PushoutCocone.inr (colimit.cocone (span f g)) = pushout.inr _ _ 
goal: CategoryTheory.Limits.PushoutCocone.inr (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Limits.span f g)) =
  CategoryTheory.Limits.pushout.inr f g

full_name: CategoryTheory.Limits.pullback.lift_fst
code: @[reassoc]
theorem pullback.lift_fst {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} [HasPullback f g] (h : W ⟶ X)
    (k : W ⟶ Y) (w : h ≫ f = k ≫ g) : pullback.lift h k w ≫ pullback.fst f g = h 
goal: CategoryTheory.Limits.pullback.lift h k w ≫ CategoryTheory.Limits.pullback.fst f g = h

full_name: CategoryTheory.Limits.pullback.lift_snd
code: @[reassoc]
theorem pullback.lift_snd {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} [HasPullback f g] (h : W ⟶ X)
    (k : W ⟶ Y) (w : h ≫ f = k ≫ g) : pullback.lift h k w ≫ pullback.snd f g = k 
goal: CategoryTheory.Limits.pullback.lift h k w ≫ CategoryTheory.Limits.pullback.snd f g = k

full_name: CategoryTheory.Limits.pushout.inl_desc
code: @[reassoc]
theorem pushout.inl_desc {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [HasPushout f g] (h : Y ⟶ W)
    (k : Z ⟶ W) (w : f ≫ h = g ≫ k) : pushout.inl _ _ ≫ pushout.desc h k w = h 
goal: CategoryTheory.Limits.pushout.inl f g ≫ CategoryTheory.Limits.pushout.desc h k w = h

full_name: CategoryTheory.Limits.pushout.inr_desc
code: @[reassoc]
theorem pushout.inr_desc {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [HasPushout f g] (h : Y ⟶ W)
    (k : Z ⟶ W) (w : f ≫ h = g ≫ k) : pushout.inr _ _ ≫ pushout.desc h k w = k 
goal: CategoryTheory.Limits.pushout.inr f g ≫ CategoryTheory.Limits.pushout.desc h k w = k

full_name: CategoryTheory.Limits.pullback.lift'
code: /-- A pair of morphisms `h : W ⟶ X` and `k : W ⟶ Y` satisfying `h ≫ f = k ≫ g` induces a morphism
    `l : W ⟶ pullback f g` such that `l ≫ pullback.fst = h` and `l ≫ pullback.snd = k`. -/
def pullback.lift' {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} [HasPullback f g] (h : W ⟶ X) (k : W ⟶ Y)
    (w : h ≫ f = k ≫ g) :
      { l : W ⟶ pullback f g // l ≫ pullback.fst f g = h ∧ l ≫ pullback.snd f g = k } 
goal: { l // l ≫ CategoryTheory.Limits.pullback.fst f g = h ∧ l ≫ CategoryTheory.Limits.pullback.snd f g = k }

full_name: CategoryTheory.Limits.pullback.desc'
code: /-- A pair of morphisms `h : Y ⟶ W` and `k : Z ⟶ W` satisfying `f ≫ h = g ≫ k` induces a morphism
    `l : pushout f g ⟶ W` such that `pushout.inl _ _ ≫ l = h` and `pushout.inr _ _ ≫ l = k`. -/
def pullback.desc' {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [HasPushout f g] (h : Y ⟶ W) (k : Z ⟶ W)
    (w : f ≫ h = g ≫ k) :
      { l : pushout f g ⟶ W // pushout.inl _ _ ≫ l = h ∧ pushout.inr _ _ ≫ l = k } 
goal: { l // CategoryTheory.Limits.pushout.inl f g ≫ l = h ∧ CategoryTheory.Limits.pushout.inr f g ≫ l = k }

full_name: CategoryTheory.Limits.pullback.condition
code: @[reassoc]
theorem pullback.condition {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} [HasPullback f g] :
    pullback.fst f g ≫ f = pullback.snd f g ≫ g 
goal: CategoryTheory.Limits.pullback.fst f g ≫ f = CategoryTheory.Limits.pullback.snd f g ≫ g

full_name: CategoryTheory.Limits.pushout.condition
code: @[reassoc]
theorem pushout.condition {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [HasPushout f g] :
    f ≫ (pushout.inl f g) = g ≫ pushout.inr _ _ 
goal: f ≫ CategoryTheory.Limits.pushout.inl f g = g ≫ CategoryTheory.Limits.pushout.inr f g

full_name: CategoryTheory.Limits.pullback.hom_ext
code: /-- Two morphisms into a pullback are equal if their compositions with the pullback morphisms are
    equal -/
@[ext 1100]
theorem pullback.hom_ext {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} [HasPullback f g] {W : C}
    {k l : W ⟶ pullback f g} (h₀ : k ≫ pullback.fst f g = l ≫ pullback.fst f g)
    (h₁ : k ≫ pullback.snd f g = l ≫ pullback.snd f g) : k = l 
goal: k = l

full_name: CategoryTheory.Limits.pullbackIsPullback
code: /-- The pullback cone built from the pullback projections is a pullback. -/
def pullbackIsPullback {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g] :
    IsLimit (PullbackCone.mk (pullback.fst f g) (pullback.snd f g) pullback.condition) 
goal: CategoryTheory.Limits.IsLimit
  (CategoryTheory.Limits.PullbackCone.mk (CategoryTheory.Limits.pullback.fst f g)
    (CategoryTheory.Limits.pullback.snd f g) ⋯)

full_name: CategoryTheory.Limits.pushout.hom_ext
code: /-- Two morphisms out of a pushout are equal if their compositions with the pushout morphisms are
    equal -/
@[ext 1100]
theorem pushout.hom_ext {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [HasPushout f g] {W : C}
    {k l : pushout f g ⟶ W} (h₀ : pushout.inl _ _ ≫ k = pushout.inl _ _ ≫ l)
    (h₁ : pushout.inr _ _ ≫ k = pushout.inr _ _ ≫ l) : k = l 
goal: k = l

full_name: CategoryTheory.Limits.pushoutIsPushout
code: /-- The pushout cocone built from the pushout coprojections is a pushout. -/
def pushoutIsPushout {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g] :
    IsColimit (PushoutCocone.mk (pushout.inl f g) (pushout.inr _ _) pushout.condition) 
goal: CategoryTheory.Limits.IsColimit
  (CategoryTheory.Limits.PushoutCocone.mk (CategoryTheory.Limits.pushout.inl f g)
    (CategoryTheory.Limits.pushout.inr f g) ⋯)

full_name: CategoryTheory.Limits.pullback.map
code: /-- Given such a diagram, then there is a natural morphism `W ×ₛ X ⟶ Y ×ₜ Z`.

```
W ⟶ Y
  ↘   ↘
  S ⟶ T
  ↗   ↗
X ⟶ Z
```
-/
abbrev pullback.map {W X Y Z S T : C} (f₁ : W ⟶ S) (f₂ : X ⟶ S) [HasPullback f₁ f₂] (g₁ : Y ⟶ T)
    (g₂ : Z ⟶ T) [HasPullback g₁ g₂] (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T)
    (eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁) (eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂) : pullback f₁ f₂ ⟶ pullback g₁ g₂ 
goal: CategoryTheory.Limits.pullback f₁ f₂ ⟶ CategoryTheory.Limits.pullback g₁ g₂

full_name: CategoryTheory.Limits.pullback.mapDesc
code: /-- The canonical map `X ×ₛ Y ⟶ X ×ₜ Y` given `S ⟶ T`. -/
abbrev pullback.mapDesc {X Y S T : C} (f : X ⟶ S) (g : Y ⟶ S) (i : S ⟶ T) [HasPullback f g]
    [HasPullback (f ≫ i) (g ≫ i)] : pullback f g ⟶ pullback (f ≫ i) (g ≫ i) 
goal: CategoryTheory.Limits.pullback f g ⟶ CategoryTheory.Limits.pullback (f ≫ i) (g ≫ i)

full_name: CategoryTheory.Limits.pullback.map_comp
code: @[reassoc]
lemma pullback.map_comp {X Y Z X' Y' Z' X'' Y'' Z'' : C}
    {f : X ⟶ Z} {g : Y ⟶ Z} {f' : X' ⟶ Z'} {g' : Y' ⟶ Z'} {f'' : X'' ⟶ Z''} {g'' : Y'' ⟶ Z''}
    (i₁ : X ⟶ X') (j₁ : X' ⟶ X'') (i₂ : Y ⟶ Y') (j₂ : Y' ⟶ Y'') (i₃ : Z ⟶ Z') (j₃ : Z' ⟶ Z'')
    [HasPullback f g] [HasPullback f' g'] [HasPullback f'' g'']
    (e₁ e₂ e₃ e₄) :
    pullback.map f g f' g' i₁ i₂ i₃ e₁ e₂ ≫ pullback.map f' g' f'' g'' j₁ j₂ j₃ e₃ e₄ =
      pullback.map f g f'' g'' (i₁ ≫ j₁) (i₂ ≫ j₂) (i₃ ≫ j₃)
        (by rw [reassoc_of% e₁, e₃, Category.assoc])
        (by rw [reassoc_of% e₂, e₄, Category.assoc]) 
goal: CategoryTheory.Limits.pullback.map f g f' g' i₁ i₂ i₃ e₁ e₂ ≫
    CategoryTheory.Limits.pullback.map f' g' f'' g'' j₁ j₂ j₃ e₃ e₄ =
  CategoryTheory.Limits.pullback.map f g f'' g'' (i₁ ≫ j₁) (i₂ ≫ j₂) (i₃ ≫ j₃) ⋯ ⋯

full_name: CategoryTheory.Limits.pullback.map_id
code: @[simp]
lemma pullback.map_id {X Y Z : C}
    {f : X ⟶ Z} {g : Y ⟶ Z} [HasPullback f g] :
    pullback.map f g f g (𝟙 _) (𝟙 _) (𝟙 _) (by simp) (by simp) = 𝟙 _ 
goal: CategoryTheory.Limits.pullback.map f g f g (𝟙 X) (𝟙 Y) (𝟙 Z) ⋯ ⋯ = 𝟙 (CategoryTheory.Limits.pullback f g)

full_name: CategoryTheory.Limits.pushout.map
code: /-- Given such a diagram, then there is a natural morphism `W ⨿ₛ X ⟶ Y ⨿ₜ Z`.

```
  W ⟶ Y
 ↗   ↗
S ⟶ T
 ↘   ↘
  X ⟶ Z
```
-/
abbrev pushout.map {W X Y Z S T : C} (f₁ : S ⟶ W) (f₂ : S ⟶ X) [HasPushout f₁ f₂] (g₁ : T ⟶ Y)
    (g₂ : T ⟶ Z) [HasPushout g₁ g₂] (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T) (eq₁ : f₁ ≫ i₁ = i₃ ≫ g₁)
    (eq₂ : f₂ ≫ i₂ = i₃ ≫ g₂) : pushout f₁ f₂ ⟶ pushout g₁ g₂ 
goal: CategoryTheory.Limits.pushout f₁ f₂ ⟶ CategoryTheory.Limits.pushout g₁ g₂

full_name: CategoryTheory.Limits.pushout.mapLift
code: /-- The canonical map `X ⨿ₛ Y ⟶ X ⨿ₜ Y` given `S ⟶ T`. -/
abbrev pushout.mapLift {X Y S T : C} (f : T ⟶ X) (g : T ⟶ Y) (i : S ⟶ T) [HasPushout f g]
    [HasPushout (i ≫ f) (i ≫ g)] : pushout (i ≫ f) (i ≫ g) ⟶ pushout f g 
goal: CategoryTheory.Limits.pushout (i ≫ f) (i ≫ g) ⟶ CategoryTheory.Limits.pushout f g

full_name: CategoryTheory.Limits.pushout.map_comp
code: @[reassoc]
lemma pushout.map_comp {X Y Z X' Y' Z' X'' Y'' Z'' : C}
    {f : X ⟶ Y} {g : X ⟶ Z} {f' : X' ⟶ Y'} {g' : X' ⟶ Z'} {f'' : X'' ⟶ Y''} {g'' : X'' ⟶ Z''}
    (i₁ : X ⟶ X') (j₁ : X' ⟶ X'') (i₂ : Y ⟶ Y') (j₂ : Y' ⟶ Y'') (i₃ : Z ⟶ Z') (j₃ : Z' ⟶ Z'')
    [HasPushout f g] [HasPushout f' g'] [HasPushout f'' g'']
    (e₁ e₂ e₃ e₄) :
    pushout.map f g f' g' i₂ i₃ i₁ e₁ e₂ ≫ pushout.map f' g' f'' g'' j₂ j₃ j₁ e₃ e₄ =
      pushout.map f g f'' g'' (i₂ ≫ j₂) (i₃ ≫ j₃) (i₁ ≫ j₁)
        (by rw [reassoc_of% e₁, e₃, Category.assoc])
        (by rw [reassoc_of% e₂, e₄, Category.assoc]) 
goal: CategoryTheory.Limits.pushout.map f g f' g' i₂ i₃ i₁ e₁ e₂ ≫
    CategoryTheory.Limits.pushout.map f' g' f'' g'' j₂ j₃ j₁ e₃ e₄ =
  CategoryTheory.Limits.pushout.map f g f'' g'' (i₂ ≫ j₂) (i₃ ≫ j₃) (i₁ ≫ j₁) ⋯ ⋯

full_name: CategoryTheory.Limits.pushout.map_id
code: @[simp]
lemma pushout.map_id {X Y Z : C}
    {f : X ⟶ Y} {g : X ⟶ Z} [HasPushout f g] :
    pushout.map f g f g (𝟙 _) (𝟙 _) (𝟙 _) (by simp) (by simp) = 𝟙 _ 
goal: CategoryTheory.Limits.pushout.map f g f g (𝟙 Y) (𝟙 Z) (𝟙 X) ⋯ ⋯ = 𝟙 (CategoryTheory.Limits.pushout f g)

full_name: CategoryTheory.Limits.pullback.map_isIso
code: instance pullback.map_isIso {W X Y Z S T : C} (f₁ : W ⟶ S) (f₂ : X ⟶ S) [HasPullback f₁ f₂]
    (g₁ : Y ⟶ T) (g₂ : Z ⟶ T) [HasPullback g₁ g₂] (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T)
    (eq₁ : f₁ ≫ i₃ = i₁ ≫ g₁) (eq₂ : f₂ ≫ i₃ = i₂ ≫ g₂) [IsIso i₁] [IsIso i₂] [IsIso i₃] :
    IsIso (pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)

full_name: CategoryTheory.Limits.pullback.congrHom
code: /-- If `f₁ = f₂` and `g₁ = g₂`, we may construct a canonical
isomorphism `pullback f₁ g₁ ≅ pullback f₂ g₂` -/
@[simps! hom]
def pullback.congrHom {X Y Z : C} {f₁ f₂ : X ⟶ Z} {g₁ g₂ : Y ⟶ Z} (h₁ : f₁ = f₂) (h₂ : g₁ = g₂)
    [HasPullback f₁ g₁] [HasPullback f₂ g₂] : pullback f₁ g₁ ≅ pullback f₂ g₂ 
goal: CategoryTheory.Limits.pullback f₁ g₁ ≅ CategoryTheory.Limits.pullback f₂ g₂

full_name: CategoryTheory.Limits.pullback.congrHom_hom
code: /-- If `f₁ = f₂` and `g₁ = g₂`, we may construct a canonical
isomorphism `pullback f₁ g₁ ≅ pullback f₂ g₂` -/
@[simps! hom]
def pullback.congrHom {X Y Z : C} {f₁ f₂ : X ⟶ Z} {g₁ g₂ : Y ⟶ Z} (h₁ : f₁ = f₂) (h₂ : g₁ = g₂)
    [HasPullback f₁ g₁] [HasPullback f₂ g₂] : pullback f₁ g₁ ≅ pullback f₂ g₂ 
goal: (CategoryTheory.Limits.pullback.congrHom h₁ h₂).hom =
  CategoryTheory.Limits.pullback.map f₁ g₁ f₂ g₂ (𝟙 X) (𝟙 Y) (𝟙 Z) ⋯ ⋯

full_name: CategoryTheory.Limits.pullback.congrHom_inv
code: @[simp]
theorem pullback.congrHom_inv {X Y Z : C} {f₁ f₂ : X ⟶ Z} {g₁ g₂ : Y ⟶ Z} (h₁ : f₁ = f₂)
    (h₂ : g₁ = g₂) [HasPullback f₁ g₁] [HasPullback f₂ g₂] :
    (pullback.congrHom h₁ h₂).inv =
      pullback.map _ _ _ _ (𝟙 _) (𝟙 _) (𝟙 _) (by simp [h₁]) (by simp [h₂]) 
goal: (CategoryTheory.Limits.pullback.congrHom h₁ h₂).inv =
  CategoryTheory.Limits.pullback.map f₂ g₂ f₁ g₁ (𝟙 X) (𝟙 Y) (𝟙 Z) ⋯ ⋯

full_name: CategoryTheory.Limits.pushout.map_isIso
code: instance pushout.map_isIso {W X Y Z S T : C} (f₁ : S ⟶ W) (f₂ : S ⟶ X) [HasPushout f₁ f₂]
    (g₁ : T ⟶ Y) (g₂ : T ⟶ Z) [HasPushout g₁ g₂] (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T)
    (eq₁ : f₁ ≫ i₁ = i₃ ≫ g₁) (eq₂ : f₂ ≫ i₂ = i₃ ≫ g₂) [IsIso i₁] [IsIso i₂] [IsIso i₃] :
    IsIso (pushout.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.pushout.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)

full_name: CategoryTheory.Limits.pullback.mapDesc_comp
code: theorem pullback.mapDesc_comp {X Y S T S' : C} (f : X ⟶ T) (g : Y ⟶ T) (i : T ⟶ S) (i' : S ⟶ S')
    [HasPullback f g] [HasPullback (f ≫ i) (g ≫ i)] [HasPullback (f ≫ i ≫ i') (g ≫ i ≫ i')]
    [HasPullback ((f ≫ i) ≫ i') ((g ≫ i) ≫ i')] :
    pullback.mapDesc f g (i ≫ i') = pullback.mapDesc f g i ≫ pullback.mapDesc _ _ i' ≫
    (pullback.congrHom (Category.assoc _ _ _) (Category.assoc _ _ _)).hom 
goal: CategoryTheory.Limits.pullback.mapDesc f g (i ≫ i') =
  CategoryTheory.Limits.pullback.mapDesc f g i ≫
    CategoryTheory.Limits.pullback.mapDesc (f ≫ i) (g ≫ i) i' ≫ (CategoryTheory.Limits.pullback.congrHom ⋯ ⋯).hom

full_name: CategoryTheory.Limits.pushout.congrHom_hom
code: /-- If `f₁ = f₂` and `g₁ = g₂`, we may construct a canonical
isomorphism `pushout f₁ g₁ ≅ pullback f₂ g₂` -/
@[simps! hom]
def pushout.congrHom {X Y Z : C} {f₁ f₂ : X ⟶ Y} {g₁ g₂ : X ⟶ Z} (h₁ : f₁ = f₂) (h₂ : g₁ = g₂)
    [HasPushout f₁ g₁] [HasPushout f₂ g₂] : pushout f₁ g₁ ≅ pushout f₂ g₂ 
goal: (CategoryTheory.Limits.pushout.congrHom h₁ h₂).hom = CategoryTheory.Limits.pushout.map f₁ g₁ f₂ g₂ (𝟙 Y) (𝟙 Z) (𝟙 X) ⋯ ⋯

full_name: CategoryTheory.Limits.pushout.congrHom
code: /-- If `f₁ = f₂` and `g₁ = g₂`, we may construct a canonical
isomorphism `pushout f₁ g₁ ≅ pullback f₂ g₂` -/
@[simps! hom]
def pushout.congrHom {X Y Z : C} {f₁ f₂ : X ⟶ Y} {g₁ g₂ : X ⟶ Z} (h₁ : f₁ = f₂) (h₂ : g₁ = g₂)
    [HasPushout f₁ g₁] [HasPushout f₂ g₂] : pushout f₁ g₁ ≅ pushout f₂ g₂ 
goal: CategoryTheory.Limits.pushout f₁ g₁ ≅ CategoryTheory.Limits.pushout f₂ g₂

full_name: CategoryTheory.Limits.pushout.congrHom_inv
code: @[simp]
theorem pushout.congrHom_inv {X Y Z : C} {f₁ f₂ : X ⟶ Y} {g₁ g₂ : X ⟶ Z} (h₁ : f₁ = f₂)
    (h₂ : g₁ = g₂) [HasPushout f₁ g₁] [HasPushout f₂ g₂] :
    (pushout.congrHom h₁ h₂).inv =
      pushout.map _ _ _ _ (𝟙 _) (𝟙 _) (𝟙 _) (by simp [h₁]) (by simp [h₂]) 
goal: (CategoryTheory.Limits.pushout.congrHom h₁ h₂).inv = CategoryTheory.Limits.pushout.map f₂ g₂ f₁ g₁ (𝟙 Y) (𝟙 Z) (𝟙 X) ⋯ ⋯

full_name: CategoryTheory.Limits.pushout.mapLift_comp
code: theorem pushout.mapLift_comp {X Y S T S' : C} (f : T ⟶ X) (g : T ⟶ Y) (i : S ⟶ T) (i' : S' ⟶ S)
    [HasPushout f g] [HasPushout (i ≫ f) (i ≫ g)] [HasPushout (i' ≫ i ≫ f) (i' ≫ i ≫ g)]
    [HasPushout ((i' ≫ i) ≫ f) ((i' ≫ i) ≫ g)] :
    pushout.mapLift f g (i' ≫ i) =
      (pushout.congrHom (Category.assoc _ _ _) (Category.assoc _ _ _)).hom ≫
        pushout.mapLift _ _ i' ≫ pushout.mapLift f g i 
goal: CategoryTheory.Limits.pushout.mapLift f g (i' ≫ i) =
  (CategoryTheory.Limits.pushout.congrHom ⋯ ⋯).hom ≫
    CategoryTheory.Limits.pushout.mapLift (i ≫ f) (i ≫ g) i' ≫ CategoryTheory.Limits.pushout.mapLift f g i

full_name: CategoryTheory.Limits.pullbackComparison
code: /-- The comparison morphism for the pullback of `f,g`.
This is an isomorphism iff `G` preserves the pullback of `f,g`; see
`Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean`
-/
def pullbackComparison (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g] [HasPullback (G.map f) (G.map g)] :
    G.obj (pullback f g) ⟶ pullback (G.map f) (G.map g) 
goal: G.obj (CategoryTheory.Limits.pullback f g) ⟶ CategoryTheory.Limits.pullback (G.map f) (G.map g)

full_name: CategoryTheory.Limits.pullbackComparison_comp_fst
code: @[reassoc (attr := simp)]
theorem pullbackComparison_comp_fst (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
    [HasPullback (G.map f) (G.map g)] :
    pullbackComparison G f g ≫ pullback.fst _ _ = G.map (pullback.fst f g) 
goal: CategoryTheory.Limits.pullbackComparison G f g ≫ CategoryTheory.Limits.pullback.fst (G.map f) (G.map g) =
  G.map (CategoryTheory.Limits.pullback.fst f g)

full_name: CategoryTheory.Limits.pullbackComparison_comp_snd
code: @[reassoc (attr := simp)]
theorem pullbackComparison_comp_snd (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
    [HasPullback (G.map f) (G.map g)] :
    pullbackComparison G f g ≫ pullback.snd _ _ = G.map (pullback.snd f g)
goal: CategoryTheory.Limits.pullbackComparison G f g ≫ CategoryTheory.Limits.pullback.snd (G.map f) (G.map g) =
  G.map (CategoryTheory.Limits.pullback.snd f g)

full_name: CategoryTheory.Limits.map_lift_pullbackComparison
code: @[reassoc (attr := simp)]
theorem map_lift_pullbackComparison (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
    [HasPullback (G.map f) (G.map g)] {W : C} {h : W ⟶ X} {k : W ⟶ Y} (w : h ≫ f = k ≫ g) :
    G.map (pullback.lift _ _ w) ≫ pullbackComparison G f g =
      pullback.lift (G.map h) (G.map k) (by simp only [← G.map_comp, w]) 
goal: G.map (CategoryTheory.Limits.pullback.lift h k w) ≫ CategoryTheory.Limits.pullbackComparison G f g =
  CategoryTheory.Limits.pullback.lift (G.map h) (G.map k) ⋯

full_name: CategoryTheory.Limits.pushoutComparison
code: /-- The comparison morphism for the pushout of `f,g`.
This is an isomorphism iff `G` preserves the pushout of `f,g`; see
`Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean`
-/
def pushoutComparison (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g] [HasPushout (G.map f) (G.map g)] :
    pushout (G.map f) (G.map g) ⟶ G.obj (pushout f g) 
goal: CategoryTheory.Limits.pushout (G.map f) (G.map g) ⟶ G.obj (CategoryTheory.Limits.pushout f g)

full_name: CategoryTheory.Limits.inl_comp_pushoutComparison
code: @[reassoc (attr := simp)]
theorem inl_comp_pushoutComparison (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g]
    [HasPushout (G.map f) (G.map g)] : pushout.inl _ _ ≫ pushoutComparison G f g =
      G.map (pushout.inl _ _) 
goal: CategoryTheory.Limits.pushout.inl (G.map f) (G.map g) ≫ CategoryTheory.Limits.pushoutComparison G f g =
  G.map (CategoryTheory.Limits.pushout.inl f g)

full_name: CategoryTheory.Limits.inr_comp_pushoutComparison
code: @[reassoc (attr := simp)]
theorem inr_comp_pushoutComparison (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g]
    [HasPushout (G.map f) (G.map g)] : pushout.inr _ _ ≫ pushoutComparison G f g =
      G.map (pushout.inr _ _) 
goal: CategoryTheory.Limits.pushout.inr (G.map f) (G.map g) ≫ CategoryTheory.Limits.pushoutComparison G f g =
  G.map (CategoryTheory.Limits.pushout.inr f g)

full_name: CategoryTheory.Limits.pushoutComparison_map_desc
code: @[reassoc (attr := simp)]
theorem pushoutComparison_map_desc (f : X ⟶ Y) (g : X ⟶ Z) [HasPushout f g]
    [HasPushout (G.map f) (G.map g)] {W : C} {h : Y ⟶ W} {k : Z ⟶ W} (w : f ≫ h = g ≫ k) :
    pushoutComparison G f g ≫ G.map (pushout.desc _ _ w) =
      pushout.desc (G.map h) (G.map k) (by simp only [← G.map_comp, w]) 
goal: CategoryTheory.Limits.pushoutComparison G f g ≫ G.map (CategoryTheory.Limits.pushout.desc h k w) =
  CategoryTheory.Limits.pushout.desc (G.map h) (G.map k) ⋯

full_name: CategoryTheory.Limits.hasPullback_symmetry
code: /-- Making this a global instance would make the typeclass search go in an infinite loop. -/
theorem hasPullback_symmetry [HasPullback f g] : HasPullback g f 
goal: CategoryTheory.Limits.HasPullback g f

full_name: CategoryTheory.Limits.pullbackSymmetry
code: /-- The isomorphism `X ×[Z] Y ≅ Y ×[Z] X`. -/
def pullbackSymmetry [HasPullback f g] : pullback f g ≅ pullback g f 
goal: CategoryTheory.Limits.pullback f g ≅ CategoryTheory.Limits.pullback g f

full_name: CategoryTheory.Limits.pullbackSymmetry_hom_comp_fst
code: @[reassoc (attr := simp)]
theorem pullbackSymmetry_hom_comp_fst [HasPullback f g] :
    (pullbackSymmetry f g).hom ≫ pullback.fst g f = pullback.snd f g 
goal: (CategoryTheory.Limits.pullbackSymmetry f g).hom ≫ CategoryTheory.Limits.pullback.fst g f =
  CategoryTheory.Limits.pullback.snd f g

full_name: CategoryTheory.Limits.pullbackSymmetry_hom_comp_snd
code: @[reassoc (attr := simp)]
theorem pullbackSymmetry_hom_comp_snd [HasPullback f g] :
    (pullbackSymmetry f g).hom ≫ pullback.snd g f = pullback.fst f g 
goal: (CategoryTheory.Limits.pullbackSymmetry f g).hom ≫ CategoryTheory.Limits.pullback.snd g f =
  CategoryTheory.Limits.pullback.fst f g

full_name: CategoryTheory.Limits.pullbackSymmetry_inv_comp_fst
code: @[reassoc (attr := simp)]
theorem pullbackSymmetry_inv_comp_fst [HasPullback f g] :
    (pullbackSymmetry f g).inv ≫ pullback.fst f g = pullback.snd g f 
goal: (CategoryTheory.Limits.pullbackSymmetry f g).inv ≫ CategoryTheory.Limits.pullback.fst f g =
  CategoryTheory.Limits.pullback.snd g f

full_name: CategoryTheory.Limits.pullbackSymmetry_inv_comp_snd
code: @[reassoc (attr := simp)]
theorem pullbackSymmetry_inv_comp_snd [HasPullback f g] :
    (pullbackSymmetry f g).inv ≫ pullback.snd f g = pullback.fst g f 
goal: (CategoryTheory.Limits.pullbackSymmetry f g).inv ≫ CategoryTheory.Limits.pullback.snd f g =
  CategoryTheory.Limits.pullback.fst g f

full_name: CategoryTheory.Limits.hasPushout_symmetry
code: /-- Making this a global instance would make the typeclass search go in an infinite loop. -/
theorem hasPushout_symmetry [HasPushout f g] : HasPushout g f 
goal: CategoryTheory.Limits.HasPushout g f

full_name: CategoryTheory.Limits.pushoutSymmetry
code: /-- The isomorphism `Y ⨿[X] Z ≅ Z ⨿[X] Y`. -/
def pushoutSymmetry [HasPushout f g] : pushout f g ≅ pushout g f 
goal: CategoryTheory.Limits.pushout f g ≅ CategoryTheory.Limits.pushout g f

full_name: CategoryTheory.Limits.inl_comp_pushoutSymmetry_hom
code: @[reassoc (attr := simp)]
theorem inl_comp_pushoutSymmetry_hom [HasPushout f g] :
    pushout.inl _ _ ≫ (pushoutSymmetry f g).hom = pushout.inr _ _ 
goal: CategoryTheory.Limits.pushout.inl f g ≫ (CategoryTheory.Limits.pushoutSymmetry f g).hom =
  CategoryTheory.Limits.pushout.inr g f

full_name: CategoryTheory.Limits.inr_comp_pushoutSymmetry_hom
code: @[reassoc (attr := simp)]
theorem inr_comp_pushoutSymmetry_hom [HasPushout f g] :
    pushout.inr _ _ ≫ (pushoutSymmetry f g).hom = pushout.inl _ _ 
goal: CategoryTheory.Limits.pushout.inr f g ≫ (CategoryTheory.Limits.pushoutSymmetry f g).hom =
  CategoryTheory.Limits.pushout.inl g f

full_name: CategoryTheory.Limits.inl_comp_pushoutSymmetry_inv
code: @[reassoc (attr := simp)]
theorem inl_comp_pushoutSymmetry_inv [HasPushout f g] :
    pushout.inl _ _ ≫ (pushoutSymmetry f g).inv = pushout.inr _ _ 
goal: CategoryTheory.Limits.pushout.inl g f ≫ (CategoryTheory.Limits.pushoutSymmetry f g).inv =
  CategoryTheory.Limits.pushout.inr f g

full_name: CategoryTheory.Limits.inr_comp_pushoutSymmetry_inv
code: @[reassoc (attr := simp)]
theorem inr_comp_pushoutSymmetry_inv [HasPushout f g] :
    pushout.inr _ _ ≫ (pushoutSymmetry f g).inv = pushout.inl _ _ 
goal: CategoryTheory.Limits.pushout.inr g f ≫ (CategoryTheory.Limits.pushoutSymmetry f g).inv =
  CategoryTheory.Limits.pushout.inl f g

full_name: CategoryTheory.Limits.HasPullbacks
code: /-- `HasPullbacks` represents a choice of pullback for every pair of morphisms

See <https://stacks.math.columbia.edu/tag/001W>
-/
abbrev HasPullbacks 
goal: Prop

full_name: CategoryTheory.Limits.HasPushouts
code: /-- `HasPushouts` represents a choice of pushout for every pair of morphisms -/
abbrev HasPushouts 
goal: Prop

full_name: CategoryTheory.Limits.hasPullbacks_of_hasLimit_cospan
code: /-- If `C` has all limits of diagrams `cospan f g`, then it has all pullbacks -/
theorem hasPullbacks_of_hasLimit_cospan
    [∀ {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}, HasLimit (cospan f g)] : HasPullbacks C 
goal: CategoryTheory.Limits.HasPullbacks C

full_name: CategoryTheory.Limits.hasPushouts_of_hasColimit_span
code: /-- If `C` has all colimits of diagrams `span f g`, then it has all pushouts -/
theorem hasPushouts_of_hasColimit_span
    [∀ {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}, HasColimit (span f g)] : HasPushouts C 
goal: CategoryTheory.Limits.HasPushouts C

full_name: CategoryTheory.Limits.walkingSpanOpEquiv
code: /-- The duality equivalence `WalkingSpanᵒᵖ ≌ WalkingCospan` -/
@[simps!]
def walkingSpanOpEquiv : WalkingSpanᵒᵖ ≌ WalkingCospan 
goal: CategoryTheory.Limits.WalkingSpanᵒᵖ ≌ CategoryTheory.Limits.WalkingCospan

full_name: CategoryTheory.Limits.walkingSpanOpEquiv_functor_map
code: /-- The duality equivalence `WalkingSpanᵒᵖ ≌ WalkingCospan` -/
@[simps!]
def walkingSpanOpEquiv : WalkingSpanᵒᵖ ≌ WalkingCospan 
goal: ∀ {X Y : (CategoryTheory.Limits.WidePushoutShape CategoryTheory.Limits.WalkingPair)ᵒᵖ} (f : X ⟶ Y),
  CategoryTheory.Limits.walkingSpanOpEquiv.functor.map f =
    (CategoryTheory.Limits.widePushoutShapeOpMap CategoryTheory.Limits.WalkingPair (Opposite.unop Y) (Opposite.unop X)
        f.unop).unop

full_name: CategoryTheory.Limits.walkingSpanOpEquiv_inverse_obj
code: /-- The duality equivalence `WalkingSpanᵒᵖ ≌ WalkingCospan` -/
@[simps!]
def walkingSpanOpEquiv : WalkingSpanᵒᵖ ≌ WalkingCospan 
goal: CategoryTheory.Limits.walkingSpanOpEquiv.inverse.obj X = Opposite.op X

full_name: CategoryTheory.Limits.walkingSpanOpEquiv_unitIso_hom_app
code: /-- The duality equivalence `WalkingSpanᵒᵖ ≌ WalkingCospan` -/
@[simps!]
def walkingSpanOpEquiv : WalkingSpanᵒᵖ ≌ WalkingCospan 
goal: CategoryTheory.Limits.walkingSpanOpEquiv.unitIso.hom.app X = 𝟙 X

full_name: CategoryTheory.Limits.walkingSpanOpEquiv_inverse_map
code: /-- The duality equivalence `WalkingSpanᵒᵖ ≌ WalkingCospan` -/
@[simps!]
def walkingSpanOpEquiv : WalkingSpanᵒᵖ ≌ WalkingCospan 
goal: ∀ (a : X₁ ⟶ X₂),
  CategoryTheory.Limits.walkingSpanOpEquiv.inverse.map a =
    CategoryTheory.Limits.widePullbackShapeOpMap CategoryTheory.Limits.WalkingPair X₁ X₂ a

full_name: CategoryTheory.Limits.walkingSpanOpEquiv_counitIso_hom_app
code: /-- The duality equivalence `WalkingSpanᵒᵖ ≌ WalkingCospan` -/
@[simps!]
def walkingSpanOpEquiv : WalkingSpanᵒᵖ ≌ WalkingCospan 
goal: CategoryTheory.Limits.walkingSpanOpEquiv.counitIso.hom.app X = 𝟙 X

full_name: CategoryTheory.Limits.walkingSpanOpEquiv_functor_obj
code: /-- The duality equivalence `WalkingSpanᵒᵖ ≌ WalkingCospan` -/
@[simps!]
def walkingSpanOpEquiv : WalkingSpanᵒᵖ ≌ WalkingCospan 
goal: CategoryTheory.Limits.walkingSpanOpEquiv.functor.obj X = Opposite.unop X

full_name: CategoryTheory.Limits.walkingSpanOpEquiv_unitIso_inv_app
code: /-- The duality equivalence `WalkingSpanᵒᵖ ≌ WalkingCospan` -/
@[simps!]
def walkingSpanOpEquiv : WalkingSpanᵒᵖ ≌ WalkingCospan 
goal: CategoryTheory.Limits.walkingSpanOpEquiv.unitIso.inv.app X = 𝟙 X

full_name: CategoryTheory.Limits.walkingSpanOpEquiv_counitIso_inv_app
code: /-- The duality equivalence `WalkingSpanᵒᵖ ≌ WalkingCospan` -/
@[simps!]
def walkingSpanOpEquiv : WalkingSpanᵒᵖ ≌ WalkingCospan 
goal: CategoryTheory.Limits.walkingSpanOpEquiv.counitIso.inv.app X = 𝟙 X

full_name: CategoryTheory.Limits.walkingCospanOpEquiv_functor_map
code: /-- The duality equivalence `WalkingCospanᵒᵖ ≌ WalkingSpan` -/
@[simps!]
def walkingCospanOpEquiv : WalkingCospanᵒᵖ ≌ WalkingSpan 
goal: ∀ {X Y : (CategoryTheory.Limits.WidePullbackShape CategoryTheory.Limits.WalkingPair)ᵒᵖ} (f : X ⟶ Y),
  CategoryTheory.Limits.walkingCospanOpEquiv.functor.map f =
    (CategoryTheory.Limits.widePullbackShapeOpMap CategoryTheory.Limits.WalkingPair (Opposite.unop Y) (Opposite.unop X)
        f.unop).unop

full_name: CategoryTheory.Limits.walkingCospanOpEquiv_unitIso_inv_app
code: /-- The duality equivalence `WalkingCospanᵒᵖ ≌ WalkingSpan` -/
@[simps!]
def walkingCospanOpEquiv : WalkingCospanᵒᵖ ≌ WalkingSpan 
goal: CategoryTheory.Limits.walkingCospanOpEquiv.unitIso.inv.app X = 𝟙 X

full_name: CategoryTheory.Limits.walkingCospanOpEquiv_inverse_obj
code: /-- The duality equivalence `WalkingCospanᵒᵖ ≌ WalkingSpan` -/
@[simps!]
def walkingCospanOpEquiv : WalkingCospanᵒᵖ ≌ WalkingSpan 
goal: CategoryTheory.Limits.walkingCospanOpEquiv.inverse.obj X = Opposite.op X

full_name: CategoryTheory.Limits.walkingCospanOpEquiv_unitIso_hom_app
code: /-- The duality equivalence `WalkingCospanᵒᵖ ≌ WalkingSpan` -/
@[simps!]
def walkingCospanOpEquiv : WalkingCospanᵒᵖ ≌ WalkingSpan 
goal: CategoryTheory.Limits.walkingCospanOpEquiv.unitIso.hom.app X = 𝟙 X

full_name: CategoryTheory.Limits.walkingCospanOpEquiv_counitIso_hom_app
code: /-- The duality equivalence `WalkingCospanᵒᵖ ≌ WalkingSpan` -/
@[simps!]
def walkingCospanOpEquiv : WalkingCospanᵒᵖ ≌ WalkingSpan 
goal: CategoryTheory.Limits.walkingCospanOpEquiv.counitIso.hom.app X = 𝟙 X

full_name: CategoryTheory.Limits.walkingCospanOpEquiv
code: /-- The duality equivalence `WalkingCospanᵒᵖ ≌ WalkingSpan` -/
@[simps!]
def walkingCospanOpEquiv : WalkingCospanᵒᵖ ≌ WalkingSpan 
goal: CategoryTheory.Limits.WalkingCospanᵒᵖ ≌ CategoryTheory.Limits.WalkingSpan

full_name: CategoryTheory.Limits.walkingCospanOpEquiv_inverse_map
code: /-- The duality equivalence `WalkingCospanᵒᵖ ≌ WalkingSpan` -/
@[simps!]
def walkingCospanOpEquiv : WalkingCospanᵒᵖ ≌ WalkingSpan 
goal: ∀ (a : X ⟶ Y),
  CategoryTheory.Limits.walkingCospanOpEquiv.inverse.map a =
    CategoryTheory.Limits.widePushoutShapeOpMap CategoryTheory.Limits.WalkingPair X Y a

full_name: CategoryTheory.Limits.walkingCospanOpEquiv_functor_obj
code: /-- The duality equivalence `WalkingCospanᵒᵖ ≌ WalkingSpan` -/
@[simps!]
def walkingCospanOpEquiv : WalkingCospanᵒᵖ ≌ WalkingSpan 
goal: CategoryTheory.Limits.walkingCospanOpEquiv.functor.obj X = Opposite.unop X

full_name: CategoryTheory.Limits.walkingCospanOpEquiv_counitIso_inv_app
code: /-- The duality equivalence `WalkingCospanᵒᵖ ≌ WalkingSpan` -/
@[simps!]
def walkingCospanOpEquiv : WalkingCospanᵒᵖ ≌ WalkingSpan 
goal: CategoryTheory.Limits.walkingCospanOpEquiv.counitIso.inv.app X = 𝟙 X

full_name: CategoryTheory.Limits.hasPullbacks_of_hasWidePullbacks
code: /-- Having wide pullback at any universe level implies having binary pullbacks. -/
instance (priority := 100) hasPullbacks_of_hasWidePullbacks (D : Type u) [Category.{v} D]
    [HasWidePullbacks.{w} D] : HasPullbacks.{v,u} D 
goal: CategoryTheory.Limits.HasPullbacks D

full_name: CategoryTheory.Limits.hasPushouts_of_hasWidePushouts
code: /-- Having wide pushout at any universe level implies having binary pushouts. -/
instance (priority := 100) hasPushouts_of_hasWidePushouts (D : Type u) [Category.{v} D]
    [HasWidePushouts.{w} D] : HasPushouts.{v,u} D 
goal: CategoryTheory.Limits.HasPushouts D