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

full_name: CategoryTheory.Limits.pullbackConeOfLeftIso
code: /-- If `f : X ⟶ Z` is iso, then `X ×[Z] Y ≅ Y`. This is the explicit limit cone. -/
def pullbackConeOfLeftIso : PullbackCone f g 
goal: CategoryTheory.Limits.PullbackCone f g

full_name: CategoryTheory.Limits.pullbackConeOfLeftIso_x
code: @[simp]
theorem pullbackConeOfLeftIso_x : (pullbackConeOfLeftIso f g).pt = Y 
goal: (CategoryTheory.Limits.pullbackConeOfLeftIso f g).pt = Y

full_name: CategoryTheory.Limits.pullbackConeOfLeftIso_fst
code: @[simp]
theorem pullbackConeOfLeftIso_fst : (pullbackConeOfLeftIso f g).fst = g ≫ inv f 
goal: (CategoryTheory.Limits.pullbackConeOfLeftIso f g).fst = g ≫ CategoryTheory.inv f

full_name: CategoryTheory.Limits.pullbackConeOfLeftIso_snd
code: @[simp]
theorem pullbackConeOfLeftIso_snd : (pullbackConeOfLeftIso f g).snd = 𝟙 _ 
goal: (CategoryTheory.Limits.pullbackConeOfLeftIso f g).snd = 𝟙 (CategoryTheory.Limits.pullbackConeOfLeftIso f g).pt

full_name: CategoryTheory.Limits.pullbackConeOfLeftIso_π_app_none
code: theorem pullbackConeOfLeftIso_π_app_none : (pullbackConeOfLeftIso f g).π.app none = g 
goal: (CategoryTheory.Limits.pullbackConeOfLeftIso f g).π.app none = g

full_name: CategoryTheory.Limits.pullbackConeOfLeftIso_π_app_left
code: @[simp]
theorem pullbackConeOfLeftIso_π_app_left : (pullbackConeOfLeftIso f g).π.app left = g ≫ inv f 
goal: (CategoryTheory.Limits.pullbackConeOfLeftIso f g).π.app CategoryTheory.Limits.WalkingCospan.left =
  g ≫ CategoryTheory.inv f

full_name: CategoryTheory.Limits.pullbackConeOfLeftIso_π_app_right
code: @[simp]
theorem pullbackConeOfLeftIso_π_app_right : (pullbackConeOfLeftIso f g).π.app right = 𝟙 _ 
goal: (CategoryTheory.Limits.pullbackConeOfLeftIso f g).π.app CategoryTheory.Limits.WalkingCospan.right =
  𝟙
    (((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingCospan).obj
          (CategoryTheory.Limits.pullbackConeOfLeftIso f g).pt).obj
      CategoryTheory.Limits.WalkingCospan.right)

full_name: CategoryTheory.Limits.pullbackConeOfLeftIsoIsLimit
code: /-- Verify that the constructed limit cone is indeed a limit. -/
def pullbackConeOfLeftIsoIsLimit : IsLimit (pullbackConeOfLeftIso f g) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.pullbackConeOfLeftIso f g)

full_name: CategoryTheory.Limits.hasPullback_of_left_iso
code: theorem hasPullback_of_left_iso : HasPullback f g 
goal: CategoryTheory.Limits.HasPullback f g

full_name: CategoryTheory.Limits.pullback_snd_iso_of_left_iso
code: instance pullback_snd_iso_of_left_iso : IsIso (pullback.snd f g) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.pullback.snd f g)

full_name: CategoryTheory.Limits.pullback_inv_snd_fst_of_left_isIso
code: @[reassoc (attr := simp)]
lemma pullback_inv_snd_fst_of_left_isIso :
    inv (pullback.snd f g) ≫ pullback.fst f g = g ≫ inv f 
goal: CategoryTheory.inv (CategoryTheory.Limits.pullback.snd f g) ≫ CategoryTheory.Limits.pullback.fst f g =
  g ≫ CategoryTheory.inv f

full_name: CategoryTheory.Limits.pullbackConeOfRightIso
code: /-- If `g : Y ⟶ Z` is iso, then `X ×[Z] Y ≅ X`. This is the explicit limit cone. -/
def pullbackConeOfRightIso : PullbackCone f g 
goal: CategoryTheory.Limits.PullbackCone f g

full_name: CategoryTheory.Limits.pullbackConeOfRightIso_x
code: @[simp]
theorem pullbackConeOfRightIso_x : (pullbackConeOfRightIso f g).pt = X 
goal: (CategoryTheory.Limits.pullbackConeOfRightIso f g).pt = X

full_name: CategoryTheory.Limits.pullbackConeOfRightIso_fst
code: @[simp]
theorem pullbackConeOfRightIso_fst : (pullbackConeOfRightIso f g).fst = 𝟙 _ 
goal: (CategoryTheory.Limits.pullbackConeOfRightIso f g).fst = 𝟙 (CategoryTheory.Limits.pullbackConeOfRightIso f g).pt

