ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.hasPushout_of_left_iso
theorem hasPushout_of_left_iso : HasPushout f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso f]
Goal: CategoryTheory.Limits.HasPushout f g
-- CategoryTheory.Limits.pushout_inl_inv_inr_of_right_isIso
@[reassoc (attr := simp)]
lemma pushout_inl_inv_inr_of_right_isIso :
    pushout.inl f g ≫ inv (pushout.inr f g) = inv f ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso f]
Goal: CategoryTheory.Limits.pushout.inl f g ≫ CategoryTheory.inv (CategoryTheory.Limits.pushout.inr f g) =
  CategoryTheory.inv f ≫ g
-- CategoryTheory.Limits.pushoutCoconeOfRightIso_x
@[simp]
theorem pushoutCoconeOfRightIso_x : (pushoutCoconeOfRightIso f g).pt = Y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso g]
Goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).pt = Y
-- CategoryTheory.Limits.pushoutCoconeOfRightIso_inl
@[simp]
theorem pushoutCoconeOfRightIso_inl : (pushoutCoconeOfRightIso f g).inl = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso g]
Goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).inl = 𝟙 Y
-- CategoryTheory.Limits.pushoutCoconeOfRightIso_inr
@[simp]
theorem pushoutCoconeOfRightIso_inr : (pushoutCoconeOfRightIso f g).inr = inv g ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso g]
Goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).inr = CategoryTheory.inv g ≫ f
-- CategoryTheory.Limits.pushoutCoconeOfRightIso_ι_app_none
theorem pushoutCoconeOfRightIso_ι_app_none : (pushoutCoconeOfRightIso f g).ι.app none = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso g]
Goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).ι.app none = f
-- CategoryTheory.Limits.pushoutCoconeOfRightIso_ι_app_left
@[simp]
theorem pushoutCoconeOfRightIso_ι_app_left : (pushoutCoconeOfRightIso f g).ι.app left = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso g]
Goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).ι.app CategoryTheory.Limits.WalkingSpan.left =
  𝟙 ((CategoryTheory.Limits.span f g).obj CategoryTheory.Limits.WalkingSpan.left)
-- CategoryTheory.Limits.pushoutCoconeOfRightIso_ι_app_right
@[simp]
theorem pushoutCoconeOfRightIso_ι_app_right :
    (pushoutCoconeOfRightIso f g).ι.app right = inv g ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso g]
Goal: (CategoryTheory.Limits.pushoutCoconeOfRightIso f g).ι.app CategoryTheory.Limits.WalkingSpan.right =
  CategoryTheory.inv g ≫ f
-- CategoryTheory.Limits.hasPushout_of_right_iso
theorem hasPushout_of_right_iso : HasPushout f g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso g]
Goal: CategoryTheory.Limits.HasPushout f g
-- CategoryTheory.Limits.pushout_inr_inv_inl_of_right_isIso
@[reassoc (attr := simp)]
lemma pushout_inr_inv_inl_of_right_isIso :
    pushout.inr f g ≫ inv (pushout.inl f g) = inv g ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) [CategoryTheory.IsIso g]
Goal: CategoryTheory.Limits.pushout.inr f g ≫ CategoryTheory.inv (CategoryTheory.Limits.pushout.inl f g) =
  CategoryTheory.inv g ≫ f
-- CategoryTheory.FunctorToTypes.prod.fst_app
@[simps]
def prod.fst : prod F G ⟶ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)}
Goal: ∀ (x : C) (a : (CategoryTheory.FunctorToTypes.prod F G).obj x), CategoryTheory.FunctorToTypes.prod.fst.app x a = a.1
-- CategoryTheory.FunctorToTypes.prod.snd_app
@[simps]
def prod.snd : prod F G ⟶ G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)}
Goal: ∀ (x : C) (a : (CategoryTheory.FunctorToTypes.prod F G).obj x), CategoryTheory.FunctorToTypes.prod.snd.app x a = a.2
-- CategoryTheory.FunctorToTypes.prod.lift_app
@[simps]
def prod.lift {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :
    F ⟶ prod F₁ F₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F F₁ F₂ : CategoryTheory.Functor C (Type w)} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) (x : C) (y : F.obj x)
