ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.IsZero.obj
theorem IsZero.obj [HasZeroObject D] {F : C ⥤ D} (hF : IsZero F) (X : C) : IsZero (F.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] [CategoryTheory.Limits.HasZeroObject D] {F : C ⥤ D} (hF : CategoryTheory.Limits.IsZero F) (X : C)
Goal: CategoryTheory.Limits.IsZero (F.obj X)
-- CategoryTheory.Limits.HasZeroObject.to_zero_ext
@[ext]
theorem to_zero_ext {X : C} (f g : X ⟶ 0) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] {X : C} (f g : X ⟶ 0)
Goal: f = g
-- CategoryTheory.Limits.HasZeroObject.from_zero_ext
@[ext]
theorem from_zero_ext {X : C} (f g : 0 ⟶ X) : f = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasZeroObject C] {X : C} (f g : 0 ⟶ X)
Goal: f = g
-- CategoryTheory.Functor.isZero_iff
theorem Functor.isZero_iff [HasZeroObject D] (F : C ⥤ D) : IsZero F ↔ ∀ X, IsZero (F.obj X) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] [CategoryTheory.Limits.HasZeroObject D] (F : C ⥤ D)
Goal: CategoryTheory.Limits.IsZero F ↔ ∀ (X : C), CategoryTheory.Limits.IsZero (F.obj X)
-- CategoryTheory.CategoryOfElements.CreatesLimitsAux.π_liftedConeElement'
@[simp]
lemma π_liftedConeElement' (i : I) :
    limit.π ((F ⋙ π A) ⋙ A) i (liftedConeElement' F) = (F.obj i).2 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor C (Type w)} {I : Type u₁} [CategoryTheory.Category.{v₁, u₁} I] [Small.{w, u₁} I] (F : CategoryTheory.Functor I A.Elements) (i : I)
Goal: CategoryTheory.Limits.limit.π ((F.comp (CategoryTheory.CategoryOfElements.π A)).comp A) i
    (CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedConeElement' F) =
  (F.obj i).snd
-- CategoryTheory.CategoryOfElements.CreatesLimitsAux.map_lift_mapCone
@[simp]
lemma map_lift_mapCone (c : Cone F) :
    A.map (limit.lift (F ⋙ π A) ((π A).mapCone c)) c.pt.snd = liftedConeElement F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor C (Type w)} {I : Type u₁} [CategoryTheory.Category.{v₁, u₁} I] [Small.{w, u₁} I] (F : CategoryTheory.Functor I A.Elements) [CategoryTheory.Limits.HasLimitsOfShape I C] [CategoryTheory.Limits.PreservesLimitsOfShape I A] (c : CategoryTheory.Limits.Cone F)
Goal: A.map
    (CategoryTheory.Limits.limit.lift (F.comp (CategoryTheory.CategoryOfElements.π A))
      ((CategoryTheory.CategoryOfElements.π A).mapCone c))
    c.pt.snd =
  CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedConeElement F
-- CategoryTheory.CategoryOfElements.CreatesLimitsAux.map_π_liftedConeElement
@[simp]
lemma map_π_liftedConeElement (i : I) :
    A.map (limit.π (F ⋙ π A) i) (liftedConeElement F) = (F.obj i).snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor C (Type w)} {I : Type u₁} [CategoryTheory.Category.{v₁, u₁} I] [Small.{w, u₁} I] (F : CategoryTheory.Functor I A.Elements) [CategoryTheory.Limits.HasLimitsOfShape I C] [CategoryTheory.Limits.PreservesLimitsOfShape I A] (i : I)
Goal: A.map (CategoryTheory.Limits.limit.π (F.comp (CategoryTheory.CategoryOfElements.π A)) i)
    (CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedConeElement F) =
  (F.obj i).snd
-- CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone_π_app_coe
@[simps]
noncomputable def liftedCone : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor C (Type w)} {I : Type u₁} [CategoryTheory.Category.{v₁, u₁} I] [Small.{w, u₁} I] (F : CategoryTheory.Functor I A.Elements) [CategoryTheory.Limits.HasLimitsOfShape I C] [CategoryTheory.Limits.PreservesLimitsOfShape I A] (i : I)
Goal: ↑((CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone F).π.app i) =
  CategoryTheory.Limits.limit.π (F.comp (CategoryTheory.CategoryOfElements.π A)) i
-- CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone_pt_fst
@[simps]
noncomputable def liftedCone : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor C (Type w)} {I : Type u₁} [CategoryTheory.Category.{v₁, u₁} I] [Small.{w, u₁} I] (F : CategoryTheory.Functor I A.Elements) [CategoryTheory.Limits.HasLimitsOfShape I C] [CategoryTheory.Limits.PreservesLimitsOfShape I A]
Goal: (CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone F).pt.fst =
  CategoryTheory.Limits.limit (F.comp (CategoryTheory.CategoryOfElements.π A))
-- CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone_pt_snd
@[simps]
noncomputable def liftedCone : Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor C (Type w)} {I : Type u₁} [CategoryTheory.Category.{v₁, u₁} I] [Small.{w, u₁} I] (F : CategoryTheory.Functor I A.Elements) [CategoryTheory.Limits.HasLimitsOfShape I C] [CategoryTheory.Limits.PreservesLimitsOfShape I A]
Goal: (CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone F).pt.snd =
  CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedConeElement F
-- CategoryTheory.CommSq.cone_fst
@[simp]
theorem cone_fst (s : CommSq f g h i) : s.cone.fst = f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (s : CategoryTheory.CommSq f g h i)
Goal: s.cone.fst = f
-- CategoryTheory.CommSq.cone_snd
@[simp]
theorem cone_snd (s : CommSq f g h i) : s.cone.snd = g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (s : CategoryTheory.CommSq f g h i)
Goal: s.cone.snd = g
-- CategoryTheory.CommSq.cocone_inl
@[simp]
theorem cocone_inl (s : CommSq f g h i) : s.cocone.inl = h 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (s : CategoryTheory.CommSq f g h i)
Goal: s.cocone.inl = h
-- CategoryTheory.CommSq.cocone_inr
@[simp]
theorem cocone_inr (s : CommSq f g h i) : s.cocone.inr = i 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z} (s : CategoryTheory.CommSq f g h i)
Goal: s.cocone.inr = i
-- CategoryTheory.IsPullback.isLimit'
structure IsPullback {P X Y Z : C} (fst : P ⟶ X) (snd : P ⟶ Y) (f : X ⟶ Z) (g : Y ⟶ Z) extends
  CommSq fst snd f g : Prop where
    isLimit' : Nonempty (IsLimit (PullbackCone.mk _ _ w))
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (self : CategoryTheory.IsPullback fst snd f g)
Goal: Nonempty (CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.PullbackCone.mk fst snd ⋯))
-- CategoryTheory.IsPushout.isColimit'
structure IsPushout {Z X Y P : C} (f : Z ⟶ X) (g : Z ⟶ Y) (inl : X ⟶ P) (inr : Y ⟶ P) extends
  CommSq f g inl inr : Prop where
    isColimit' : Nonempty (IsColimit (PushoutCocone.mk _ _ w))
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P} (self : CategoryTheory.IsPushout f g inl inr)
Goal: Nonempty (CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.PushoutCocone.mk inl inr ⋯))
-- CategoryTheory.IsPullback.cone_fst
@[simp]
theorem cone_fst (h : IsPullback fst snd f g) : h.cone.fst = fst 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (h : CategoryTheory.IsPullback fst snd f g)
Goal: h.cone.fst = fst
-- CategoryTheory.IsPullback.cone_snd
@[simp]
theorem cone_snd (h : IsPullback fst snd f g) : h.cone.snd = snd 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (h : CategoryTheory.IsPullback fst snd f g)
Goal: h.cone.snd = snd
-- CategoryTheory.IsPullback.lift_fst
@[reassoc (attr := simp)]
lemma lift_fst (hP : IsPullback fst snd f g) {W : C} (h : W ⟶ X) (k : W ⟶ Y)
    (w : h ≫ f = k ≫ g) : hP.lift h k w ≫ fst = h 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (hP : CategoryTheory.IsPullback fst snd f g) {W : C} (h : W ⟶ X) (k : W ⟶ Y) (w : h ≫ f = k ≫ g)
Goal: hP.lift h k w ≫ fst = h
-- CategoryTheory.IsPullback.lift_snd
@[reassoc (attr := simp)]
lemma lift_snd (hP : IsPullback fst snd f g) {W : C} (h : W ⟶ X) (k : W ⟶ Y)
    (w : h ≫ f = k ≫ g) : hP.lift h k w ≫ snd = k 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (hP : CategoryTheory.IsPullback fst snd f g) {W : C} (h : W ⟶ X) (k : W ⟶ Y) (w : h ≫ f = k ≫ g)
