ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.terminal.comp_from
@[simp]
theorem terminal.comp_from [HasTerminal C] {P Q : C} (f : P ⟶ Q) :
    f ≫ terminal.from Q = terminal.from P 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal C] {P Q : C} (f : P ⟶ Q)
Goal: f ≫ CategoryTheory.Limits.terminal.from Q = CategoryTheory.Limits.terminal.from P
-- CategoryTheory.Limits.initial.to_comp
@[simp]
theorem initial.to_comp [HasInitial C] {P Q : C} (f : P ⟶ Q) : initial.to P ≫ f = initial.to Q 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasInitial C] {P Q : C} (f : P ⟶ Q)
Goal: CategoryTheory.Limits.initial.to P ≫ f = CategoryTheory.Limits.initial.to Q
-- CategoryTheory.Limits.hasTerminal_of_hasInitial_op
theorem hasTerminal_of_hasInitial_op [HasInitial Cᵒᵖ] : HasTerminal C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasInitial Cᵒᵖ]
Goal: CategoryTheory.Limits.HasTerminal C
-- CategoryTheory.Limits.hasInitial_of_hasTerminal_op
theorem hasInitial_of_hasTerminal_op [HasTerminal Cᵒᵖ] : HasInitial C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasTerminal Cᵒᵖ]
Goal: CategoryTheory.Limits.HasInitial C
-- CategoryTheory.Limits.limitConstTerminal_hom
@[simps hom]
def limitConstTerminal {J : Type*} [Category J] {C : Type*} [Category C] [HasTerminal C] :
    limit ((CategoryTheory.Functor.const J).obj (⊤_ C)) ≅ ⊤_ C 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_3, u_1} J] {C : Type u_2} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Limits.HasTerminal C]
Goal: CategoryTheory.Limits.limitConstTerminal.hom =
  CategoryTheory.Limits.terminal.from (CategoryTheory.Limits.limit ((CategoryTheory.Functor.const J).obj (⊤_ C)))
-- CategoryTheory.Limits.limitConstTerminal_inv_π
@[reassoc (attr := simp)]
theorem limitConstTerminal_inv_π {J : Type*} [Category J] {C : Type*} [Category C] [HasTerminal C]
    {j : J} :
    limitConstTerminal.inv ≫ limit.π ((CategoryTheory.Functor.const J).obj (⊤_ C)) j =
      terminal.from _ 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_3, u_1} J] {C : Type u_2} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Limits.HasTerminal C] {j : J}
Goal: CategoryTheory.Limits.limitConstTerminal.inv ≫
    CategoryTheory.Limits.limit.π ((CategoryTheory.Functor.const J).obj (⊤_ C)) j =
  CategoryTheory.Limits.terminal.from (⊤_ C)
-- CategoryTheory.Limits.colimitConstInitial_inv
@[simps inv]
def colimitConstInitial {J : Type*} [Category J] {C : Type*} [Category C] [HasInitial C] :
    colimit ((CategoryTheory.Functor.const J).obj (⊥_ C)) ≅ ⊥_ C 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_3, u_1} J] {C : Type u_2} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Limits.HasInitial C]
Goal: CategoryTheory.Limits.colimitConstInitial.inv =
  CategoryTheory.Limits.initial.to (CategoryTheory.Limits.colimit ((CategoryTheory.Functor.const J).obj (⊥_ C)))
-- CategoryTheory.Limits.ι_colimitConstInitial_hom
@[reassoc (attr := simp)]
theorem ι_colimitConstInitial_hom {J : Type*} [Category J] {C : Type*} [Category C] [HasInitial C]
    {j : J} :
    colimit.ι ((CategoryTheory.Functor.const J).obj (⊥_ C)) j ≫ colimitConstInitial.hom =
      initial.to _ 
Arguments: {J : Type u_1} [CategoryTheory.Category.{u_3, u_1} J] {C : Type u_2} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Limits.HasInitial C] {j : J}
Goal: CategoryTheory.Limits.colimit.ι ((CategoryTheory.Functor.const J).obj (⊥_ C)) j ≫
    CategoryTheory.Limits.colimitConstInitial.hom =
  CategoryTheory.Limits.initial.to (⊥_ C)
