File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

full_name: CategoryTheory.FunctorToTypes.prod
code: /-- `prod F G` is the explicit binary product of type-valued functors `F` and `G`. -/
def prod : C ⥤ Type w 
goal: CategoryTheory.Functor C (Type w)

full_name: CategoryTheory.FunctorToTypes.prod.fst_app
code: /-- The first projection of `prod F G`, onto `F`. -/
@[simps]
def prod.fst : prod F G ⟶ F 
goal: ∀ (x : C) (a : (CategoryTheory.FunctorToTypes.prod F G).obj x), CategoryTheory.FunctorToTypes.prod.fst.app x a = a.1

full_name: CategoryTheory.FunctorToTypes.prod.fst
code: /-- The first projection of `prod F G`, onto `F`. -/
@[simps]
def prod.fst : prod F G ⟶ F 
goal: CategoryTheory.FunctorToTypes.prod F G ⟶ F

full_name: CategoryTheory.FunctorToTypes.prod.snd
code: /-- The second projection of `prod F G`, onto `G`. -/
@[simps]
def prod.snd : prod F G ⟶ G 
goal: CategoryTheory.FunctorToTypes.prod F G ⟶ G

full_name: CategoryTheory.FunctorToTypes.prod.snd_app
code: /-- The second projection of `prod F G`, onto `G`. -/
@[simps]
def prod.snd : prod F G ⟶ G 
goal: ∀ (x : C) (a : (CategoryTheory.FunctorToTypes.prod F G).obj x), CategoryTheory.FunctorToTypes.prod.snd.app x a = a.2

full_name: CategoryTheory.FunctorToTypes.prod.lift
code: /-- Given natural transformations `F ⟶ F₁` and `F ⟶ F₂`, construct
a natural transformation `F ⟶ prod F₁ F₂`. -/
@[simps]
def prod.lift {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :
    F ⟶ prod F₁ F₂ 
goal: F ⟶ CategoryTheory.FunctorToTypes.prod F₁ F₂

full_name: CategoryTheory.FunctorToTypes.prod.lift_app
code: /-- Given natural transformations `F ⟶ F₁` and `F ⟶ F₂`, construct
a natural transformation `F ⟶ prod F₁ F₂`. -/
@[simps]
def prod.lift {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :
    F ⟶ prod F₁ F₂ 
goal: (CategoryTheory.FunctorToTypes.prod.lift τ₁ τ₂).app x y = (τ₁.app x y, τ₂.app x y)

full_name: CategoryTheory.FunctorToTypes.prod.lift_fst
code: @[simp]
lemma prod.lift_fst {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :
    prod.lift τ₁ τ₂ ≫ prod.fst = τ₁ 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.prod.lift τ₁ τ₂)
    CategoryTheory.FunctorToTypes.prod.fst =
  τ₁

full_name: CategoryTheory.FunctorToTypes.prod.lift_snd
code: @[simp]
lemma prod.lift_snd {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :
    prod.lift τ₁ τ₂ ≫ prod.snd = τ₂ 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.prod.lift τ₁ τ₂)
    CategoryTheory.FunctorToTypes.prod.snd =
  τ₂

full_name: CategoryTheory.FunctorToTypes.binaryProductCone_pt_obj
code: /-- The binary fan whose point is `prod F G`. -/
@[simps!]
def binaryProductCone : BinaryFan F G 
goal: (CategoryTheory.FunctorToTypes.binaryProductCone F G).pt.obj a = (F.obj a × G.obj a)

full_name: CategoryTheory.FunctorToTypes.binaryProductCone_pt_map
code: /-- The binary fan whose point is `prod F G`. -/
@[simps!]
def binaryProductCone : BinaryFan F G 
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)

full_name: CategoryTheory.FunctorToTypes.binaryProductCone_π_app
code: /-- The binary fan whose point is `prod F G`. -/
@[simps!]
def binaryProductCone : BinaryFan F G 
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

full_name: CategoryTheory.FunctorToTypes.binaryProductCone
code: /-- The binary fan whose point is `prod F G`. -/
@[simps!]
def binaryProductCone : BinaryFan F G 
goal: CategoryTheory.Limits.BinaryFan F G

full_name: CategoryTheory.FunctorToTypes.binaryProductLimit
code: /-- `prod F G` is a limit cone. -/
@[simps]
def binaryProductLimit : IsLimit (binaryProductCone F G) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.FunctorToTypes.binaryProductCone F G)

