ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_hom
@[simp]
theorem colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_hom {j} {k} :
    colimit.ι _ j ≫ colimit.ι (curry.obj (Prod.swap K J ⋙ G) ⋙ colim) k ≫
      (colimitCurrySwapCompColimIsoColimitCurryCompColim G).hom =
        (colimit.ι _ k ≫ colimit.ι (curry.obj G ⋙ colim) j : _ ⟶ colimit (curry.obj G⋙ colim)) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (G : J × K ⥤ C) [CategoryTheory.Limits.HasColimits C] {j : J} {k : K}
Goal: CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G)).obj k) j ≫
    CategoryTheory.Limits.colimit.ι
        (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G) ⋙ CategoryTheory.Limits.colim) k ≫
      (CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim G).hom =
  CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj G).obj j) k ≫
    CategoryTheory.Limits.colimit.ι (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim) j
-- CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_inv
@[simp]
theorem colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_inv {j} {k} :
    colimit.ι _ k ≫ colimit.ι (curry.obj G ⋙ colim) j ≫
      (colimitCurrySwapCompColimIsoColimitCurryCompColim G).inv =
        (colimit.ι _ j ≫
          colimit.ι (curry.obj _ ⋙ colim) k :
            _ ⟶ colimit (curry.obj (Prod.swap K J ⋙ G) ⋙ colim)) 
Arguments: {J K : Type v} [CategoryTheory.SmallCategory J] [CategoryTheory.SmallCategory K] {C : Type u} [CategoryTheory.Category.{v, u} C] (G : J × K ⥤ C) [CategoryTheory.Limits.HasColimits C] {j : J} {k : K}
Goal: CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj G).obj j) k ≫
    CategoryTheory.Limits.colimit.ι (CategoryTheory.curry.obj G ⋙ CategoryTheory.Limits.colim) j ≫
      (CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim G).inv =
  CategoryTheory.Limits.colimit.ι ((CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G)).obj k) j ≫
    CategoryTheory.Limits.colimit.ι
      (CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ G) ⋙ CategoryTheory.Limits.colim) k
-- CategoryTheory.Limits.PullbackCone.fst_limit_cone
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.cospan f g)]
Goal: CategoryTheory.Limits.PullbackCone.fst (CategoryTheory.Limits.limit.cone (CategoryTheory.Limits.cospan f g)) =
  CategoryTheory.Limits.pullback.fst f g
-- CategoryTheory.Limits.PullbackCone.snd_limit_cone
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.cospan f g)]
Goal: CategoryTheory.Limits.PullbackCone.snd (CategoryTheory.Limits.limit.cone (CategoryTheory.Limits.cospan f g)) =
  CategoryTheory.Limits.pullback.snd f g
-- CategoryTheory.Limits.PushoutCocone.inl_colimit_cocone
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 _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : Z ⟶ X) (g : Z ⟶ Y) [CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.span f g)]
Goal: CategoryTheory.Limits.PushoutCocone.inl (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Limits.span f g)) =
  CategoryTheory.Limits.pushout.inl f g
-- CategoryTheory.Limits.PushoutCocone.inr_colimit_cocone
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 _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : Z ⟶ X) (g : Z ⟶ Y) [CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.span f g)]
Goal: CategoryTheory.Limits.PushoutCocone.inr (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Limits.span f g)) =
  CategoryTheory.Limits.pushout.inr f g