-- CategoryTheory.Limits.InitialMonoClass.isInitial_mono_from
class InitialMonoClass (C : Type u₁) [Category.{v₁} C] : Prop where
    isInitial_mono_from : ∀ {I} (X : C) (hI : IsInitial I), Mono (hI.to X)
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [self : CategoryTheory.Limits.InitialMonoClass C] {I : C} (X : C) (hI : CategoryTheory.Limits.IsInitial I)
Goal: CategoryTheory.Mono (hI.to X)
-- CategoryTheory.Limits.IsInitial.mono_from
theorem IsInitial.mono_from [InitialMonoClass C] {I} {X : C} (hI : IsInitial I) (f : I ⟶ X) :
    Mono f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.InitialMonoClass C] {I X : C} (hI : CategoryTheory.Limits.IsInitial I) (f : I ⟶ X)
Goal: CategoryTheory.Mono f
-- CategoryTheory.Limits.InitialMonoClass.of_isInitial
theorem InitialMonoClass.of_isInitial {I : C} (hI : IsInitial I) (h : ∀ X, Mono (hI.to X)) :
    InitialMonoClass C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {I : C} (hI : CategoryTheory.Limits.IsInitial I) (h : ∀ (X : C), CategoryTheory.Mono (hI.to X))
Goal: CategoryTheory.Limits.InitialMonoClass C
-- CategoryTheory.Limits.InitialMonoClass.of_initial
theorem InitialMonoClass.of_initial [HasInitial C] (h : ∀ X : C, Mono (initial.to X)) :
    InitialMonoClass C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasInitial C] (h : ∀ (X : C), CategoryTheory.Mono (CategoryTheory.Limits.initial.to X))
Goal: CategoryTheory.Limits.InitialMonoClass C
-- CategoryTheory.Limits.InitialMonoClass.of_isTerminal
theorem InitialMonoClass.of_isTerminal {I T : C} (hI : IsInitial I) (hT : IsTerminal T)
    (_ : Mono (hI.to T)) : InitialMonoClass C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {I T : C} (hI : CategoryTheory.Limits.IsInitial I) (hT : CategoryTheory.Limits.IsTerminal T)
Goal: CategoryTheory.Mono (hI.to T) → CategoryTheory.Limits.InitialMonoClass C
-- CategoryTheory.Limits.InitialMonoClass.of_terminal
theorem InitialMonoClass.of_terminal [HasInitial C] [HasTerminal C] (h : Mono (initial.to (⊤_ C))) :
    InitialMonoClass C 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.HasTerminal C] (h : CategoryTheory.Mono (CategoryTheory.Limits.initial.to (⊤_ C)))