full_name: CategoryTheory.FunctorToTypes.binaryProductLimit_lift
code: /-- `prod F G` is a limit cone. -/
@[simps]
def binaryProductLimit : IsLimit (binaryProductCone F G) 
goal: (CategoryTheory.FunctorToTypes.binaryProductLimit F G).lift s = CategoryTheory.FunctorToTypes.prod.lift s.fst s.snd

full_name: CategoryTheory.FunctorToTypes.binaryProductLimitCone
code: /-- `prod F G` is a binary product for `F` and `G`. -/
def binaryProductLimitCone : Limits.LimitCone (pair F G) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair F G)

full_name: CategoryTheory.FunctorToTypes.binaryProductIso
code: /-- The categorical binary product of type-valued functors is `prod F G`. -/
noncomputable def binaryProductIso : F ⨯ G ≅ prod F G 
goal: F ⨯ G ≅ CategoryTheory.FunctorToTypes.prod F G

full_name: CategoryTheory.FunctorToTypes.binaryProductIso_hom_comp_fst
code: @[simp]
lemma binaryProductIso_hom_comp_fst :
    (binaryProductIso F G).hom ≫ prod.fst = Limits.prod.fst 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.binaryProductIso F G).hom
    CategoryTheory.FunctorToTypes.prod.fst =
  CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.FunctorToTypes.binaryProductIso_hom_comp_snd
code: @[simp]
lemma binaryProductIso_hom_comp_snd :
    (binaryProductIso F G).hom ≫ prod.snd = Limits.prod.snd 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.binaryProductIso F G).hom
    CategoryTheory.FunctorToTypes.prod.snd =
  CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_fst
code: @[simp]
lemma binaryProductIso_inv_comp_fst :
    (binaryProductIso F G).inv ≫ Limits.prod.fst = prod.fst 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.binaryProductIso F G).inv
    CategoryTheory.Limits.prod.fst =
  CategoryTheory.FunctorToTypes.prod.fst

full_name: CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_fst_apply
code: @[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 
goal: CategoryTheory.Limits.prod.fst.app a ((CategoryTheory.FunctorToTypes.binaryProductIso F G).inv.app a z) = z.1

full_name: CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_snd
code: @[simp]
lemma binaryProductIso_inv_comp_snd :
    (binaryProductIso F G).inv ≫ Limits.prod.snd = prod.snd 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.FunctorToTypes.binaryProductIso F G).inv
    CategoryTheory.Limits.prod.snd =
  CategoryTheory.FunctorToTypes.prod.snd