Goal: hP.lift h k w ≫ snd = k
-- CategoryTheory.IsPullback.hom_ext
lemma hom_ext (hP : IsPullback fst snd f g) {W : C} {k l : W ⟶ P}
    (h₀ : k ≫ fst = l ≫ fst) (h₁ : k ≫ snd = l ≫ snd) : k = l 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (hP : CategoryTheory.IsPullback fst snd f g) {W : C} {k l : W ⟶ P} (h₀ : k ≫ fst = l ≫ fst) (h₁ : k ≫ snd = l ≫ snd)
Goal: k = l
-- CategoryTheory.IsPullback.of_isLimit
theorem of_isLimit {c : PullbackCone f g} (h : Limits.IsLimit c) : IsPullback c.fst c.snd f g 
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} (h : CategoryTheory.Limits.IsLimit c)
Goal: CategoryTheory.IsPullback c.fst c.snd f g
-- CategoryTheory.IsPullback.of_isLimit'
theorem of_isLimit' (w : CommSq fst snd f g) (h : Limits.IsLimit w.cone) :
    IsPullback fst snd f g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (w : CategoryTheory.CommSq fst snd f g) (h : CategoryTheory.Limits.IsLimit w.cone)
Goal: CategoryTheory.IsPullback fst snd f g
-- CategoryTheory.IsPullback.of_hasPullback
theorem of_hasPullback (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g] :
    IsPullback (pullback.fst f g) (pullback.snd f g) f g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasPullback f g]
Goal: CategoryTheory.IsPullback (CategoryTheory.Limits.pullback.fst f g) (CategoryTheory.Limits.pullback.snd f g) f g
-- CategoryTheory.IsPullback.of_is_product
theorem of_is_product {c : BinaryFan X Y} (h : Limits.IsLimit c) (t : IsTerminal Z) :
    IsPullback c.fst c.snd (t.from _) (t.from _) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {c : CategoryTheory.Limits.BinaryFan X Y} (h : CategoryTheory.Limits.IsLimit c) (t : CategoryTheory.Limits.IsTerminal Z)
Goal: CategoryTheory.IsPullback c.fst c.snd
  (t.from ((CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.left }))
  (t.from ((CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.right }))
-- CategoryTheory.IsPullback.of_is_product'
theorem of_is_product' (h : Limits.IsLimit (BinaryFan.mk fst snd)) (t : IsTerminal Z) :
    IsPullback fst snd (t.from _) (t.from _) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} (h : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.BinaryFan.mk fst snd)) (t : CategoryTheory.Limits.IsTerminal Z)
Goal: CategoryTheory.IsPullback fst snd (t.from X) (t.from Y)
-- CategoryTheory.IsPullback.of_hasBinaryProduct'
theorem of_hasBinaryProduct' [HasBinaryProduct X Y] [HasTerminal C] :
    IsPullback Limits.prod.fst Limits.prod.snd (terminal.from X) (terminal.from Y) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X Y : C) [CategoryTheory.Limits.HasBinaryProduct X Y] [CategoryTheory.Limits.HasTerminal C]
Goal: CategoryTheory.IsPullback CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd
  (CategoryTheory.Limits.terminal.from X) (CategoryTheory.Limits.terminal.from Y)
-- CategoryTheory.IsPullback.of_hasBinaryProduct
theorem of_hasBinaryProduct [HasBinaryProduct X Y] [HasZeroObject C] [HasZeroMorphisms C] :
    IsPullback Limits.prod.fst Limits.prod.snd (0 : X ⟶ 0) (0 : Y ⟶ 0) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X Y : C) [CategoryTheory.Limits.HasBinaryProduct X Y] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C]