-- CategoryTheory.Limits.pullback.lift_fst
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} [CategoryTheory.Limits.HasPullback f g] (h : W ⟶ X) (k : W ⟶ Y) (w : h ≫ f = k ≫ g)
Goal: CategoryTheory.Limits.pullback.lift h k w ≫ CategoryTheory.Limits.pullback.fst f g = h
-- CategoryTheory.Limits.pullback.lift_snd
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} [CategoryTheory.Limits.HasPullback f g] (h : W ⟶ X) (k : W ⟶ Y) (w : h ≫ f = k ≫ g)
Goal: CategoryTheory.Limits.pullback.lift h k w ≫ CategoryTheory.Limits.pullback.snd f g = k
-- CategoryTheory.Limits.pushout.inl_desc
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [CategoryTheory.Limits.HasPushout f g] (h : Y ⟶ W) (k : Z ⟶ W) (w : f ≫ h = g ≫ k)
Goal: CategoryTheory.Limits.pushout.inl f g ≫ CategoryTheory.Limits.pushout.desc h k w = h
-- CategoryTheory.Limits.pushout.inr_desc
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [CategoryTheory.Limits.HasPushout f g] (h : Y ⟶ W) (k : Z ⟶ W) (w : f ≫ h = g ≫ k)
Goal: CategoryTheory.Limits.pushout.inr f g ≫ CategoryTheory.Limits.pushout.desc h k w = k
-- CategoryTheory.Limits.pullback.condition
@[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 
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.Limits.pullback.fst f g ≫ f = CategoryTheory.Limits.pullback.snd f g ≫ g
-- CategoryTheory.Limits.pushout.condition
@[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 _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [CategoryTheory.Limits.HasPushout f g]
Goal: f ≫ CategoryTheory.Limits.pushout.inl f g = g ≫ CategoryTheory.Limits.pushout.inr f g
-- CategoryTheory.Limits.pullback.hom_ext
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} [CategoryTheory.Limits.HasPullback f g] {W : C} {k l : W ⟶ CategoryTheory.Limits.pullback f g} (h₀ : k ≫ CategoryTheory.Limits.pullback.fst f g = l ≫ CategoryTheory.Limits.pullback.fst f g) (h₁ : k ≫ CategoryTheory.Limits.pullback.snd f g = l ≫ CategoryTheory.Limits.pullback.snd f g)
Goal: k = l
-- CategoryTheory.Limits.pushout.hom_ext
@[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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [CategoryTheory.Limits.HasPushout f g] {W : C} {k l : CategoryTheory.Limits.pushout f g ⟶ W} (h₀ : CategoryTheory.Limits.pushout.inl f g ≫ k = CategoryTheory.Limits.pushout.inl f g ≫ l) (h₁ : CategoryTheory.Limits.pushout.inr f g ≫ k = CategoryTheory.Limits.pushout.inr f g ≫ l)
Goal: k = l
-- CategoryTheory.Limits.pullback.map_comp
@[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]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {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'') [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback f' g'] [CategoryTheory.Limits.HasPullback f'' g''] (e₁ : f ≫ i₃ = i₁ ≫ f') (e₂ : g ≫ i₃ = i₂ ≫ g') (e₃ : f' ≫ j₃ = j₁ ≫ f'') (e₄ : g' ≫ j₃ = j₂ ≫ g'')
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₃) ⋯ ⋯
-- CategoryTheory.Limits.pullback.map_id
@[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) = 𝟙 _ 
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.Limits.pullback.map f g f g (𝟙 X) (𝟙 Y) (𝟙 Z) ⋯ ⋯ = 𝟙 (CategoryTheory.Limits.pullback f g)
-- CategoryTheory.Limits.pushout.map_comp
@[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]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {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'') [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPushout f' g'] [CategoryTheory.Limits.HasPushout f'' g''] (e₁ : f ≫ i₂ = i₁ ≫ f') (e₂ : g ≫ i₃ = i₁ ≫ g') (e₃ : f' ≫ j₂ = j₁ ≫ f'') (e₄ : g' ≫ j₃ = j₁ ≫ g'')
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₁) ⋯ ⋯
-- CategoryTheory.Limits.pushout.map_id
@[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) = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [CategoryTheory.Limits.HasPushout f g]
Goal: CategoryTheory.Limits.pushout.map f g f g (𝟙 Y) (𝟙 Z) (𝟙 X) ⋯ ⋯ = 𝟙 (CategoryTheory.Limits.pushout f g)
-- CategoryTheory.Limits.pullback.congrHom_hom
@[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₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f₁ f₂ : X ⟶ Z} {g₁ g₂ : Y ⟶ Z} (h₁ : f₁ = f₂) (h₂ : g₁ = g₂) [CategoryTheory.Limits.HasPullback f₁ g₁] [CategoryTheory.Limits.HasPullback f₂ g₂]
Goal: (CategoryTheory.Limits.pullback.congrHom h₁ h₂).hom =
  CategoryTheory.Limits.pullback.map f₁ g₁ f₂ g₂ (𝟙 X) (𝟙 Y) (𝟙 Z) ⋯ ⋯
-- CategoryTheory.Limits.pullback.congrHom_inv
@[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₂]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f₁ f₂ : X ⟶ Z} {g₁ g₂ : Y ⟶ Z} (h₁ : f₁ = f₂) (h₂ : g₁ = g₂) [CategoryTheory.Limits.HasPullback f₁ g₁] [CategoryTheory.Limits.HasPullback f₂ g₂]
Goal: (CategoryTheory.Limits.pullback.congrHom h₁ h₂).inv =
  CategoryTheory.Limits.pullback.map f₂ g₂ f₁ g₁ (𝟙 X) (𝟙 Y) (𝟙 Z) ⋯ ⋯