full_name: CategoryTheory.Limits.pullbackConeOfRightIso_snd
code: @[simp]
theorem pullbackConeOfRightIso_snd : (pullbackConeOfRightIso f g).snd = f ≫ inv g 
goal: (CategoryTheory.Limits.pullbackConeOfRightIso f g).snd = f ≫ CategoryTheory.inv g

full_name: CategoryTheory.Limits.pullbackConeOfRightIso_π_app_none
code: theorem pullbackConeOfRightIso_π_app_none : (pullbackConeOfRightIso f g).π.app none = f 
goal: (CategoryTheory.Limits.pullbackConeOfRightIso f g).π.app none = f

full_name: CategoryTheory.Limits.pullbackConeOfRightIso_π_app_left
code: @[simp]
theorem pullbackConeOfRightIso_π_app_left : (pullbackConeOfRightIso f g).π.app left = 𝟙 _ 
goal: (CategoryTheory.Limits.pullbackConeOfRightIso f g).π.app CategoryTheory.Limits.WalkingCospan.left =
  𝟙
    (((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingCospan).obj
          (CategoryTheory.Limits.pullbackConeOfRightIso f g).pt).obj
      CategoryTheory.Limits.WalkingCospan.left)

full_name: CategoryTheory.Limits.pullbackConeOfRightIso_π_app_right
code: @[simp]
theorem pullbackConeOfRightIso_π_app_right : (pullbackConeOfRightIso f g).π.app right = f ≫ inv g 
goal: (CategoryTheory.Limits.pullbackConeOfRightIso f g).π.app CategoryTheory.Limits.WalkingCospan.right =
  f ≫ CategoryTheory.inv g

full_name: CategoryTheory.Limits.pullbackConeOfRightIsoIsLimit
code: /-- Verify that the constructed limit cone is indeed a limit. -/
def pullbackConeOfRightIsoIsLimit : IsLimit (pullbackConeOfRightIso f g) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.pullbackConeOfRightIso f g)

full_name: CategoryTheory.Limits.hasPullback_of_right_iso
code: theorem hasPullback_of_right_iso : HasPullback f g 
goal: CategoryTheory.Limits.HasPullback f g

full_name: CategoryTheory.Limits.pullback_snd_iso_of_right_iso
code: instance pullback_snd_iso_of_right_iso : IsIso (pullback.fst f g) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.pullback.fst f g)

full_name: CategoryTheory.Limits.pullback_inv_fst_snd_of_right_isIso
code: @[reassoc (attr := simp)]
lemma pullback_inv_fst_snd_of_right_isIso :
    inv (pullback.fst f g) ≫ pullback.snd f g = f ≫ inv g 
goal: CategoryTheory.inv (CategoryTheory.Limits.pullback.fst f g) ≫ CategoryTheory.Limits.pullback.snd f g =
  f ≫ CategoryTheory.inv g

full_name: CategoryTheory.Limits.pushoutCoconeOfLeftIso
code: /-- If `f : X ⟶ Y` is iso, then `Y ⨿[X] Z ≅ Z`. This is the explicit colimit cocone. -/
def pushoutCoconeOfLeftIso : PushoutCocone f g 
goal: CategoryTheory.Limits.PushoutCocone f g

full_name: CategoryTheory.Limits.pushoutCoconeOfLeftIso_x
code: @[simp]
theorem pushoutCoconeOfLeftIso_x : (pushoutCoconeOfLeftIso f g).pt = Z 
goal: (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g).pt = Z

full_name: CategoryTheory.Limits.pushoutCoconeOfLeftIso_inl
code: @[simp]
theorem pushoutCoconeOfLeftIso_inl : (pushoutCoconeOfLeftIso f g).inl = inv f ≫ g 
goal: (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g).inl = CategoryTheory.inv f ≫ g

full_name: CategoryTheory.Limits.pushoutCoconeOfLeftIso_inr
code: @[simp]
theorem pushoutCoconeOfLeftIso_inr : (pushoutCoconeOfLeftIso f g).inr = 𝟙 _ 
goal: (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g).inr = 𝟙 Z

full_name: CategoryTheory.Limits.pushoutCoconeOfLeftIso_ι_app_none
code: theorem pushoutCoconeOfLeftIso_ι_app_none : (pushoutCoconeOfLeftIso f g).ι.app none = g 
goal: (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g).ι.app none = g

full_name: CategoryTheory.Limits.pushoutCoconeOfLeftIso_ι_app_left
code: @[simp]
theorem pushoutCoconeOfLeftIso_ι_app_left : (pushoutCoconeOfLeftIso f g).ι.app left = inv f ≫ g 
goal: (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g).ι.app CategoryTheory.Limits.WalkingSpan.left =
  CategoryTheory.inv f ≫ g