Goal: CategoryTheory.Limits.InitialMonoClass C
-- CategoryTheory.Limits.coneOfDiagramInitial_pt
@[simps]
def coneOfDiagramInitial {X : J} (tX : IsInitial X) (F : J ⥤ C) : Cone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {X : J} (tX : CategoryTheory.Limits.IsInitial X) (F : J ⥤ C)
Goal: (CategoryTheory.Limits.coneOfDiagramInitial tX F).pt = F.obj X
-- CategoryTheory.Limits.coneOfDiagramInitial_π_app
@[simps]
def coneOfDiagramInitial {X : J} (tX : IsInitial X) (F : J ⥤ C) : Cone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {X : J} (tX : CategoryTheory.Limits.IsInitial X) (F : J ⥤ C) (j : J)
Goal: (CategoryTheory.Limits.coneOfDiagramInitial tX F).π.app j = F.map (tX.to j)
-- CategoryTheory.Limits.coneOfDiagramTerminal_π_app
@[simps]
def coneOfDiagramTerminal {X : J} (hX : IsTerminal X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {X : J} (hX : CategoryTheory.Limits.IsTerminal X) (F : J ⥤ C) [∀ (i j : J) (f : i ⟶ j), CategoryTheory.IsIso (F.map f)] (i : J)
Goal: (CategoryTheory.Limits.coneOfDiagramTerminal hX F).π.app i = CategoryTheory.inv (F.map (hX.from i))
-- CategoryTheory.Limits.coneOfDiagramTerminal_pt
@[simps]
def coneOfDiagramTerminal {X : J} (hX : IsTerminal X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {X : J} (hX : CategoryTheory.Limits.IsTerminal X) (F : J ⥤ C) [∀ (i j : J) (f : i ⟶ j), CategoryTheory.IsIso (F.map f)]
Goal: (CategoryTheory.Limits.coneOfDiagramTerminal hX F).pt = F.obj X
-- CategoryTheory.Limits.coconeOfDiagramTerminal_ι_app
@[simps]
def coconeOfDiagramTerminal {X : J} (tX : IsTerminal X) (F : J ⥤ C) : Cocone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {X : J} (tX : CategoryTheory.Limits.IsTerminal X) (F : J ⥤ C) (j : J)
Goal: (CategoryTheory.Limits.coconeOfDiagramTerminal tX F).ι.app j = F.map (tX.from j)
-- CategoryTheory.Limits.coconeOfDiagramTerminal_pt
@[simps]
def coconeOfDiagramTerminal {X : J} (tX : IsTerminal X) (F : J ⥤ C) : Cocone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {X : J} (tX : CategoryTheory.Limits.IsTerminal X) (F : J ⥤ C)
Goal: (CategoryTheory.Limits.coconeOfDiagramTerminal tX F).pt = F.obj X
-- CategoryTheory.Limits.IsColimit.isIso_ι_app_of_isTerminal
lemma IsColimit.isIso_ι_app_of_isTerminal {F : J ⥤ C} {c : Cocone F} (hc : IsColimit c)
    (X : J) (hX : IsTerminal X) :
    IsIso (c.ι.app X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {F : J ⥤ C} {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c) (X : J) (hX : CategoryTheory.Limits.IsTerminal X)
Goal: CategoryTheory.IsIso (c.ι.app X)
-- CategoryTheory.Limits.coconeOfDiagramInitial_ι_app
@[simps]
def coconeOfDiagramInitial {X : J} (hX : IsInitial X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cocone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {X : J} (hX : CategoryTheory.Limits.IsInitial X) (F : J ⥤ C) [∀ (i j : J) (f : i ⟶ j), CategoryTheory.IsIso (F.map f)] (i : J)
Goal: (CategoryTheory.Limits.coconeOfDiagramInitial hX F).ι.app i = CategoryTheory.inv (F.map (hX.to i))
-- CategoryTheory.Limits.coconeOfDiagramInitial_pt
@[simps]
def coconeOfDiagramInitial {X : J} (hX : IsInitial X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cocone F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {X : J} (hX : CategoryTheory.Limits.IsInitial X) (F : J ⥤ C) [∀ (i j : J) (f : i ⟶ j), CategoryTheory.IsIso (F.map f)]
Goal: (CategoryTheory.Limits.coconeOfDiagramInitial hX F).pt = F.obj X
-- CategoryTheory.Limits.IsLimit.isIso_π_app_of_isInitial
lemma IsLimit.isIso_π_app_of_isInitial {F : J ⥤ C} {c : Cone F} (hc : IsLimit c)
    (X : J) (hX : IsInitial X) :
    IsIso (c.π.app X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {F : J ⥤ C} {c : CategoryTheory.Limits.Cone F} (hc : CategoryTheory.Limits.IsLimit c) (X : J) (hX : CategoryTheory.Limits.IsInitial X)
Goal: CategoryTheory.IsIso (c.π.app X)
-- CategoryTheory.Limits.isIso_π_of_isInitial
theorem isIso_π_of_isInitial {j : J} (I : IsInitial j) (F : J ⥤ C) [HasLimit F] :
    IsIso (limit.π F j) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {j : J} (I : CategoryTheory.Limits.IsInitial j) (F : J ⥤ C) [CategoryTheory.Limits.HasLimit F]
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.limit.π F j)
-- CategoryTheory.Limits.isIso_π_of_isTerminal
theorem isIso_π_of_isTerminal {j : J} (I : IsTerminal j) (F : J ⥤ C) [HasLimit F]
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : IsIso (limit.π F j) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {j : J} (I : CategoryTheory.Limits.IsTerminal j) (F : J ⥤ C) [CategoryTheory.Limits.HasLimit F] [∀ (i j : J) (f : i ⟶ j), CategoryTheory.IsIso (F.map f)]
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.limit.π F j)
-- CategoryTheory.Limits.isIso_ι_of_isTerminal
theorem isIso_ι_of_isTerminal {j : J} (I : IsTerminal j) (F : J ⥤ C) [HasColimit F] :
    IsIso (colimit.ι F j) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {j : J} (I : CategoryTheory.Limits.IsTerminal j) (F : J ⥤ C) [CategoryTheory.Limits.HasColimit F]
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.colimit.ι F j)
-- CategoryTheory.Limits.isIso_ι_of_isInitial
theorem isIso_ι_of_isInitial {j : J} (I : IsInitial j) (F : J ⥤ C) [HasColimit F]
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : IsIso (colimit.ι F j) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] {j : J} (I : CategoryTheory.Limits.IsInitial j) (F : J ⥤ C) [CategoryTheory.Limits.HasColimit F] [∀ (i j : J) (f : i ⟶ j), CategoryTheory.IsIso (F.map f)]
Goal: CategoryTheory.IsIso (CategoryTheory.Limits.colimit.ι F j)
-- CategoryTheory.Limits.isIso_of_isTerminal
lemma isIso_of_isTerminal {X Y : C} (hX : IsTerminal X) (hY : IsTerminal Y) (f : X ⟶ Y) :
    IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (hX : CategoryTheory.Limits.IsTerminal X) (hY : CategoryTheory.Limits.IsTerminal Y) (f : X ⟶ Y)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Limits.isIso_of_isInitial
lemma isIso_of_isInitial {X Y : C} (hX : IsInitial X) (hY : IsInitial Y) (f : X ⟶ Y) :
    IsIso f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (hX : CategoryTheory.Limits.IsInitial X) (hY : CategoryTheory.Limits.IsInitial Y) (f : X ⟶ Y)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Limits.hasLimitsOfShape_of_essentiallySmall
theorem hasLimitsOfShape_of_essentiallySmall [EssentiallySmall.{w₁} J]
    [HasLimitsOfSize.{w₁, w₁} C] : HasLimitsOfShape J C 
Arguments: (J : Type u₂) [CategoryTheory.Category.{v₂, u₂} J] (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.EssentiallySmall.{w₁, v₂, u₂} J] [CategoryTheory.Limits.HasLimitsOfSize.{w₁, w₁, v₁, u₁} C]
Goal: CategoryTheory.Limits.HasLimitsOfShape J C
-- CategoryTheory.Limits.hasColimitsOfShape_of_essentiallySmall
theorem hasColimitsOfShape_of_essentiallySmall [EssentiallySmall.{w₁} J]
    [HasColimitsOfSize.{w₁, w₁} C] : HasColimitsOfShape J C 
Arguments: (J : Type u₂) [CategoryTheory.Category.{v₂, u₂} J] (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.EssentiallySmall.{w₁, v₂, u₂} J] [CategoryTheory.Limits.HasColimitsOfSize.{w₁, w₁, v₁, u₁} C]
Goal: CategoryTheory.Limits.HasColimitsOfShape J C
-- CategoryTheory.Limits.hasProductsOfShape_of_small
theorem hasProductsOfShape_of_small (β : Type w₂) [Small.{w₁} β] [HasProducts.{w₁} C] :
    HasProductsOfShape β C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (β : Type w₂) [Small.{w₁, w₂} β] [CategoryTheory.Limits.HasProducts C]
Goal: CategoryTheory.Limits.HasProductsOfShape β C
-- CategoryTheory.Limits.hasCoproductsOfShape_of_small
theorem hasCoproductsOfShape_of_small (β : Type w₂) [Small.{w₁} β] [HasCoproducts.{w₁} C] :
    HasCoproductsOfShape β C 
Arguments: (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (β : Type w₂) [Small.{w₁, w₂} β] [CategoryTheory.Limits.HasCoproducts C]
Goal: CategoryTheory.Limits.HasCoproductsOfShape β C
-- CategoryTheory.Limits.WalkingParallelPairHom.id_comp
theorem WalkingParallelPairHom.id_comp
    {X Y : WalkingParallelPair} (g : WalkingParallelPairHom X Y) : comp (id X) g = g 
Arguments: {X Y : CategoryTheory.Limits.WalkingParallelPair} (g : CategoryTheory.Limits.WalkingParallelPairHom X Y)
Goal: (CategoryTheory.Limits.WalkingParallelPairHom.id X).comp g = g
-- CategoryTheory.Limits.WalkingParallelPairHom.comp_id
theorem WalkingParallelPairHom.comp_id
    {X Y : WalkingParallelPair} (f : WalkingParallelPairHom X Y) : comp f (id Y) = f 
Arguments: {X Y : CategoryTheory.Limits.WalkingParallelPair} (f : CategoryTheory.Limits.WalkingParallelPairHom X Y)
Goal: f.comp (CategoryTheory.Limits.WalkingParallelPairHom.id Y) = f
-- CategoryTheory.Limits.WalkingParallelPairHom.assoc
theorem WalkingParallelPairHom.assoc {X Y Z W : WalkingParallelPair}
    (f : WalkingParallelPairHom X Y) (g : WalkingParallelPairHom Y Z)
    (h : WalkingParallelPairHom Z W) : comp (comp f g) h = comp f (comp g h) 
Arguments: {X Y Z W : CategoryTheory.Limits.WalkingParallelPair} (f : CategoryTheory.Limits.WalkingParallelPairHom X Y) (g : CategoryTheory.Limits.WalkingParallelPairHom Y Z) (h : CategoryTheory.Limits.WalkingParallelPairHom Z W)
Goal: (f.comp g).comp h = f.comp (g.comp h)
-- CategoryTheory.Limits.walkingParallelPairHom_id
@[simp]
theorem walkingParallelPairHom_id (X : WalkingParallelPair) : WalkingParallelPairHom.id X = 𝟙 X 
Arguments: (X : CategoryTheory.Limits.WalkingParallelPair)
Goal: CategoryTheory.Limits.WalkingParallelPairHom.id X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Limits.WalkingParallelPairHom.id.sizeOf_spec'
@[simp]
theorem WalkingParallelPairHom.id.sizeOf_spec' (X : WalkingParallelPair) :
    (WalkingParallelPairHom._sizeOf_inst X X).sizeOf (𝟙 X) = 1 + sizeOf X 
Arguments: (X : CategoryTheory.Limits.WalkingParallelPair)
Goal: sizeOf (CategoryTheory.CategoryStruct.id X) = 1 + sizeOf X
-- CategoryTheory.Limits.walkingParallelPairOp_zero
@[simp]
theorem walkingParallelPairOp_zero : walkingParallelPairOp.obj zero = op one 
Goal: CategoryTheory.Limits.walkingParallelPairOp.obj CategoryTheory.Limits.WalkingParallelPair.zero =
  Opposite.op CategoryTheory.Limits.WalkingParallelPair.one
-- CategoryTheory.Limits.walkingParallelPairOp_one
@[simp]
theorem walkingParallelPairOp_one : walkingParallelPairOp.obj one = op zero 
Goal: CategoryTheory.Limits.walkingParallelPairOp.obj CategoryTheory.Limits.WalkingParallelPair.one =
  Opposite.op CategoryTheory.Limits.WalkingParallelPair.zero
-- CategoryTheory.Limits.walkingParallelPairOp_left
@[simp]
theorem walkingParallelPairOp_left :
    walkingParallelPairOp.map left = @Quiver.Hom.op _ _ zero one left 
Goal: CategoryTheory.Limits.walkingParallelPairOp.map CategoryTheory.Limits.WalkingParallelPairHom.left =
  Quiver.Hom.op CategoryTheory.Limits.WalkingParallelPairHom.left
-- CategoryTheory.Limits.walkingParallelPairOp_right
@[simp]
theorem walkingParallelPairOp_right :
    walkingParallelPairOp.map right = @Quiver.Hom.op _ _ zero one right 
Goal: CategoryTheory.Limits.walkingParallelPairOp.map CategoryTheory.Limits.WalkingParallelPairHom.right =
  Quiver.Hom.op CategoryTheory.Limits.WalkingParallelPairHom.right
-- CategoryTheory.Limits.walkingParallelPairOpEquiv_functor
@[simps functor inverse]
def walkingParallelPairOpEquiv : WalkingParallelPair ≌ WalkingParallelPairᵒᵖ 
Goal: CategoryTheory.Limits.walkingParallelPairOpEquiv.functor = CategoryTheory.Limits.walkingParallelPairOp
-- CategoryTheory.Limits.walkingParallelPairOpEquiv_inverse
@[simps functor inverse]
def walkingParallelPairOpEquiv : WalkingParallelPair ≌ WalkingParallelPairᵒᵖ 
Goal: CategoryTheory.Limits.walkingParallelPairOpEquiv.inverse = CategoryTheory.Limits.walkingParallelPairOp.leftOp
-- CategoryTheory.Limits.walkingParallelPairOpEquiv_unitIso_zero
@[simp]
theorem walkingParallelPairOpEquiv_unitIso_zero :
    walkingParallelPairOpEquiv.unitIso.app zero = Iso.refl zero 
Goal: CategoryTheory.Limits.walkingParallelPairOpEquiv.unitIso.app CategoryTheory.Limits.WalkingParallelPair.zero =
  CategoryTheory.Iso.refl CategoryTheory.Limits.WalkingParallelPair.zero
-- CategoryTheory.Limits.walkingParallelPairOpEquiv_unitIso_one
@[simp]
theorem walkingParallelPairOpEquiv_unitIso_one :
    walkingParallelPairOpEquiv.unitIso.app one = Iso.refl one 
Goal: CategoryTheory.Limits.walkingParallelPairOpEquiv.unitIso.app CategoryTheory.Limits.WalkingParallelPair.one =
  CategoryTheory.Iso.refl CategoryTheory.Limits.WalkingParallelPair.one
-- CategoryTheory.Limits.walkingParallelPairOpEquiv_counitIso_zero
@[simp]
theorem walkingParallelPairOpEquiv_counitIso_zero :
    walkingParallelPairOpEquiv.counitIso.app (op zero) = Iso.refl (op zero) 
Goal: CategoryTheory.Limits.walkingParallelPairOpEquiv.counitIso.app
    (Opposite.op CategoryTheory.Limits.WalkingParallelPair.zero) =
  CategoryTheory.Iso.refl (Opposite.op CategoryTheory.Limits.WalkingParallelPair.zero)
-- CategoryTheory.Limits.walkingParallelPairOpEquiv_counitIso_one
@[simp]
theorem walkingParallelPairOpEquiv_counitIso_one :
    walkingParallelPairOpEquiv.counitIso.app (op one) = Iso.refl (op one) 
Goal: CategoryTheory.Limits.walkingParallelPairOpEquiv.counitIso.app
    (Opposite.op CategoryTheory.Limits.WalkingParallelPair.one) =
  CategoryTheory.Iso.refl (Opposite.op CategoryTheory.Limits.WalkingParallelPair.one)
-- CategoryTheory.Limits.parallelPair_obj_zero
@[simp]
theorem parallelPair_obj_zero (f g : X ⟶ Y) : (parallelPair f g).obj zero = X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
Goal: (CategoryTheory.Limits.parallelPair f g).obj CategoryTheory.Limits.WalkingParallelPair.zero = X
-- CategoryTheory.Limits.parallelPair_obj_one
@[simp]
theorem parallelPair_obj_one (f g : X ⟶ Y) : (parallelPair f g).obj one = Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
Goal: (CategoryTheory.Limits.parallelPair f g).obj CategoryTheory.Limits.WalkingParallelPair.one = Y
-- CategoryTheory.Limits.parallelPair_map_left
@[simp]
theorem parallelPair_map_left (f g : X ⟶ Y) : (parallelPair f g).map left = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
Goal: (CategoryTheory.Limits.parallelPair f g).map CategoryTheory.Limits.WalkingParallelPairHom.left = f
-- CategoryTheory.Limits.parallelPair_map_right
@[simp]
theorem parallelPair_map_right (f g : X ⟶ Y) : (parallelPair f g).map right = g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
Goal: (CategoryTheory.Limits.parallelPair f g).map CategoryTheory.Limits.WalkingParallelPairHom.right = g
-- CategoryTheory.Limits.parallelPair_functor_obj
@[simp]
theorem parallelPair_functor_obj {F : WalkingParallelPair ⥤ C} (j : WalkingParallelPair) :
    (parallelPair (F.map left) (F.map right)).obj j = F.obj j 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C} (j : CategoryTheory.Limits.WalkingParallelPair)
Goal: (CategoryTheory.Limits.parallelPair (F.map CategoryTheory.Limits.WalkingParallelPairHom.left)
        (F.map CategoryTheory.Limits.WalkingParallelPairHom.right)).obj
    j =
  F.obj j
-- CategoryTheory.Limits.diagramIsoParallelPair_hom_app
@[simps!]
def diagramIsoParallelPair (F : WalkingParallelPair ⥤ C) :
    F ≅ parallelPair (F.map left) (F.map right) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C) (X : CategoryTheory.Limits.WalkingParallelPair)
Goal: (CategoryTheory.Limits.diagramIsoParallelPair F).hom.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.diagramIsoParallelPair_inv_app
@[simps!]
def diagramIsoParallelPair (F : WalkingParallelPair ⥤ C) :
    F ≅ parallelPair (F.map left) (F.map right) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C) (X : CategoryTheory.Limits.WalkingParallelPair)