-- CategoryTheory.Limits.pullback.mapDesc_comp
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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y S T S' : C} (f : X ⟶ T) (g : Y ⟶ T) (i : T ⟶ S) (i' : S ⟶ S') [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback (f ≫ i) (g ≫ i)] [CategoryTheory.Limits.HasPullback (f ≫ i ≫ i') (g ≫ i ≫ i')] [CategoryTheory.Limits.HasPullback ((f ≫ i) ≫ i') ((g ≫ i) ≫ i')]
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
-- CategoryTheory.Limits.pushout.congrHom_hom
@[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₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f₁ f₂ : X ⟶ Y} {g₁ g₂ : X ⟶ Z} (h₁ : f₁ = f₂) (h₂ : g₁ = g₂) [CategoryTheory.Limits.HasPushout f₁ g₁] [CategoryTheory.Limits.HasPushout f₂ g₂]
Goal: (CategoryTheory.Limits.pushout.congrHom h₁ h₂).hom = CategoryTheory.Limits.pushout.map f₁ g₁ f₂ g₂ (𝟙 Y) (𝟙 Z) (𝟙 X) ⋯ ⋯
-- CategoryTheory.Limits.pushout.congrHom_inv
@[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₂]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {f₁ f₂ : X ⟶ Y} {g₁ g₂ : X ⟶ Z} (h₁ : f₁ = f₂) (h₂ : g₁ = g₂) [CategoryTheory.Limits.HasPushout f₁ g₁] [CategoryTheory.Limits.HasPushout f₂ g₂]
Goal: (CategoryTheory.Limits.pushout.congrHom h₁ h₂).inv = CategoryTheory.Limits.pushout.map f₂ g₂ f₁ g₁ (𝟙 Y) (𝟙 Z) (𝟙 X) ⋯ ⋯
-- CategoryTheory.Limits.pushout.mapLift_comp
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 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y S T S' : C} (f : T ⟶ X) (g : T ⟶ Y) (i : S ⟶ T) (i' : S' ⟶ S) [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPushout (i ≫ f) (i ≫ g)] [CategoryTheory.Limits.HasPushout (i' ≫ i ≫ f) (i' ≫ i ≫ g)] [CategoryTheory.Limits.HasPushout ((i' ≫ i) ≫ f) ((i' ≫ i) ≫ g)]
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
-- CategoryTheory.Limits.pullbackComparison_comp_fst
@[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) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback (G.map f) (G.map 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)
-- CategoryTheory.Limits.pullbackComparison_comp_snd
@[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)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback (G.map f) (G.map 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)
-- CategoryTheory.Limits.map_lift_pullbackComparison
@[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]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (f : X ⟶ Z) (g : Y ⟶ Z) [CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Limits.HasPullback (G.map f) (G.map g)] {W : C} {h : W ⟶ X} {k : W ⟶ Y} (w : h ≫ f = k ≫ g)
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) ⋯
-- CategoryTheory.Limits.inl_comp_pushoutComparison
@[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 _ _) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
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)
-- CategoryTheory.Limits.inr_comp_pushoutComparison
@[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 _ _) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
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)
-- CategoryTheory.Limits.pushoutComparison_map_desc
@[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]) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Limits.HasPushout f g] [CategoryTheory.Limits.HasPushout (G.map f) (G.map g)] {W : C} {h : Y ⟶ W} {k : Z ⟶ W} (w : f ≫ h = g ≫ k)
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) ⋯
-- CategoryTheory.Limits.hasPullback_symmetry
theorem hasPullback_symmetry [HasPullback f g] : HasPullback g f 
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.Limits.HasPullback g f
-- CategoryTheory.Limits.pullbackSymmetry_hom_comp_fst
@[reassoc (attr := simp)]
theorem pullbackSymmetry_hom_comp_fst [HasPullback f g] :
    (pullbackSymmetry f g).hom ≫ pullback.fst g f = pullback.snd 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.Limits.pullbackSymmetry f g).hom ≫ CategoryTheory.Limits.pullback.fst g f =
  CategoryTheory.Limits.pullback.snd f g
-- CategoryTheory.Limits.pullbackSymmetry_hom_comp_snd
@[reassoc (attr := simp)]
theorem pullbackSymmetry_hom_comp_snd [HasPullback f g] :
    (pullbackSymmetry f g).hom ≫ pullback.snd g f = pullback.fst 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.Limits.pullbackSymmetry f g).hom ≫ CategoryTheory.Limits.pullback.snd g f =
  CategoryTheory.Limits.pullback.fst f g
-- CategoryTheory.Limits.pullbackSymmetry_inv_comp_fst
@[reassoc (attr := simp)]
theorem pullbackSymmetry_inv_comp_fst [HasPullback f g] :
    (pullbackSymmetry f g).inv ≫ pullback.fst f g = pullback.snd g f 
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.Limits.pullbackSymmetry f g).inv ≫ CategoryTheory.Limits.pullback.fst f g =
  CategoryTheory.Limits.pullback.snd g f
-- CategoryTheory.Limits.pullbackSymmetry_inv_comp_snd
@[reassoc (attr := simp)]
theorem pullbackSymmetry_inv_comp_snd [HasPullback f g] :
    (pullbackSymmetry f g).inv ≫ pullback.snd f g = pullback.fst g f 
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.Limits.pullbackSymmetry f g).inv ≫ CategoryTheory.Limits.pullback.snd f g =
  CategoryTheory.Limits.pullback.fst g f
-- CategoryTheory.Limits.hasPushout_symmetry
theorem hasPushout_symmetry [HasPushout f g] : HasPushout g f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Limits.HasPushout f g]
Goal: CategoryTheory.Limits.HasPushout g f
-- CategoryTheory.Limits.inl_comp_pushoutSymmetry_hom
@[reassoc (attr := simp)]
theorem inl_comp_pushoutSymmetry_hom [HasPushout f g] :
    pushout.inl _ _ ≫ (pushoutSymmetry f g).hom = pushout.inr _ _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.Limits.HasPushout f g]
Goal: CategoryTheory.Limits.pushout.inl f g ≫ (CategoryTheory.Limits.pushoutSymmetry f g).hom =
  CategoryTheory.Limits.pushout.inr g f