Goal: (CategoryTheory.FunctorToTypes.prod.lift τ₁ τ₂).app x y = (τ₁.app x y, τ₂.app x y)
-- CategoryTheory.FunctorToTypes.prod.lift_fst
@[simp]
lemma prod.lift_fst {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :
    prod.lift τ₁ τ₂ ≫ prod.fst = τ₁ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F F₁ F₂ : CategoryTheory.Functor C (Type w)} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.prod.lift τ₁ τ₂)
    CategoryTheory.FunctorToTypes.prod.fst =
  τ₁
-- CategoryTheory.FunctorToTypes.prod.lift_snd
@[simp]
lemma prod.lift_snd {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :
    prod.lift τ₁ τ₂ ≫ prod.snd = τ₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F F₁ F₂ : CategoryTheory.Functor C (Type w)} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.prod.lift τ₁ τ₂)
    CategoryTheory.FunctorToTypes.prod.snd =
  τ₂
-- CategoryTheory.FunctorToTypes.binaryProductCone_pt_obj
@[simps!]
def binaryProductCone : BinaryFan F G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C)
Goal: (CategoryTheory.FunctorToTypes.binaryProductCone F G).pt.obj a = (F.obj a × G.obj a)
-- CategoryTheory.FunctorToTypes.binaryProductCone_pt_map
@[simps!]
def binaryProductCone : BinaryFan F G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: ∀ {X Y : C} (f : X ⟶ Y) (a : F.obj X × G.obj X),
  (CategoryTheory.FunctorToTypes.binaryProductCone F G).pt.map f a = (F.map f a.1, G.map f a.2)
-- CategoryTheory.FunctorToTypes.binaryProductCone_π_app
@[simps!]
def binaryProductCone : BinaryFan F G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: ∀ (x : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
  (CategoryTheory.FunctorToTypes.binaryProductCone F G).π.app x =
    match x.as with
    | CategoryTheory.Limits.WalkingPair.left => CategoryTheory.FunctorToTypes.prod.fst
    | CategoryTheory.Limits.WalkingPair.right => CategoryTheory.FunctorToTypes.prod.snd
-- CategoryTheory.FunctorToTypes.binaryProductLimit_lift
@[simps]
def binaryProductLimit : IsLimit (binaryProductCone F G) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (s : CategoryTheory.Limits.BinaryFan F G)
Goal: (CategoryTheory.FunctorToTypes.binaryProductLimit F G).lift s = CategoryTheory.FunctorToTypes.prod.lift s.fst s.snd
-- CategoryTheory.FunctorToTypes.binaryProductIso_hom_comp_fst
@[simp]
lemma binaryProductIso_hom_comp_fst :
    (binaryProductIso F G).hom ≫ prod.fst = Limits.prod.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.binaryProductIso F G).hom
    CategoryTheory.FunctorToTypes.prod.fst =
  CategoryTheory.Limits.prod.fst
-- CategoryTheory.FunctorToTypes.binaryProductIso_hom_comp_snd
@[simp]
lemma binaryProductIso_hom_comp_snd :
    (binaryProductIso F G).hom ≫ prod.snd = Limits.prod.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.binaryProductIso F G).hom
    CategoryTheory.FunctorToTypes.prod.snd =
  CategoryTheory.Limits.prod.snd
-- CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_fst
@[simp]
lemma binaryProductIso_inv_comp_fst :
    (binaryProductIso F G).inv ≫ Limits.prod.fst = prod.fst 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.binaryProductIso F G).inv
    CategoryTheory.Limits.prod.fst =
  CategoryTheory.FunctorToTypes.prod.fst
-- CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_fst_apply
@[simp]
lemma binaryProductIso_inv_comp_fst_apply (a : C) (z : (prod F G).obj a) :
    (Limits.prod.fst (X := F)).app a ((binaryProductIso F G).inv.app a z) = z.1 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (z : (CategoryTheory.FunctorToTypes.prod F G).obj a)
Goal: CategoryTheory.Limits.prod.fst.app a ((CategoryTheory.FunctorToTypes.binaryProductIso F G).inv.app a z) = z.1
-- CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_snd
@[simp]
lemma binaryProductIso_inv_comp_snd :
    (binaryProductIso F G).inv ≫ Limits.prod.snd = prod.snd 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.binaryProductIso F G).inv
    CategoryTheory.Limits.prod.snd =
  CategoryTheory.FunctorToTypes.prod.snd
-- CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_snd_apply
@[simp]
lemma binaryProductIso_inv_comp_snd_apply (a : C) (z : (prod F G).obj a) :
    (Limits.prod.snd (X := F)).app a ((binaryProductIso F G).inv.app a z) = z.2 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (z : (CategoryTheory.FunctorToTypes.prod F G).obj a)
Goal: CategoryTheory.Limits.prod.snd.app a ((CategoryTheory.FunctorToTypes.binaryProductIso F G).inv.app a z) = z.2
-- CategoryTheory.FunctorToTypes.prodMk_fst
@[simp]
lemma prodMk_fst {a : C} (x : F.obj a) (y : G.obj a) :
    (Limits.prod.fst (X := F)).app a (prodMk x y) = x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)} {a : C} (x : F.obj a) (y : G.obj a)
Goal: CategoryTheory.Limits.prod.fst.app a (CategoryTheory.FunctorToTypes.prodMk x y) = x
-- CategoryTheory.FunctorToTypes.prodMk_snd
@[simp]
lemma prodMk_snd {a : C} (x : F.obj a) (y : G.obj a) :
    (Limits.prod.snd (X := F)).app a (prodMk x y) = y 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)} {a : C} (x : F.obj a) (y : G.obj a)
Goal: CategoryTheory.Limits.prod.snd.app a (CategoryTheory.FunctorToTypes.prodMk x y) = y
-- CategoryTheory.FunctorToTypes.prod_ext
@[ext]
lemma prod_ext {a : C} (z w : (prod F G).obj a) (h1 : z.1 = w.1) (h2 : z.2 = w.2) :
    z = w 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)} {a : C} (z w : (CategoryTheory.FunctorToTypes.prod F G).obj a) (h1 : z.1 = w.1) (h2 : z.2 = w.2)
Goal: z = w
-- CategoryTheory.FunctorToTypes.binaryProductEquiv_symm_apply
@[simps]
noncomputable
def binaryProductEquiv (a : C) : (F ⨯ G).obj a ≃ (F.obj a) × (G.obj a) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (z : F.obj a × G.obj a)
Goal: (CategoryTheory.FunctorToTypes.binaryProductEquiv F G a).symm z = CategoryTheory.FunctorToTypes.prodMk z.1 z.2
-- CategoryTheory.FunctorToTypes.binaryProductEquiv_apply
@[simps]
noncomputable
def binaryProductEquiv (a : C) : (F ⨯ G).obj a ≃ (F.obj a) × (G.obj a) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (z : (F ⨯ G).obj a)
Goal: (CategoryTheory.FunctorToTypes.binaryProductEquiv F G a) z =
  (((CategoryTheory.FunctorToTypes.binaryProductIso F G).hom.app a z).1,
    ((CategoryTheory.FunctorToTypes.binaryProductIso F G).hom.app a z).2)