Goal: (CategoryTheory.Limits.diagramIsoParallelPair F).inv.app X = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Limits.parallelPairHom_app_zero
@[simp]
theorem parallelPairHom_app_zero {X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : X ⟶ X')
    (q : Y ⟶ Y') (wf : f ≫ q = p ≫ f') (wg : g ≫ q = p ≫ g') :
    (parallelPairHom f g f' g' p q wf wg).app zero = p 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : X ⟶ X') (q : Y ⟶ Y') (wf : CategoryTheory.CategoryStruct.comp f q = CategoryTheory.CategoryStruct.comp p f') (wg : CategoryTheory.CategoryStruct.comp g q = CategoryTheory.CategoryStruct.comp p g')
Goal: (CategoryTheory.Limits.parallelPairHom f g f' g' p q wf wg).app CategoryTheory.Limits.WalkingParallelPair.zero = p
-- CategoryTheory.Limits.parallelPairHom_app_one
@[simp]
theorem parallelPairHom_app_one {X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : X ⟶ X')
    (q : Y ⟶ Y') (wf : f ≫ q = p ≫ f') (wg : g ≫ q = p ≫ g') :
    (parallelPairHom f g f' g' p q wf wg).app one = q 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y X' Y' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : X ⟶ X') (q : Y ⟶ Y') (wf : CategoryTheory.CategoryStruct.comp f q = CategoryTheory.CategoryStruct.comp p f') (wg : CategoryTheory.CategoryStruct.comp g q = CategoryTheory.CategoryStruct.comp p g')
Goal: (CategoryTheory.Limits.parallelPairHom f g f' g' p q wf wg).app CategoryTheory.Limits.WalkingParallelPair.one = q