full_name: CategoryTheory.Limits.pushoutCoconeOfLeftIso_ι_app_right
code: @[simp]
theorem pushoutCoconeOfLeftIso_ι_app_right : (pushoutCoconeOfLeftIso f g).ι.app right = 𝟙 _ 
goal: (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g).ι.app CategoryTheory.Limits.WalkingSpan.right =
  𝟙 ((CategoryTheory.Limits.span f g).obj CategoryTheory.Limits.WalkingSpan.right)

full_name: CategoryTheory.Limits.pushoutCoconeOfLeftIsoIsLimit
code: /-- Verify that the constructed cocone is indeed a colimit. -/
def pushoutCoconeOfLeftIsoIsLimit : IsColimit (pushoutCoconeOfLeftIso f g) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g)

full_name: CategoryTheory.Limits.hasPushout_of_left_iso
code: theorem hasPushout_of_left_iso : HasPushout f g 
goal: CategoryTheory.Limits.HasPushout f g

full_name: CategoryTheory.Limits.pushout_inr_iso_of_left_iso
code: instance pushout_inr_iso_of_left_iso : IsIso (pushout.inr f g) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.pushout.inr f g)

full_name: CategoryTheory.Limits.pushout_inl_inv_inr_of_right_isIso
code: @[reassoc (attr := simp)]
lemma pushout_inl_inv_inr_of_right_isIso :
    pushout.inl f g ≫ inv (pushout.inr f g) = inv f ≫ g 
goal: CategoryTheory.Limits.pushout.inl f g ≫ CategoryTheory.inv (CategoryTheory.Limits.pushout.inr f g) =
  CategoryTheory.inv f ≫ g

full_name: CategoryTheory.Limits.pushoutCoconeOfRightIso
code: /-- If `f : X ⟶ Z` is iso, then `Y ⨿[X] Z ≅ Y`. This is the explicit colimit cocone. -/
def pushoutCoconeOfRightIso : PushoutCocone f g 
goal: CategoryTheory.Limits.PushoutCocone f g

full_name: CategoryTheory.Limits.pushoutCoconeOfRightIso_x
code: @[simp]
theorem pushoutCoconeOfRightIso_x : (pushoutCoconeOfRightIso f g).pt = Y 
goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).pt = Y

full_name: CategoryTheory.Limits.pushoutCoconeOfRightIso_inl
code: @[simp]
theorem pushoutCoconeOfRightIso_inl : (pushoutCoconeOfRightIso f g).inl = 𝟙 _ 
goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).inl = 𝟙 Y

full_name: CategoryTheory.Limits.pushoutCoconeOfRightIso_inr
code: @[simp]
theorem pushoutCoconeOfRightIso_inr : (pushoutCoconeOfRightIso f g).inr = inv g ≫ f 
goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).inr = CategoryTheory.inv g ≫ f

full_name: CategoryTheory.Limits.pushoutCoconeOfRightIso_ι_app_none
code: theorem pushoutCoconeOfRightIso_ι_app_none : (pushoutCoconeOfRightIso f g).ι.app none = f 
goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).ι.app none = f

full_name: CategoryTheory.Limits.pushoutCoconeOfRightIso_ι_app_left
code: @[simp]
theorem pushoutCoconeOfRightIso_ι_app_left : (pushoutCoconeOfRightIso f g).ι.app left = 𝟙 _ 
goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).ι.app CategoryTheory.Limits.WalkingSpan.left =
  𝟙 ((CategoryTheory.Limits.span f g).obj CategoryTheory.Limits.WalkingSpan.left)

full_name: CategoryTheory.Limits.pushoutCoconeOfRightIso_ι_app_right
code: @[simp]
theorem pushoutCoconeOfRightIso_ι_app_right :
    (pushoutCoconeOfRightIso f g).ι.app right = inv g ≫ f 
goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).ι.app CategoryTheory.Limits.WalkingSpan.right =
  CategoryTheory.inv g ≫ f

full_name: CategoryTheory.Limits.pushoutCoconeOfRightIsoIsLimit
code: /-- Verify that the constructed cocone is indeed a colimit. -/
def pushoutCoconeOfRightIsoIsLimit : IsColimit (pushoutCoconeOfRightIso f g) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.pushoutCoconeOfRightIso f g)

full_name: CategoryTheory.Limits.hasPushout_of_right_iso
code: theorem hasPushout_of_right_iso : HasPushout f g 
goal: CategoryTheory.Limits.HasPushout f g

full_name: CategoryTheory.Limits.pushout_inl_iso_of_right_iso
code: instance pushout_inl_iso_of_right_iso : IsIso (pushout.inl _ _ : _ ⟶ pushout f g) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.pushout.inl f g)

full_name: CategoryTheory.Limits.pushout_inr_inv_inl_of_right_isIso
code: @[reassoc (attr := simp)]
lemma pushout_inr_inv_inl_of_right_isIso :
    pushout.inr f g ≫ inv (pushout.inl f g) = inv g ≫ f 
goal: CategoryTheory.Limits.pushout.inr f g ≫ CategoryTheory.inv (CategoryTheory.Limits.pushout.inl f g) =
  CategoryTheory.inv g ≫ f