full_name: CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_snd_apply
code: @[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 
goal: CategoryTheory.Limits.prod.snd.app a ((CategoryTheory.FunctorToTypes.binaryProductIso F G).inv.app a z) = z.2

full_name: CategoryTheory.FunctorToTypes.prodMk
code: /-- Construct an element of `(F ⨯ G).obj a` from an element of `F.obj a` and
an element of `G.obj a`. -/
noncomputable
def prodMk {a : C} (x : F.obj a) (y : G.obj a) : (F ⨯ G).obj a 
goal: (F ⨯ G).obj a

full_name: CategoryTheory.FunctorToTypes.prodMk_fst
code: @[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 
goal: CategoryTheory.Limits.prod.fst.app a (CategoryTheory.FunctorToTypes.prodMk x y) = x

full_name: CategoryTheory.FunctorToTypes.prodMk_snd
code: @[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 
goal: CategoryTheory.Limits.prod.snd.app a (CategoryTheory.FunctorToTypes.prodMk x y) = y

full_name: CategoryTheory.FunctorToTypes.prod_ext
code: @[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 
goal: z = w

full_name: CategoryTheory.FunctorToTypes.binaryProductEquiv_symm_apply
code: /-- `(F ⨯ G).obj a` is in bijection with the product of `F.obj a` and `G.obj a`. -/
@[simps]
noncomputable
def binaryProductEquiv (a : C) : (F ⨯ G).obj a ≃ (F.obj a) × (G.obj a) 
goal: (CategoryTheory.FunctorToTypes.binaryProductEquiv F G a).symm z = CategoryTheory.FunctorToTypes.prodMk z.1 z.2

full_name: CategoryTheory.FunctorToTypes.binaryProductEquiv
code: /-- `(F ⨯ G).obj a` is in bijection with the product of `F.obj a` and `G.obj a`. -/
@[simps]
noncomputable
def binaryProductEquiv (a : C) : (F ⨯ G).obj a ≃ (F.obj a) × (G.obj a) 
goal: (F ⨯ G).obj a ≃ F.obj a × G.obj a

full_name: CategoryTheory.FunctorToTypes.binaryProductEquiv_apply
code: /-- `(F ⨯ G).obj a` is in bijection with the product of `F.obj a` and `G.obj a`. -/
@[simps]
noncomputable
def binaryProductEquiv (a : C) : (F ⨯ G).obj a ≃ (F.obj a) × (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)

full_name: CategoryTheory.FunctorToTypes.prod_ext'
code: @[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 
goal: z = w

full_name: CategoryTheory.FunctorToTypes.coprod
code: /-- `coprod F G` is the explicit binary coproduct of type-valued functors `F` and `G`. -/
def coprod : C ⥤ Type w 
goal: CategoryTheory.Functor C (Type w)

full_name: CategoryTheory.FunctorToTypes.coprod.inl
code: /-- The left inclusion of `F` into `coprod F G`. -/
@[simps]
def coprod.inl : F ⟶ coprod F G 
goal: F ⟶ CategoryTheory.FunctorToTypes.coprod F G

full_name: CategoryTheory.FunctorToTypes.coprod.inl_app
code: /-- The left inclusion of `F` into `coprod F G`. -/
@[simps]
def coprod.inl : F ⟶ coprod F G 
goal: ∀ (x : C) (x_1 : F.obj x), CategoryTheory.FunctorToTypes.coprod.inl.app x x_1 = Sum.inl x_1

full_name: CategoryTheory.FunctorToTypes.coprod.inr_app
code: /-- The right inclusion of `G` into `coprod F G`. -/
@[simps]
def coprod.inr : G ⟶ coprod F G 
goal: ∀ (x : C) (x_1 : G.obj x), CategoryTheory.FunctorToTypes.coprod.inr.app x x_1 = Sum.inr x_1

full_name: CategoryTheory.FunctorToTypes.coprod.inr
code: /-- The right inclusion of `G` into `coprod F G`. -/
@[simps]
def coprod.inr : G ⟶ coprod F G 
goal: G ⟶ CategoryTheory.FunctorToTypes.coprod F G

full_name: CategoryTheory.FunctorToTypes.coprod.desc_app
code: /-- Given natural transformations `F₁ ⟶ F` and `F₂ ⟶ F`, construct
a natural transformation `coprod F₁ F₂ ⟶ F`. -/
@[simps]
def coprod.desc {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) :
    coprod F₁ F₂ ⟶ F 
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) ⋯

full_name: CategoryTheory.FunctorToTypes.coprod.desc
code: /-- Given natural transformations `F₁ ⟶ F` and `F₂ ⟶ F`, construct
a natural transformation `coprod F₁ F₂ ⟶ F`. -/
@[simps]
def coprod.desc {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) :
    coprod F₁ F₂ ⟶ F 
goal: CategoryTheory.FunctorToTypes.coprod F₁ F₂ ⟶ F

full_name: CategoryTheory.FunctorToTypes.coprod.desc_inl
code: @[simp]
lemma coprod.desc_inl {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) :
    coprod.inl ≫ coprod.desc τ₁ τ₂ = τ₁ 
goal: CategoryTheory.CategoryStruct.comp CategoryTheory.FunctorToTypes.coprod.inl
    (CategoryTheory.FunctorToTypes.coprod.desc τ₁ τ₂) =
  τ₁

full_name: CategoryTheory.FunctorToTypes.coprod.desc_inr
code: @[simp]
lemma coprod.desc_inr {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) :
    coprod.inr ≫ coprod.desc τ₁ τ₂ = τ₂ 
goal: CategoryTheory.CategoryStruct.comp CategoryTheory.FunctorToTypes.coprod.inr
    (CategoryTheory.FunctorToTypes.coprod.desc τ₁ τ₂) =
  τ₂

full_name: CategoryTheory.FunctorToTypes.binaryCoproductCocone_ι_app
code: /-- The binary cofan whose point is `coprod F G`. -/
@[simps!]
def binaryCoproductCocone : BinaryCofan F G 
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

full_name: CategoryTheory.FunctorToTypes.binaryCoproductCocone
code: /-- The binary cofan whose point is `coprod F G`. -/
@[simps!]
def binaryCoproductCocone : BinaryCofan F G 
goal: CategoryTheory.Limits.BinaryCofan F G

full_name: CategoryTheory.FunctorToTypes.binaryCoproductCocone_pt_obj
code: /-- The binary cofan whose point is `coprod F G`. -/
@[simps!]
def binaryCoproductCocone : BinaryCofan F G 
goal: (CategoryTheory.FunctorToTypes.binaryCoproductCocone F G).pt.obj a = (F.obj a ⊕ G.obj a)

full_name: CategoryTheory.FunctorToTypes.binaryCoproductCocone_pt_map
code: /-- The binary cofan whose point is `coprod F G`. -/
@[simps!]
def binaryCoproductCocone : BinaryCofan F G 
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 ⋯

full_name: CategoryTheory.FunctorToTypes.binaryCoproductColimit_desc
code: /-- `coprod F G` is a colimit cocone. -/
@[simps]
def binaryCoproductColimit : IsColimit (binaryCoproductCocone F G) 
goal: (CategoryTheory.FunctorToTypes.binaryCoproductColimit F G).desc s =
  CategoryTheory.FunctorToTypes.coprod.desc s.inl s.inr

full_name: CategoryTheory.FunctorToTypes.binaryCoproductColimit
code: /-- `coprod F G` is a colimit cocone. -/
@[simps]
def binaryCoproductColimit : IsColimit (binaryCoproductCocone F G) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.FunctorToTypes.binaryCoproductCocone F G)

full_name: CategoryTheory.FunctorToTypes.binaryCoproductColimitCocone
code: /-- `coprod F G` is a binary coproduct for `F` and `G`. -/
def binaryCoproductColimitCocone : Limits.ColimitCocone (pair F G) 
goal: CategoryTheory.Limits.ColimitCocone (CategoryTheory.Limits.pair F G)

full_name: CategoryTheory.FunctorToTypes.binaryCoproductIso
code: /-- The categorical binary coproduct of type-valued functors is `coprod F G`. -/
noncomputable def binaryCoproductIso : F ⨿ G ≅ coprod F G 
goal: F ⨿ G ≅ CategoryTheory.FunctorToTypes.coprod F G

full_name: CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_hom
code: @[simp]
lemma inl_comp_binaryCoproductIso_hom :
    Limits.coprod.inl ≫ (binaryCoproductIso F G).hom = coprod.inl 
goal: CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl
    (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom =
  CategoryTheory.FunctorToTypes.coprod.inl

full_name: CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_hom_apply
code: @[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 
goal: (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom.app a (CategoryTheory.Limits.coprod.inl.app a x) = Sum.inl x

full_name: CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_hom
code: @[simp]
lemma inr_comp_binaryCoproductIso_hom :
    Limits.coprod.inr ≫ (binaryCoproductIso F G).hom = coprod.inr 
goal: CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr
    (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom =
  CategoryTheory.FunctorToTypes.coprod.inr

full_name: CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_hom_apply
code: @[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 
goal: (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom.app a (CategoryTheory.Limits.coprod.inr.app a x) = Sum.inr x

full_name: CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_inv
code: @[simp]
lemma inl_comp_binaryCoproductIso_inv :
    coprod.inl ≫ (binaryCoproductIso F G).inv = (Limits.coprod.inl (X := F)) 
goal: CategoryTheory.CategoryStruct.comp CategoryTheory.FunctorToTypes.coprod.inl
    (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv =
  CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_inv_apply
code: @[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 
goal: (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv.app a (Sum.inl x) = CategoryTheory.Limits.coprod.inl.app a x

full_name: CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_inv
code: @[simp]
lemma inr_comp_binaryCoproductIso_inv :
    coprod.inr ≫ (binaryCoproductIso F G).inv = (Limits.coprod.inr (X := F)) 
goal: CategoryTheory.CategoryStruct.comp CategoryTheory.FunctorToTypes.coprod.inr
    (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv =
  CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_inv_apply
code: @[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 
goal: (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv.app a (Sum.inr x) = CategoryTheory.Limits.coprod.inr.app a x

full_name: CategoryTheory.FunctorToTypes.coprodInl
code: /-- Construct an element of `(F ⨿ G).obj a` from an element of `F.obj a` -/
noncomputable
abbrev coprodInl {a : C} (x : F.obj a) : (F ⨿ G).obj a 
goal: (F ⨿ G).obj a

full_name: CategoryTheory.FunctorToTypes.coprodInr
code: /-- Construct an element of `(F ⨿ G).obj a` from an element of `G.obj a` -/
noncomputable
abbrev coprodInr {a : C} (x : G.obj a) : (F ⨿ G).obj a 
goal: (F ⨿ G).obj a

full_name: CategoryTheory.FunctorToTypes.binaryCoproductEquiv
code: /-- `(F ⨿ G).obj a` is in bijection with disjoint union of `F.obj a` and `G.obj a`. -/
@[simps]
noncomputable
def binaryCoproductEquiv (a : C) :
    (F ⨿ G).obj a ≃ (F.obj a) ⊕ (G.obj a) 
goal: (F ⨿ G).obj a ≃ F.obj a ⊕ G.obj a

full_name: CategoryTheory.FunctorToTypes.binaryCoproductEquiv_symm_apply
code: /-- `(F ⨿ G).obj a` is in bijection with disjoint union of `F.obj a` and `G.obj a`. -/
@[simps]
noncomputable
def binaryCoproductEquiv (a : C) :
    (F ⨿ G).obj a ≃ (F.obj a) ⊕ (G.obj a) 
goal: (CategoryTheory.FunctorToTypes.binaryCoproductEquiv F G a).symm z =
  (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv.app a z

full_name: CategoryTheory.FunctorToTypes.binaryCoproductEquiv_apply
code: /-- `(F ⨿ G).obj a` is in bijection with disjoint union of `F.obj a` and `G.obj a`. -/
@[simps]
noncomputable
def binaryCoproductEquiv (a : C) :
    (F ⨿ G).obj a ≃ (F.obj a) ⊕ (G.obj a) 
goal: (CategoryTheory.FunctorToTypes.binaryCoproductEquiv F G a) z =
  (CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom.app a z