Goal: CategoryTheory.IsPullback CategoryTheory.Limits.prod.fst CategoryTheory.Limits.prod.snd 0 0
-- CategoryTheory.IsPullback.isoIsPullback_hom_fst
@[reassoc (attr := simp)]
theorem isoIsPullback_hom_fst (h : IsPullback fst snd f g) (h' : IsPullback fst' snd' f g) :
    (h.isoIsPullback h').hom ≫ fst' = fst 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : C} (X Y : C) {Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} {P' : C} {fst' : P' ⟶ X} {snd' : P' ⟶ Y} (h : CategoryTheory.IsPullback fst snd f g) (h' : CategoryTheory.IsPullback fst' snd' f g)
Goal: (CategoryTheory.IsPullback.isoIsPullback X Y h h').hom ≫ fst' = fst
-- CategoryTheory.IsPullback.isoIsPullback_hom_snd
@[reassoc (attr := simp)]
theorem isoIsPullback_hom_snd (h : IsPullback fst snd f g) (h' : IsPullback fst' snd' f g) :
    (h.isoIsPullback h').hom ≫ snd' = snd 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : C} (X Y : C) {Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} {P' : C} {fst' : P' ⟶ X} {snd' : P' ⟶ Y} (h : CategoryTheory.IsPullback fst snd f g) (h' : CategoryTheory.IsPullback fst' snd' f g)
Goal: (CategoryTheory.IsPullback.isoIsPullback X Y h h').hom ≫ snd' = snd
-- CategoryTheory.IsPullback.isoIsPullback_inv_fst
@[reassoc (attr := simp)]
theorem isoIsPullback_inv_fst (h : IsPullback fst snd f g) (h' : IsPullback fst' snd' f g) :
    (h.isoIsPullback h').inv ≫ fst = fst' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : C} (X Y : C) {Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} {P' : C} {fst' : P' ⟶ X} {snd' : P' ⟶ Y} (h : CategoryTheory.IsPullback fst snd f g) (h' : CategoryTheory.IsPullback fst' snd' f g)
Goal: (CategoryTheory.IsPullback.isoIsPullback X Y h h').inv ≫ fst = fst'
-- CategoryTheory.IsPullback.isoIsPullback_inv_snd
@[reassoc (attr := simp)]
theorem isoIsPullback_inv_snd (h : IsPullback fst snd f g) (h' : IsPullback fst' snd' f g) :
    (h.isoIsPullback h').inv ≫ snd = snd' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P : C} (X Y : C) {Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} {P' : C} {fst' : P' ⟶ X} {snd' : P' ⟶ Y} (h : CategoryTheory.IsPullback fst snd f g) (h' : CategoryTheory.IsPullback fst' snd' f g)
Goal: (CategoryTheory.IsPullback.isoIsPullback X Y h h').inv ≫ snd = snd'
-- CategoryTheory.IsPullback.isoPullback_hom_fst
@[reassoc (attr := simp)]
theorem isoPullback_hom_fst (h : IsPullback fst snd f g) [HasPullback f g] :
    h.isoPullback.hom ≫ pullback.fst _ _ = fst 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (h : CategoryTheory.IsPullback fst snd f g) [CategoryTheory.Limits.HasPullback f g]
Goal: h.isoPullback.hom ≫ CategoryTheory.Limits.pullback.fst f g = fst
-- CategoryTheory.IsPullback.isoPullback_hom_snd
@[reassoc (attr := simp)]
theorem isoPullback_hom_snd (h : IsPullback fst snd f g) [HasPullback f g] :
    h.isoPullback.hom ≫ pullback.snd _ _ = snd 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (h : CategoryTheory.IsPullback fst snd f g) [CategoryTheory.Limits.HasPullback f g]
Goal: h.isoPullback.hom ≫ CategoryTheory.Limits.pullback.snd f g = snd
-- CategoryTheory.IsPullback.isoPullback_inv_fst
@[reassoc (attr := simp)]
theorem isoPullback_inv_fst (h : IsPullback fst snd f g) [HasPullback f g] :
    h.isoPullback.inv ≫ fst = pullback.fst _ _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (h : CategoryTheory.IsPullback fst snd f g) [CategoryTheory.Limits.HasPullback f g]
Goal: h.isoPullback.inv ≫ fst = CategoryTheory.Limits.pullback.fst f g
-- CategoryTheory.IsPullback.isoPullback_inv_snd
@[reassoc (attr := simp)]
theorem isoPullback_inv_snd (h : IsPullback fst snd f g) [HasPullback f g] :
    h.isoPullback.inv ≫ snd = pullback.snd _ _ 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (h : CategoryTheory.IsPullback fst snd f g) [CategoryTheory.Limits.HasPullback f g]
Goal: h.isoPullback.inv ≫ snd = CategoryTheory.Limits.pullback.snd f g
-- CategoryTheory.IsPullback.of_iso_pullback
theorem of_iso_pullback (h : CommSq fst snd f g) [HasPullback f g] (i : P ≅ pullback f g)
    (w₁ : i.hom ≫ pullback.fst _ _ = fst) (w₂ : i.hom ≫ pullback.snd _ _ = snd) :
      IsPullback fst snd f g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (h : CategoryTheory.CommSq fst snd f g) [CategoryTheory.Limits.HasPullback f g] (i : P ≅ CategoryTheory.Limits.pullback f g) (w₁ : i.hom ≫ CategoryTheory.Limits.pullback.fst f g = fst) (w₂ : i.hom ≫ CategoryTheory.Limits.pullback.snd f g = snd)
Goal: CategoryTheory.IsPullback fst snd f g
-- CategoryTheory.IsPullback.of_horiz_isIso
theorem of_horiz_isIso [IsIso fst] [IsIso g] (sq : CommSq fst snd f g) : IsPullback fst snd f g 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} [CategoryTheory.IsIso fst] [CategoryTheory.IsIso g] (sq : CategoryTheory.CommSq fst snd f g)
Goal: CategoryTheory.IsPullback fst snd f g
-- CategoryTheory.IsPullback.of_iso
lemma of_iso (h : IsPullback fst snd f g)
    {P' X' Y' Z' : C} {fst' : P' ⟶ X'} {snd' : P' ⟶ Y'} {f' : X' ⟶ Z'} {g' : Y' ⟶ Z'}
    (e₁ : P ≅ P') (e₂ : X ≅ X') (e₃ : Y ≅ Y') (e₄ : Z ≅ Z')
    (commfst : fst ≫ e₂.hom = e₁.hom ≫ fst')
    (commsnd : snd ≫ e₃.hom = e₁.hom ≫ snd')
    (commf : f ≫ e₄.hom = e₂.hom ≫ f')
    (commg : g ≫ e₄.hom = e₃.hom ≫ g') :
    IsPullback fst' snd' f' g' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {P X Y Z : C} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z} (h : CategoryTheory.IsPullback fst snd f g) {P' X' Y' Z' : C} {fst' : P' ⟶ X'} {snd' : P' ⟶ Y'} {f' : X' ⟶ Z'} {g' : Y' ⟶ Z'} (e₁ : P ≅ P') (e₂ : X ≅ X') (e₃ : Y ≅ Y') (e₄ : Z ≅ Z') (commfst : fst ≫ e₂.hom = e₁.hom ≫ fst') (commsnd : snd ≫ e₃.hom = e₁.hom ≫ snd') (commf : f ≫ e₄.hom = e₂.hom ≫ f') (commg : g ≫ e₄.hom = e₃.hom ≫ g')
Goal: CategoryTheory.IsPullback fst' snd' f' g'
-- CategoryTheory.IsPushout.cocone_inl
@[simp]
theorem cocone_inl (h : IsPushout f g inl inr) : h.cocone.inl = inl 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P} (h : CategoryTheory.IsPushout f g inl inr)
Goal: h.cocone.inl = inl
-- CategoryTheory.IsPushout.cocone_inr
@[simp]
theorem cocone_inr (h : IsPushout f g inl inr) : h.cocone.inr = inr 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P} (h : CategoryTheory.IsPushout f g inl inr)
Goal: h.cocone.inr = inr
-- CategoryTheory.IsPushout.inl_desc
@[reassoc (attr := simp)]
lemma inl_desc (hP : IsPushout f g inl inr) {W : C} (h : X ⟶ W) (k : Y ⟶ W)
    (w : f ≫ h = g ≫ k) : inl ≫ hP.desc h k w = h 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P} (hP : CategoryTheory.IsPushout f g inl inr) {W : C} (h : X ⟶ W) (k : Y ⟶ W) (w : f ≫ h = g ≫ k)
Goal: inl ≫ hP.desc h k w = h
-- CategoryTheory.IsPushout.inr_desc
@[reassoc (attr := simp)]
lemma inr_desc (hP : IsPushout f g inl inr) {W : C} (h : X ⟶ W) (k : Y ⟶ W)
    (w : f ≫ h = g ≫ k) : inr ≫ hP.desc h k w = k 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P} (hP : CategoryTheory.IsPushout f g inl inr) {W : C} (h : X ⟶ W) (k : Y ⟶ W) (w : f ≫ h = g ≫ k)
Goal: inr ≫ hP.desc h k w = k
-- CategoryTheory.IsPushout.hom_ext
lemma hom_ext (hP : IsPushout f g inl inr) {W : C} {k l : P ⟶ W}
    (h₀ : inl ≫ k = inl ≫ l) (h₁ : inr ≫ k = inr ≫ l) : k = l 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P} (hP : CategoryTheory.IsPushout f g inl inr) {W : C} {k l : P ⟶ W} (h₀ : inl ≫ k = inl ≫ l) (h₁ : inr ≫ k = inr ≫ l)
Goal: k = l
-- CategoryTheory.IsPushout.of_isColimit
theorem of_isColimit {c : PushoutCocone f g} (h : Limits.IsColimit c) : IsPushout f g c.inl c.inr 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y : C} {f : Z ⟶ X} {g : Z ⟶ Y} {c : CategoryTheory.Limits.PushoutCocone f g} (h : CategoryTheory.Limits.IsColimit c)
Goal: CategoryTheory.IsPushout f g c.inl c.inr
-- CategoryTheory.IsPushout.of_isColimit'
theorem of_isColimit' (w : CommSq f g inl inr) (h : Limits.IsColimit w.cocone) :
    IsPushout f g inl inr 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P} (w : CategoryTheory.CommSq f g inl inr) (h : CategoryTheory.Limits.IsColimit w.cocone)
Goal: CategoryTheory.IsPushout f g inl inr
-- CategoryTheory.IsPushout.of_hasPushout
theorem of_hasPushout (f : Z ⟶ X) (g : Z ⟶ Y) [HasPushout f g] :
    IsPushout f g (pushout.inl f g) (pushout.inr f g) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y : C} (f : Z ⟶ X) (g : Z ⟶ Y) [CategoryTheory.Limits.HasPushout f g]
Goal: CategoryTheory.IsPushout f g (CategoryTheory.Limits.pushout.inl f g) (CategoryTheory.Limits.pushout.inr f g)
-- CategoryTheory.IsPushout.of_is_coproduct
theorem of_is_coproduct {c : BinaryCofan X Y} (h : Limits.IsColimit c) (t : IsInitial Z) :
    IsPushout (t.to _) (t.to _) c.inl c.inr 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y : C} {c : CategoryTheory.Limits.BinaryCofan X Y} (h : CategoryTheory.Limits.IsColimit c) (t : CategoryTheory.Limits.IsInitial Z)
Goal: CategoryTheory.IsPushout (t.to ((CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.left }))
  (t.to ((CategoryTheory.Limits.pair X Y).obj { as := CategoryTheory.Limits.WalkingPair.right })) c.inl c.inr
-- CategoryTheory.IsPushout.of_is_coproduct'
theorem of_is_coproduct' (h : Limits.IsColimit (BinaryCofan.mk inl inr)) (t : IsInitial Z) :
    IsPushout (t.to _) (t.to _) inl inr 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {inl : X ⟶ P} {inr : Y ⟶ P} (h : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk inl inr)) (t : CategoryTheory.Limits.IsInitial Z)