-- CategoryTheory.FunctorToTypes.prod_ext'
@[ext]
lemma prod_ext' (a : C) (z w : (F ⨯ G).obj a)
    (h1 : (Limits.prod.fst (X := F)).app a z = (Limits.prod.fst (X := F)).app a w)
    (h2 : (Limits.prod.snd (X := F)).app a z = (Limits.prod.snd (X := F)).app a w) :
    z = w 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (z w : (F ⨯ G).obj a) (h1 : CategoryTheory.Limits.prod.fst.app a z = CategoryTheory.Limits.prod.fst.app a w) (h2 : CategoryTheory.Limits.prod.snd.app a z = CategoryTheory.Limits.prod.snd.app a w)
Goal: z = w
-- CategoryTheory.FunctorToTypes.coprod.inl_app
@[simps]
def coprod.inl : F ⟶ coprod F G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)}
Goal: ∀ (x : C) (x_1 : F.obj x), CategoryTheory.FunctorToTypes.coprod.inl.app x x_1 = Sum.inl x_1
-- CategoryTheory.FunctorToTypes.coprod.inr_app
@[simps]
def coprod.inr : G ⟶ coprod F G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)}
Goal: ∀ (x : C) (x_1 : G.obj x), CategoryTheory.FunctorToTypes.coprod.inr.app x x_1 = Sum.inr x_1
-- CategoryTheory.FunctorToTypes.coprod.desc_app
@[simps]
def coprod.desc {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) :
    coprod F₁ F₂ ⟶ F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F F₁ F₂ : CategoryTheory.Functor C (Type w)} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) (a : C) (x : (CategoryTheory.FunctorToTypes.coprod F₁ F₂).obj a)
Goal: (CategoryTheory.FunctorToTypes.coprod.desc τ₁ τ₂).app a x =
  Sum.casesOn (motive := fun t => x = t → F.obj a) x (fun x_1 h => τ₁.app a x_1) (fun x_1 h => τ₂.app a x_1) ⋯
-- CategoryTheory.FunctorToTypes.coprod.desc_inl
@[simp]
lemma coprod.desc_inl {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) :
    coprod.inl ≫ coprod.desc τ₁ τ₂ = τ₁ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F F₁ F₂ : CategoryTheory.Functor C (Type w)} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F)
Goal: CategoryTheory.CategoryStruct.comp CategoryTheory.FunctorToTypes.coprod.inl
    (CategoryTheory.FunctorToTypes.coprod.desc τ₁ τ₂) =
  τ₁
-- CategoryTheory.FunctorToTypes.coprod.desc_inr
@[simp]
lemma coprod.desc_inr {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) :
    coprod.inr ≫ coprod.desc τ₁ τ₂ = τ₂ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {F F₁ F₂ : CategoryTheory.Functor C (Type w)} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F)
Goal: CategoryTheory.CategoryStruct.comp CategoryTheory.FunctorToTypes.coprod.inr
    (CategoryTheory.FunctorToTypes.coprod.desc τ₁ τ₂) =
  τ₂
-- CategoryTheory.FunctorToTypes.binaryCoproductCocone_ι_app
@[simps!]
def binaryCoproductCocone : BinaryCofan F G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: ∀ (x : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
  (CategoryTheory.FunctorToTypes.binaryCoproductCocone F G).ι.app x =
    match x.as with
    | CategoryTheory.Limits.WalkingPair.left => CategoryTheory.FunctorToTypes.coprod.inl
    | CategoryTheory.Limits.WalkingPair.right => CategoryTheory.FunctorToTypes.coprod.inr
-- CategoryTheory.FunctorToTypes.binaryCoproductCocone_pt_obj
@[simps!]
def binaryCoproductCocone : BinaryCofan F G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C)
Goal: (CategoryTheory.FunctorToTypes.binaryCoproductCocone F G).pt.obj a = (F.obj a ⊕ G.obj a)
-- CategoryTheory.FunctorToTypes.binaryCoproductCocone_pt_map
@[simps!]
def binaryCoproductCocone : BinaryCofan F G 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: ∀ {X Y : C} (f : X ⟶ Y) (x : F.obj X ⊕ G.obj X),
  (CategoryTheory.FunctorToTypes.binaryCoproductCocone F G).pt.map f x =
    Sum.rec (motive := fun t => x = t → F.obj Y ⊕ G.obj Y) (fun val h => Sum.inl (F.map f val))
      (fun val h => Sum.inr (G.map f val)) x ⋯
-- CategoryTheory.FunctorToTypes.binaryCoproductColimit_desc
@[simps]
def binaryCoproductColimit : IsColimit (binaryCoproductCocone F G) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (s : CategoryTheory.Limits.BinaryCofan F G)
Goal: (CategoryTheory.FunctorToTypes.binaryCoproductColimit F G).desc s =
  CategoryTheory.FunctorToTypes.coprod.desc s.inl s.inr
-- CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_hom
@[simp]
lemma inl_comp_binaryCoproductIso_hom :
    Limits.coprod.inl ≫ (binaryCoproductIso F G).hom = coprod.inl 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl
    (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom =
  CategoryTheory.FunctorToTypes.coprod.inl
-- CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_hom_apply
@[simp]
lemma inl_comp_binaryCoproductIso_hom_apply (a : C) (x : F.obj a) :
    (binaryCoproductIso F G).hom.app a ((Limits.coprod.inl (X := F)).app a x) = .inl x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (x : F.obj a)
Goal: (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom.app a (CategoryTheory.Limits.coprod.inl.app a x) = Sum.inl x
-- CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_hom
@[simp]
lemma inr_comp_binaryCoproductIso_hom :
    Limits.coprod.inr ≫ (binaryCoproductIso F G).hom = coprod.inr 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr
    (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom =
  CategoryTheory.FunctorToTypes.coprod.inr
-- CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_hom_apply
@[simp]
lemma inr_comp_binaryCoproductIso_hom_apply (a : C) (x : G.obj a) :
    (binaryCoproductIso F G).hom.app a ((Limits.coprod.inr (X := F)).app a x) = .inr x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (x : G.obj a)
Goal: (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom.app a (CategoryTheory.Limits.coprod.inr.app a x) = Sum.inr x
-- CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_inv
@[simp]
lemma inl_comp_binaryCoproductIso_inv :
    coprod.inl ≫ (binaryCoproductIso F G).inv = (Limits.coprod.inl (X := F)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: CategoryTheory.CategoryStruct.comp CategoryTheory.FunctorToTypes.coprod.inl
    (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv =
  CategoryTheory.Limits.coprod.inl
-- CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_inv_apply
@[simp]
lemma inl_comp_binaryCoproductIso_inv_apply (a : C) (x : F.obj a) :
    (binaryCoproductIso F G).inv.app a (.inl x) = (Limits.coprod.inl (X := F)).app a x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (x : F.obj a)
Goal: (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv.app a (Sum.inl x) = CategoryTheory.Limits.coprod.inl.app a x
-- CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_inv
@[simp]
lemma inr_comp_binaryCoproductIso_inv :
    coprod.inr ≫ (binaryCoproductIso F G).inv = (Limits.coprod.inr (X := F)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w))
Goal: CategoryTheory.CategoryStruct.comp CategoryTheory.FunctorToTypes.coprod.inr
    (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv =
  CategoryTheory.Limits.coprod.inr
-- CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_inv_apply
@[simp]
lemma inr_comp_binaryCoproductIso_inv_apply (a : C) (x : G.obj a) :
    (binaryCoproductIso F G).inv.app a (.inr x) = (Limits.coprod.inr (X := F)).app a x 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (x : G.obj a)
Goal: (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv.app a (Sum.inr x) = CategoryTheory.Limits.coprod.inr.app a x
-- CategoryTheory.FunctorToTypes.binaryCoproductEquiv_symm_apply
@[simps]
noncomputable
def binaryCoproductEquiv (a : C) :
    (F ⨿ G).obj a ≃ (F.obj a) ⊕ (G.obj a) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (z : F.obj a ⊕ G.obj a)
Goal: (CategoryTheory.FunctorToTypes.binaryCoproductEquiv F G a).symm z =
  (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv.app a z
-- CategoryTheory.FunctorToTypes.binaryCoproductEquiv_apply
@[simps]
noncomputable
def binaryCoproductEquiv (a : C) :
    (F ⨿ G).obj a ≃ (F.obj a) ⊕ (G.obj a) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C) (z : (F ⨿ G).obj a)
Goal: (CategoryTheory.FunctorToTypes.binaryCoproductEquiv F G a) z =
  (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom.app a z
-- CategoryTheory.Over.ConstructProducts.conesEquivInverseObj_π_app
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) {J : Type w} (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B) (c : CategoryTheory.Limits.Cone F) (X : CategoryTheory.Limits.WidePullbackShape J)
Goal: (CategoryTheory.Over.ConstructProducts.conesEquivInverseObj B F c).π.app X =
  Option.casesOn X c.pt.hom fun j => (c.π.app { as := j }).left
-- CategoryTheory.Over.ConstructProducts.conesEquivInverseObj_pt
@[simps]
def conesEquivInverseObj (B : C) {J : Type w} (F : Discrete J ⥤ Over B) (c : Cone F) :
    Cone (widePullbackDiagramOfDiagramOver B F) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) {J : Type w} (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B) (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Over.ConstructProducts.conesEquivInverseObj B F c).pt = c.pt.left
-- CategoryTheory.Over.ConstructProducts.conesEquivInverse_map_hom
@[simps]
def conesEquivInverse (B : C) {J : Type w} (F : Discrete J ⥤ Over B) :
    Cone F ⥤ Cone (widePullbackDiagramOfDiagramOver B F) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) {J : Type w} (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B)
Goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y),
  ((CategoryTheory.Over.ConstructProducts.conesEquivInverse B F).map f).hom = f.hom.left
-- CategoryTheory.Over.ConstructProducts.conesEquivInverse_obj
@[simps]
def conesEquivInverse (B : C) {J : Type w} (F : Discrete J ⥤ Over B) :
    Cone F ⥤ Cone (widePullbackDiagramOfDiagramOver B F) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) {J : Type w} (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B) (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Over.ConstructProducts.conesEquivInverse B F).obj c =
  CategoryTheory.Over.ConstructProducts.conesEquivInverseObj B F c
-- CategoryTheory.Over.ConstructProducts.conesEquivFunctor_obj_pt
@[simps]
def conesEquivFunctor (B : C) {J : Type w} (F : Discrete J ⥤ Over B) :
    Cone (widePullbackDiagramOfDiagramOver B F) ⥤ Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) {J : Type w} (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B) (c : CategoryTheory.Limits.Cone (CategoryTheory.Over.ConstructProducts.widePullbackDiagramOfDiagramOver B F))
Goal: ((CategoryTheory.Over.ConstructProducts.conesEquivFunctor B F).obj c).pt = CategoryTheory.Over.mk (c.π.app none)
-- CategoryTheory.Over.ConstructProducts.conesEquivFunctor_obj_π_app
@[simps]
def conesEquivFunctor (B : C) {J : Type w} (F : Discrete J ⥤ Over B) :
    Cone (widePullbackDiagramOfDiagramOver B F) ⥤ Cone F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] (B : C) {J : Type w} (F : CategoryTheory.Discrete J ⥤ CategoryTheory.Over B) (c : CategoryTheory.Limits.Cone (CategoryTheory.Over.ConstructProducts.widePullbackDiagramOfDiagramOver B F))
Goal: ∀ (x : CategoryTheory.Discrete J),
  ((CategoryTheory.Over.ConstructProducts.conesEquivFunctor B F).obj c).π.app x =
    match x with
    | { as := j } => CategoryTheory.Over.homMk (c.π.app (some j)) ⋯