Goal: CategoryTheory.IsPushout (t.to X) (t.to Y) inl inr
-- CategoryTheory.IsPushout.of_hasBinaryCoproduct'
theorem of_hasBinaryCoproduct' [HasBinaryCoproduct X Y] [HasInitial C] :
    IsPushout (initial.to _) (initial.to _) (coprod.inl : X ⟶ _) (coprod.inr : Y ⟶ _) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X Y : C) [CategoryTheory.Limits.HasBinaryCoproduct X Y] [CategoryTheory.Limits.HasInitial C]
Goal: CategoryTheory.IsPushout (CategoryTheory.Limits.initial.to X) (CategoryTheory.Limits.initial.to Y)
  CategoryTheory.Limits.coprod.inl CategoryTheory.Limits.coprod.inr
-- CategoryTheory.IsPushout.of_hasBinaryCoproduct
theorem of_hasBinaryCoproduct [HasBinaryCoproduct X Y] [HasZeroObject C] [HasZeroMorphisms C] :
    IsPushout (0 : 0 ⟶ X) (0 : 0 ⟶ Y) coprod.inl coprod.inr 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (X Y : C) [CategoryTheory.Limits.HasBinaryCoproduct X Y] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroMorphisms C]
Goal: CategoryTheory.IsPushout 0 0 CategoryTheory.Limits.coprod.inl CategoryTheory.Limits.coprod.inr
-- CategoryTheory.IsPushout.inl_isoIsPushout_hom
@[reassoc (attr := simp)]
theorem inl_isoIsPushout_hom (h : IsPushout f g inl inr) (h' : IsPushout f g inl' inr') :
    inl ≫ (h.isoIsPushout h').hom = inl' 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {Z : C} (X Y : C) {P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P} {P' : C} {inl' : X ⟶ P'} {inr' : Y ⟶ P'} (h : CategoryTheory.IsPushout f g inl inr) (h' : CategoryTheory.IsPushout f g inl' inr')
Goal: inl ≫ (CategoryTheory.IsPushout.isoIsPushout X Y h h').hom = inl'